Skip to content
Tutorials Center
My learning

Topics

Lesson 11 of 29 ยท Flow and Metrics

Kanban and WIP Limits

Learn Kanban for software teams: visualize work, limit work in progress, use pull systems and measure cycle time and lead time, with runnable simulations.

Scrum organizes work into fixed-length Sprints. Kanban takes a different route: work flows continuously, and the team improves how smoothly it flows. There are no required roles or events. You start with the process you already have, make the work visible, and put a limit on how much can be in progress at once.

The word kanban is Japanese for "signboard" or "card". The method grew out of Toyota's production system and was adapted to knowledge work in the 2000s. In software it is used by support teams, operations teams, maintenance teams and many product teams, often mixed with Scrum (see Scrum, Kanban, XP and Lean Compared). This lesson covers the board, work in progress (WIP) limits, pull systems, and the two flow measures called cycle time and lead time.

The runnable examples are JavaScript stand-ins: a tiny board that obeys WIP limits, and a calculator for flow times. Real tools such as a Jira Kanban board do the same bookkeeping for you.

The core Kanban practices

Visualize Put every piece of work on a board.
Limit WIP Start less, finish more.
Manage flow Spot blockages and remove them.
Improve Change in small, measured steps.
1 / 2

Visualize the work

A Kanban board is a set of columns that show the stages work goes through, with a card for each item. A simple software board might look like this:

Backlog Doing Review Done
Group bookings Waiting list Cancel link Confirm email
Loyalty points Card payments Date picker

The columns should match how your team really works, not an idealized process. If code review is a separate wait, give it a column. Add the columns you need; remove the ones that nobody uses.

Visibility is useful because problems become obvious. A pile of cards in "Review" shows a bottleneck. An empty "Doing" column with a full Backlog shows the team is waiting on something. Cards usually show who owns the item, its type (bug, feature), and sometimes a due date or a "blocked" flag. Many boards use swimlanes, horizontal rows that separate kinds of work, such as an "expedite" lane for urgent production fixes.

Limit work in progress

The most distinctive Kanban rule is the WIP limit: a maximum number of items allowed in a column (or in the whole board) at the same time. When a column is full, nobody starts new work in it. Instead, the team helps finish what is already there.

This feels backwards at first. Surely more things started means more things done? In practice, the opposite is true, for these reasons:

  • Context switching is expensive. Juggling five tasks means constantly reloading each one into your head.
  • Half-finished work delivers nothing. A feature that is 90% done has no value to users, and its code gets stale.
  • Queues hide problems. With no limit, review requests pile up silently. With a limit, the pile blocks everyone and gets fixed.
  • Fewer items in flight means each finishes sooner. Less waiting means shorter cycle times.

Where do you set the limit? A common starting point is one or two items per person, or "number of people plus one" for the doing columns. Then adjust: if the board is often starved and people idle, raise the limit; if cards pile up and take forever, lower it. The right number is found by experiment, not by formula.

A WIP limit is a rule of the team, not a suggestion. When the limit is hit, the right reaction is "what is blocking us?", never "let's raise the limit just this once".

Pull systems

A WIP limit works because Kanban is a pull system. In a push system, someone assigns work to you whenever it shows up, whether or not you have time. In a pull system, you take the next item when you finish something and have room. Each stage pulls from the one before it:

flowchart LR
  B["Backlog"] -->|"pull when Doing has room"| D["Doing<br/>(limit 2)"]
  D -->|"pull when Review has room"| R["Review<br/>(limit 1)"]
  R --> X["Done"]

Work moves right only when the next column has room, which stops work from piling up.

Pull also gives a rule for what to do when you are free: first look for work to finish (from the right of the board), and only then start something new. Teams often say "stop starting, start finishing".

A WIP-limit board simulation

The stand-in below runs a small board with a limit of 2 on "Doing" and 1 on "Review". Six cards enter. Each card has a number of working days and then needs one day of review. Every simulated day, the code finishes reviews first, then pulls cards rightward if there is room, then pulls new cards into "Doing".

