Agile — Scrum (sprints, roles, ceremonies), Kanban: Visual walkthrough

We will build three ideas — stock, flow, and wait — from a picture of cards crossing a board, and show they must lock together into one equation.

Step 1 — The board and three plain-English quantities

WHAT. Picture a task board. Cards enter on the left ("To Do"), crawl rightward through columns, and exit on the right ("Done"). Nothing else. We name three things we can literally count or time.

WHY. Before any formula, every symbol must mean something you could measure with your eyes and a stopwatch. If we can't point at it on the board, we don't get to use a letter for it.

PICTURE. Look at the board below. The three quantities are colour-coded and we'll keep those colours for the whole page.

Reveal-check:

L

is a count at one instant — is it a rate?

No.

L

has no "per week" in it; it's a plain number of cards, a snapshot.

λ

carries units of

cards per unit time (e.g. cards/week) — it's a rate of leaving.

W

carries units of

time (e.g. weeks) — how long one card lingers.

Step 2 — The one assumption: a steady system

WHAT. We assume the board is in steady state: over the window we look at, cards arrive at the same average rate they depart. The size of the queue isn't exploding or draining to zero — it hovers.

WHY. Without this, the counting trick falls apart: if cards pour in faster than they leave, $L$ grows without bound and there's no single "average" to talk about. Steady state is what makes "in = out" true and lets us pin down one number. This is the same stability idea behind Little's Law anywhere it's used.

