Flow metrics: WIP, throughput, age, cycle time

The IT helpdesk of a college finished 140 requests in a 90-day stretch, about 11 a week, and the middle request took 3 days. Both numbers look healthy, yet on the last day 30 requests were still open and the oldest had been in progress for 41 days. Counting hours would have hidden that; counting work items shows it.

Kanban requires four measurements at a minimum: WIP, throughput, work item age and cycle time. You will compute all four from one board export of 170 items, read the chart the cycle times draw, and see which question each measurement answers and which it cannot. Every figure comes from that export.

The four counts a Kanban board must give you

The export has five columns: an id, a work item type, and the days the item was created, started and finished, with an empty cell where either has not happened. All four mandatory flow metricsflow metrics: The minimum set of measurements a Kanban system collects: work in progress, throughput, work item age and cycle time, each taken between the started and finished points the team has defined. are measured between the started and finished points of the team’s Definition of Workflow.

Work in progresswork in progress (WIP): The number of work items that have been started but not finished. One of the four flow metrics the Kanban Guide requires. More in “Lean flow: waste, Little's law and constraints” is the number of items started but not finished, counted at a moment rather than over a period. Here it was 6 at the end of week 7, 43 at the end of week 10 and 30 on day 90.

Throughputthroughput: The number of work items finished per unit of time, counted as whole items rather than estimated in points or hours. More in “Lean flow: waste, Little's law and constraints” is the number of items finished per unit of time: “the exact count of work items” (Kanban Guide), never an estimate in points or hours. This helpdesk finished 140 items in 90 days, 10.9 a week, with weekly counts from 5 to 17.

Work item agework item age: The elapsed time between the moment a work item started and today, so only items that have not finished yet have one. is how long an item has been in progress so far, so only unfinished items have one. It is the one measurement about work in front of the team: 30 items were open on day 90, the oldest for 41 days.

Cycle timecycle time: The elapsed time between the moment a work item starts and the moment it finishes, as the team has defined those two points. More in “Lean flow: waste, Little's law and constraints” is the elapsed time from an item’s start to its finish, so only finished items have one. Over the 90 days the median was 3 days, the longest took 32, and 85 % came in at or under 15 days. One program computes all four, week by week:

"""The four mandatory flow metrics of one Kanban board, from its export.

Reads board-export.csv beside this file: 170 work items of a college IT helpdesk
over 90 days, with the columns id, type, created, started and finished. An empty
started or finished column means the item has not started or has not finished.

Day 1 is the first day of the export, so every figure below is a day number and
nothing depends on a calendar. Cycle time and work item age count whole days
inclusive, so an item started and finished on one day took one day.

The service level expectation at the end comes from the first seven weeks alone,
the stretch before an end-of-term rush changed the system.
"""

import csv
import datetime as dt
import statistics

DAYS = 90
WEEKS = 12


def load(path: str = "board-export.csv") -> list[dict]:
    with open(path, newline="", encoding="utf-8") as handle:
        rows = list(csv.DictReader(handle))
    first = min(dt.date.fromisoformat(row["created"]) for row in rows)

    def day(value: str) -> int | None:
        if not value:
            return None
        return (dt.date.fromisoformat(value) - first).days + 1

    return [
        {
            "id": row["id"],
            "type": row["type"],
            "created": day(row["created"]),
            "started": day(row["started"]),
            "finished": day(row["finished"]),
        }
        for row in rows
    ]


def wip_on(items: list[dict], day: int) -> int:
    """Items started on or before this day and not finished by the end of it."""
    return sum(
        1
        for item in items
        if item["started"] is not None
        and item["started"] <= day
        and (item["finished"] is None or item["finished"] > day)
    )


def finished_in(items: list[dict], first: int, last: int) -> list[dict]:
    return [i for i in items if i["finished"] is not None and first <= i["finished"] <= last]