JS A Kanban board with WIP limits

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Look at day 4: card C is finished with its work, but "Review" still holds card B, so C must wait in "Doing" and keeps using a WIP slot. That is the system working as designed. The limit on Review pushes back on Doing, and Doing pushes back on the Backlog, so the team feels the bottleneck right away instead of discovering a mountain of unreviewed work later. Try raising Review to 2 and compare the days.

This is a model. It has no people, no interruptions and no variable review times. It is useful for seeing the mechanism, not for predicting a real team.

Lead time and cycle time

Kanban teams improve by measuring how long work takes, and two words appear everywhere:

  • Lead time is the time from when an item is requested (it enters the system) until it is delivered. This is the customer's view: "I asked on Monday and got it on Friday."
  • Cycle time is the time from when the team starts working on an item until it is finished. This is the team's view of its own process.

The difference between them is waiting time in the queue before work started. Some organizations define cycle time slightly differently (for example, from the first "In progress" column), so make sure your team's definition is written down. Both numbers are measured in elapsed days, not hours of effort.

Averages hide a lot. A few very slow items disappear in a mean. Most Kanban teams therefore look at percentiles: "85% of our items are finished within 6 days" is a much more useful promise to a customer than "our average is 3.6 days". A cycle time scatter plot (one dot per finished item) quickly shows the spread and the outliers worth investigating.

There is also a mathematical relationship between flow measures called Little's Law: on average, the number of items in progress equals the throughput (items finished per day) multiplied by the average cycle time. It shows why lowering WIP lowers cycle time when throughput stays the same, and it is why limits help. It is an average over a stable system, so use it as a sanity check, not an exact forecast.

Measure flow from dates

The second stand-in takes the three dates each item has (requested, started, finished) and computes lead time, cycle time, the waiting between, the 85th percentile, throughput and a Little's Law estimate.

JS Lead time, cycle time and percentiles

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The data shows lead time (6.7 days on average) is much longer than cycle time (3.6 days). Most of the customer's wait happens before work starts, in the queue. That insight points the team toward limiting what enters the system, not toward typing faster. These dates are made up, and with only seven items, the percentiles are rough. Real teams use many weeks of history.

Kanban or Scrum?

Kanban does not forbid Sprints, and Scrum does not forbid a WIP limit on the Sprint board. The practical differences:

  • Scrum has fixed-length iterations and planned commitments. Kanban delivers continuously and pulls work whenever there is capacity.
  • Scrum defines three roles. Kanban prescribes none, so you keep the roles you have.
  • Scrum changes happen between Sprints. Kanban lets priorities change any time, as long as WIP limits are respected.
  • Kanban fits work with unpredictable arrival, such as support requests and production bugs. Scrum fits product development where a goal for the next few weeks makes sense.

A hybrid often called Scrumban uses Sprints for planning and a Kanban board with WIP limits for flow. The Agile methods lesson compares the options in more depth, and the project Kanban Flow Simulator builds a larger model with forecasting.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is the main purpose of a WIP limit?

    A WIP limit caps the number of items in progress so the team finishes work before starting more. It makes blockages visible and shortens cycle time.
  2. 2. In a pull system, when does a developer take a new card?

    Pull means work is taken when there is capacity, not pushed on the team regardless of load.
  3. 3. A customer asks for a feature on Monday. The team starts it on Thursday and delivers it the next Tuesday. Which statement is correct?

    Lead time starts at the request (customer view). Cycle time starts when work begins (team view). The wait before work started is the difference.
  4. 4. Why do many Kanban teams quote a percentile, such as '85% of items finish within 6 days'?

    A few very slow items distort an average. A percentile states how often the team meets a given time, which is more useful for planning.

Summary

  • Kanban makes work visible on a board and improves how it flows, without fixed Sprints or required roles.
  • A WIP limit caps the items in progress. It exposes bottlenecks, reduces context switching and shortens cycle time.
  • Work is pulled when there is capacity. The motto is "stop starting, start finishing".
  • Lead time runs from request to delivery; cycle time runs from start to finish. Use percentiles rather than averages.
  • Little's Law links WIP, throughput and cycle time, which explains why less WIP means faster delivery.
  • Kanban suits continuous, unpredictable work and can be combined with Scrum.

Next, see how teams track progress over time with velocity, burndown and cumulative flow in Velocity, Burndown and Cumulative Flow.