PICTURE. Two taps and a tank. Water in at rate $λ_{in}$ , water out at rate $λ_{out}$ . Steady state = the two taps are matched, so the water level (that's $L$ ) holds flat.

$λ_{in} = λ_{out} = λ$

$λ_{in}$ — cards entering per week (the top tap).
$λ_{out}$ — cards leaving per week (the bottom tap).
When they're equal we just call the shared value $λ$ — the single throughput.

Step 3 — Follow ONE card through time

WHAT. Zoom in on a single card. It appears on the board, sits there for a duration $W$ , then leaves. Draw that as a horizontal bar on a timeline: the bar's length is $W$ .

WHY. We're building toward "how much card-time is on the board". The natural atom of that is one card × the time it stays — a bar of length $W$ . Getting this atom right is the whole derivation.

PICTURE. A timeline (time runs left→right). Our card is a yellow bar starting when it enters, ending when it exits. Its horizontal length is $W$ .

Step 4 — Stack every card's bar — the total is an area, counted two ways

WHAT. Now draw all the cards' bars stacked on the same timeline over a long observation window of length $T$ . Each card is one horizontal bar of length $W_{i}$ (its own lead time). The total shaded area = total card-time.

WHY. An area you can measure two independent ways gives an equation. That's the trick: compute the same shaded region horizontally (per card) and vertically (per instant), then set them equal.

PICTURE. Bars stacked; we slice the picture two ways with dashed guides.

Horizontal count (per card). Each card contributes a bar of length $W_{i}$ . If $N$ cards passed through in total, the area is the sum of all bar lengths: $Area = \sum_{i = 1}^{N} W_{i} = N \cdot \overset{ˉ}{W}$

$N$ — total number of cards that flowed through during the window.
$W_{i}$ — the $i$ -th card's own lead time (its bar length).
$\overset{ˉ}{W}$ — the average lead time, $\frac{1}{N} \sum W_{i}$ ; so the sum is just $N$ times the average. This $\overset{ˉ}{W}$ is what we call $W$ .

Vertical count (per instant). At any moment, the number of bars the vertical line crosses = the number of cards on the board right then = $L$ at that instant. Sweeping the line across the whole window $T$ and adding up: $Area = \overset{ˉ}{L} \cdot T$

$\overset{ˉ}{L}$ — the average height of the stack = average number of cards on the board = the $L$ we defined.
$T$ — the length of the observation window.

Step 5 — Set the two counts equal and simplify

WHAT. The same area computed two ways must agree. Equate them: $N \cdot \overset{ˉ}{W} = \overset{ˉ}{L} \cdot T$

WHY. It's one region of the plane; its area is a single number no matter how you slice it. So the two expressions are forced equal — that's the whole engine.

PICTURE. The two slicing directions overlaid — same shaded blob, two rulers.

Now divide both sides by $T$ : $\frac{N}{T} \cdot \overset{ˉ}{W} = \overset{ˉ}{L}$

Look hard at $\frac{N}{T}$ : it's cards that passed through, divided by the time window — that is cards per unit time — which is exactly the throughput $λ$ ! So: $\overset{ˉ}{L} = \frac{N}{T} \overset{ˉ}{W} = λ \overset{ˉ}{W}$

Dropping the bars (all three are understood as averages), we land the result:

Reveal-check:

Which two counts of the same area did we equate?

Horizontal

N \overset{ˉ}{W}

(per card) and vertical

\overset{ˉ}{L} T

(per instant).

Where did

λ

come from algebraically?

From

N / T

— total cards divided by the window = cards per unit time.

Step 6 — The lever: rearrange for the thing customers feel

WHAT. Solve for $W$ , the wait — that's what a customer experiences as "how long till my thing ships": $W = \frac{L}{λ}$

WHY. Kanban's goal is short lead time. This form shows the two — and only two — knobs: shrink $L$ or grow $λ$ . Since forcing throughput $λ$ higher (hire, work faster) is hard and often backfires, Kanban pulls the easy lever: cap $L$ with a WIP limit. See the parent note for the WIP rule itself, and Lean Manufacturing for where this idea was born.

PICTURE. Two dials, $L$ and $λ$ , feeding an output gauge $W = L / λ$ . Turning $L$ down drops $W$ immediately.

Step 7 — Edge and degenerate cases (never leave a gap)

WHAT + WHY + PICTURE. A law you'll trust must survive its extremes. Four corners:

Definition The corner cases

$L = 0$ (empty board). No cards in progress ⇒ $W = 0/ λ = 0$ . Nothing waits because nothing is here. Consistent. (Left panel: flat empty tank.)
WIP limit $= 1$ . Only one card allowed in flight. Then $L = 1$ and $W = 1/ λ$ — the shortest possible wait for a given throughput. This is a true assembly line: finish before you start. (Second panel.)
$λ \to 0$ (nobody finishing). Denominator heads to zero, so $W = L / λ \to \infty$ . Cards pile up forever, waits explode. This is the "everything is 90% done" traffic jam the parent warned about — the formula predicts it. (Third panel: level rising, out-tap shut.)
Not steady ( $λ_{in} > λ_{out}$ ). Our derivation required in = out. Break that and $L$ grows with time, so there's no single average $L$ — the law doesn't apply as a fixed number; it only holds over a window long enough that the tank levels out. (Right panel: level climbing, law greyed out.)

The one-picture summary

One figure, the whole argument: cards as bars over a timeline → area counted per-card ( $N \overset{ˉ}{W}$ ) and per-instant ( $\overset{ˉ}{L} T$ ) → equate → divide by $T$ → $λ = N / T$ pops out → $L = λW$ → rearrange to $W = L / λ$ → cap $L$ to cut $W$ .

Recall Feynman retelling — say it like a story

Imagine a board where cards crawl from To-Do to Done. Three things you can watch: how many cards are on it right now (call it $L$ ), how many reach Done each week (call it $λ$ ), and how long one card sits there (call it $W$ ). Now the trick: draw every card as a bar on a timeline, as long as the time it stayed. Stack all the bars. That shaded shape has an area. Count it two ways — go card by card and you get "number of cards times their average stay". Slice it moment by moment and you get "average height of the stack times the total time". Same shape, so those two are equal. Cancel the total time from both sides and the number-of-cards-over-time turns into the finish rate $λ$ . What's left is $L = λW$ . Flip it: $W = L / λ$ . So to make each card finish faster, either finish more per week (hard) or keep fewer cards on the board at once (easy) — which is exactly why Kanban slaps a limit on work-in-progress. Empty board? Zero wait. Nobody finishing? Infinite wait. Start ten things at once? Everything's stuck at 90%. The picture told us all of it.

Related trails: Little's Law · Lean Manufacturing · Project Estimation & Story Points · Software Development Life Cycle (SDLC) · Continuous Integration & Delivery (CI-CD) · Waterfall Model