def percentile(values: list[int], pct: int) -> int:
    """Nearest rank: the smallest value with at least pct % of the items at or below it."""
    ordered = sorted(values)
    rank = -(-len(ordered) * pct // 100)
    return ordered[rank - 1]


def cycle_times(items: list[dict]) -> list[int]:
    return [i["finished"] - i["started"] + 1 for i in items]


def median(values: list[int]) -> str:
    """The median as it reads: 11.5 stays 11.5, 3.0 prints as 3."""
    return f"{statistics.median(values):g}"


board = load()
done = finished_in(board, 1, DAYS)
openwork = [i for i in board if i["started"] is not None and i["finished"] is None]
print(f"{len(board)} items arrived, {len(done)} finished, {len(openwork)} still open on day {DAYS}")
for day in (49, 70, DAYS):
    print(f"WIP on day {day:2d}: {wip_on(board, day):2d} items started and not finished")

print("\nweek  arrived  finished  WIP at week end")
for week in range(WEEKS):
    first, last = week * 7 + 1, week * 7 + 7
    arrived = sum(1 for i in board if first <= i["created"] <= last)
    print(f"{week + 1:4d}  {arrived:7d}  {len(finished_in(board, first, last)):8d}  {wip_on(board, last):15d}")
print(f"throughput: {len(done)} items in {DAYS} days = {len(done) / (DAYS / 7):.1f} a week")

ages = sorted(DAYS - i["started"] + 1 for i in openwork)
print(f"\nwork item age of the {len(ages)} open items: median {median(ages)}, oldest {ages[-1]} days")
whole = cycle_times(done)
print(
    f"cycle time of the {len(whole)} finished items: median {median(whole)},"
    f" 85th {percentile(whole, 85)}, 95th {percentile(whole, 95)}, longest {max(whole)} days"
)
stable = cycle_times(finished_in(board, 1, 49))
print(
    f"first seven weeks only ({len(stable)} finished): median {median(stable)},"
    f" 85th {percentile(stable, 85)}, 95th {percentile(stable, 95)} days"
)
print(f"SLE from those weeks: 85% of work items finish in {percentile(stable, 85)} days or less")

170 items arrived, 140 finished, 30 still open on day 90
WIP on day 49:  6 items started and not finished
WIP on day 70: 43 items started and not finished
WIP on day 90: 30 items started and not finished

week  arrived  finished  WIP at week end
   1       12        10                2
   2        9         5                6
   3        7        12                1
   4       12        11                2
   5       11         8                5
   6       10        12                3
   7       14        11                6
   8       22        10               18
   9       24        13               29
  10       23         9               43
  11        8        17               34
  12        8        14               28
throughput: 140 items in 90 days = 10.9 a week

work item age of the 30 open items: median 11.5, oldest 41 days
cycle time of the 140 finished items: median 3, 85th 15, 95th 27, longest 32 days
first seven weeks only (69 finished): median 2, 85th 5, 95th 8 days
SLE from those weeks: 85% of work items finish in 5 days or less

The week table is where they meet: weeks 1 to 7 keep 1 to 6 items open, while weeks 8 to 10 bring 22, 24 and 23 arrivals against finishes near 10, so WIP climbs to 43.

Every finished item on one chart, and the spread it shows

A median describes one item in the middle; a cycle-time scatterplotcycle-time scatterplot: A chart with one dot for every finished work item, placed at the day it finished and the number of days it took, so the whole spread of cycle times and its outliers are visible. shows all of them, one dot per finished item at the day it finished and the days it took:

Up to the dotted line at day 49 the dots stay in a band of 1 to 9 days; after it they climb, and all 20 items above the dashed 85th-percentile line at 15 days finished in weeks 8 to 12. A median hides that change.

A promise, two charts and a law take these counts further, each worked below. A service level expectation turns one percentile of past cycle times into a promise, such as 85 % of items inside a stated number of days. Aging WIPaging WIP: A view that sets the age of every unfinished work item beside the service level expectation, so slow work can be acted on while it is still open. sets each unfinished item’s age beside that expectation, so slow work is acted on before it is late. A cumulative flow diagramcumulative flow diagram: A chart that stacks the counts of work items in each state over time, so that a band which widens shows a growing queue in that state. stacks the item counts of each state over time, and a widening band is a growing queue. Little’s lawLittle's law: For a stable queue, the average number of items in the system equals the arrival rate times the average time an item spends in it: in flow words, work in progress equals throughput times cycle time. More in “Lean flow: waste, Little's law and constraints” relates the averages: average WIP divided by average throughput is the average time an item spends in the system.

The export is an ordinary CSV: MySmartCoPilot’s CSV editor sorts and filters its rows, and the line graph maker plots the program’s week table as two lines, WIP and finishes.

Setting a service level expectation, and aging the open work Pro: opens with a Pro, Premium or Ultimate pass

Reading a cumulative flow diagram, and using Little's law honestly Pro: opens with a Pro, Premium or Ultimate pass

Practise: the four counts on this board

Every answer below can be checked against the table the program printed:

Interview questions

Warm-up: how do work item age and cycle time differ, and what is each one for?

Both measure elapsed time from the moment an item started, but they look in opposite directions. Cycle time belongs to finished items and describes the past: the 140 finished requests had a median of 3 days and an 85th percentile of 15. Work item age belongs to open items and describes the present: 30 were open on day 90, the oldest for 41 days. Age is the number a team can still act on today.

Three harder questions follow: a promise asked of a team with no history, a widening band, and a forecast from a growing queue.

Key takeaways

• WIP, throughput, work item age and cycle time are the four measurements a Kanban system must collect, counted in whole items between the team’s own started and finished points.
• WIP is counted at a moment and throughput over a period, so 43 items open and 10.9 finished a week answer different questions.
• Work item age is the only one of the four about unfinished work, which is why the oldest open request here, at 41 days, appears in no cycle-time report.
• A scatterplot shows the whole spread: a median of 3 days and 20 items above 15 days.