# Kanban

**URL:** https://kaizumi.com/dictionary/kanban

**Description:** Kanban is a signal that lets you make or move one container. Five cards of 60 pieces cap the loop at 300 pieces.

**Japanese:** 看板 (kanban) — "signboard"

**Category:** lean-tools

**Tags:** flow, visual-management, foundational

## Sizing the loop | How many kanban cards do you need

You need enough cards to cover what you use while you wait for a refill. For example, imagine a work area that uses `120` pieces an hour. Getting a refill takes `2` hours. Each container holds `60` pieces.

That area needs `5` cards. That means the loop will never hold more than `300` pieces in total. If you cut the refill time in half, you only need `3` cards.

You can calculate this card count using a simple formula. The formula sizes a single loop between two steps: one step supplies the part, another step uses it, and a [store](/dictionary/supermarket) sits between them. Any [pull system](/dictionary/pull-system) uses this exact arithmetic, whether you work in a hospital, a warehouse, an office, or a factory.

```kz-formula
expr: Cards =
expr: ⌈ (D × LT × (1 + S)) ÷ C ⌉
var: D | **Average demand** at the process that uses the part, in pieces per period. Level it first. A spiky D sizes your loop for a peak that rarely arrives.
var: LT | **Honest refill time**, in the same period as D. Card leaves, queue, changeover, run, transport, full container back on the shelf. Not run time.
var: C | **Container quantity**, in pieces. One card, one container, always the same count.
var: S | **Safety factor as a decimal.** `0.20` means 20 percent. You apply it as `1 + S`, never as S alone.
var: ⌈ ⌉ | **Round up.** A loop holds whole cards. `4.8` cards is `5` cards.
```

Let us put those numbers into the formula. Demand is `120` pieces an hour, the refill takes `2` hours, each container holds `60` pieces, and you include a `20` percent safety factor. The formula returns three numbers. The card count is the only decision you have to make. The maximum inventory and the hours of supply come directly from that choice.

```kz-tiles
lead: Cards
tile: Cards | 5
tile: Max WIP | 300 | pcs
tile: Supply | 2.5 | hrs
```

```kz-callout
tone: warn
title: The bracket that costs you a factor of five.
p: The safety factor multiplies your whole demand figure. So the multiplier is `1.20`, not `0.20`.
p: Write `D × LT × S` instead, and the same inputs give you `48 ÷ 60 = 0.8`, which rounds up to `1` card. One card where the loop needs five. The line runs dry before lunch.
```

### Two ways to write the same formula

You can also write this formula by separating out the buffer: `Cards = ⌈ ((D × LT) + buffer) ÷ C ⌉`. It gives you the exact same result. If you set `buffer = D × LT × S` and factor out `D × LT`, then `240 + 48 = 288` gives you the same total as `240 × 1.20 = 288`. Use whichever version is easier for your team to read. They will always match.

There is another method that works differently. You break the lead time down into its separate steps: queue time, setup or changeover, processing time, transport, and the return of empty containers. You divide that total time by your [takt time](/dictionary/takt-time), and then you add cards to cover your batch sizes.

Use that method when your supplying step runs parts in batches instead of one at a time. You can size those production batches using [EPEI](/dictionary/epei), which measures the time between runs of the same part.

### A worked example

Imagine an assembly area uses `120` brackets an hour. A refill takes `2` hours from start to finish. Each container holds `60` brackets. Because this is a new setup, you carry a `20` percent safety buffer.

```kz-pass
title: Pass 1 — the loop as it runs today
step: Demand during LT = 120 × 2 = **240**
step: Buffer = 240 × 0.20 = **48**
step: Cards = ⌈ (240 + 48) ÷ 60 ⌉ = ⌈ 4.8 ⌉ = **5**
out: Five cards. The loop holds at most **300** pieces, or **2.5** hours of supply.
```

```kz-pass
title: Pass 2 — after you halve the refill time
step: Demand during LT = 120 × 1 = **120**
step: Buffer = 120 × 0.20 = **24**
step: Cards = ⌈ (120 + 24) ÷ 60 ⌉ = ⌈ 2.4 ⌉ = **3**
out: Three cards. The loop now holds at most **180** pieces, or **1.5** hours of supply.
```

Pass 2 shows why refill time matters. In the first pass, four cards covered what you used during the wait, and the fifth card served as your buffer. Cutting the wait time in half removed `120` pieces of stock from the loop. You did not have to change demand, container sizes, or the safety factor to achieve that.

Your card count is a result of your process, not a setting you pick. If the formula gives you a number that seems too high, your refill process takes too long. The real solution is to shorten the refill time. If you simply remove cards without speeding up the process, you will run out of parts about two hours later.

### How to pick the safety factor

When setting up a new loop, starting around `20` percent is common. As your deliveries become consistent and reliable, you can lower that number toward `10` percent. If you need more than `30` percent, the buffer is covering up bigger problems upstream. Instead of adding more [safety stock](/dictionary/safety-stock), look into why deliveries are late or inconsistent.

Use the number from the formula as a practical starting point. Set up the loop, run it, and observe how material moves. You might see containers piling up in one spot or running low in another. A calculation cannot account for every real-world variation in your building.

Recalculate when your conditions change instead of debating the numbers. Tracking [inventory turns](/dictionary/inventory-turns) over time will show everyone whether stock levels are improving.

## Two loops | Production kanban and withdrawal kanban

Kanban operates using two separate loops. A production kanban authorizes someone to make a container of parts. A withdrawal kanban authorizes someone to move a container from storage to where it is used. These two loops meet at the store, and nowhere else. Teams that confuse the two usually stall partway through a rollout.

```kz-figure
id: two-loops
caption: Dashed lines are signals travelling empty-handed. Solid lines are material. The store is the only place the two loops touch.
wide: true
```

|  | Production kanban | Withdrawal kanban |
|---|---|---|
| Tells you to | Make one container | Move one container |
| Travels between | The store and the process that makes the part | The store and the process that uses it |
| Starts when | Someone takes a container out of the store | Someone empties a container at the point of use |
| Controls | What you make, and in what order | What moves, and how often |
| Rides with | The container it belongs to | The handler on a fixed route |
| In a hospital | Sterile services reprocesses one tray set | A runner restocks one bin on the ward |

You see this exact same division in a hospital. A supply runner uses a card to move bins from the main storeroom to a patient bay. The sterile processing team works from their own card to clean and prepare surgical sets, and that card stays in their department. These are two distinct tasks with two different cards, meeting at a shared shelf.

Make sure the two types of cards look clearly different. Use different colours, different shapes, or separate card holders. If you use one generic card for both jobs, it becomes difficult to tell whether a shortage is caused by a production delay or a transport delay.

```kz-photo
src: /guides/toyota-assembly/supermarket.webp
alt: A worker pushes an empty three-tier trolley down a narrow aisle between tall racks of blue and grey open-front bins holding cables, clips and small brackets, with a yellow lane marked on the floor.
caption: **The store, where both loops meet.** Every bin has a fixed address and a fixed quantity. The card on the bin is what tells the supplying process to make another one.
width: 1920
height: 1072
```

```kz-photo
src: /guides/toyota-assembly/tugger-train.webp
alt: A driver in a high-visibility vest tows two flat trailers stacked with blue and grey plastic totes along a yellow-taped lane through an assembly hall.
caption: **The withdrawal loop on wheels.** A fixed-time route beats a call-when-empty runner, because you can predict it.
width: 1920
height: 1072
```

The frequency of your delivery route is part of your lead time. A scheduled [milk run](/dictionary/milk-run) adds its whole interval to the refill time of every part it moves. The formula turns those extra minutes into extra cards and more inventory. Cutting your route interval in half reduces stock just as effectively as cutting a setup time in half.

## The card | What goes on a kanban card

A standard kanban card contains eight fields. Each field answers a practical question so that handlers do not have to stop and ask what to do.

```kz-figure
id: card
caption: The card is an instruction, not a label. If a handler has to interpret it, a field is missing.
wide: true
```

Two of these fields directly connect to the formula. **Quantity per container** is the value C in the equation. If someone changes the quantity in a container without changing the card, your total stock changes without anyone approving it. **Card 3 of 5** makes the total card count clear and trackable.

Tracking individual cards is important. If a loop is designed for five cards but quietly runs on four, you have lost 20 percent of your planned stock without realizing it. Cards can easily end up in pockets, slip behind storage racks, or get thrown out inside empty boxes.

When every card is numbered, you can glance at the card board at the end of a shift and immediately spot if one is missing. That is a direct application of [visual management](/dictionary/visual-management) to your control system.

The other six fields make everyday handling clear. The card type indicates which loop the card belongs to. Listing both the part number and the part name helps workers catch mistakes. The **Make at** and **Return to** fields provide exact physical addresses. The barcode allows the card to be scanned into inventory software.

Both addresses must name specific locations. Labels like "Weld cell 3" or shelf location "A-14-3" work well. A vague label like "Stores" does not. A card that only says "Stores" often ends up on the wrong shelf, leaving the team short of a container that no one can locate.

The physical signal itself does not have to be a paper card. It can be a bin, a marked square on the floor, a golf ball sent down a tube, or an electronic record in software. That choice does not change the math. Only your container size and your refill time affect the arithmetic.

## The rules | Six rules that make kanban work

A kanban system relies on six basic rules to stay reliable. Toyota wrote them down in the 1950s and has not needed to revise them since. If you break these rules, the cards stop reflecting actual demand.

1. **Take only what the card says.** Take the exact part and the exact count only when you actually need it. Taking parts early creates clutter and hides real demand patterns.
2. **Make only what the cards ask for**, in the order the cards arrive. The order of incoming cards sets your production sequence, which maintains a first-in, first-out flow ([FIFO](/dictionary/fifo)).
3. **No card means no movement, and nothing made.** One card authorizes one container. This rule is what puts a strict cap on your total inventory, and it is the first rule people break when they are under pressure.
4. **A card always travels with its container.** A card without parts is an error, and parts without a card are also an error. Treat both cases as quality defects.
5. **Defects never pass to the next process.** Because a pull system runs with low stock, there are no extra piles of parts to hide mistakes. When a defect occurs, the line stops so you can fix it immediately, which is the core idea of [jidoka](/dictionary/jidoka).
6. **Cut the card count over time.** The number of cards in your loop shows how much extra inventory you carry to cover process delays and uncertainty.

Teams often overlook the sixth rule. They calculate the card count once, laminate the cards, and leave them alone for years. A card count that never changes over two years usually means no one is working to reduce lead times or improve process reliability.

These rules also show why kanban works hand in hand with production leveling, or [heijunka](/dictionary/heijunka). Because rule two requires you to make parts in the exact order cards arrive, large swings in customer orders will disrupt your supplying processes.

Leveling your schedule at your pacemaker process prevents these sudden disruptions. It also ensures that your average demand number D remains dependable.

## Limits | When kanban is the wrong choice

Kanban relies on regular repetition. It orders a replacement for something you just consumed, which only makes sense if you will need that same item again soon. If you do not have steady, repeated demand, kanban is usually the wrong approach.

```kz-compare
leftTitle: Use kanban when
left: You use the part regularly, weekly or more often
left: Demand moves inside a band the buffer covers, not by multiples
left: You know the refill time and it repeats
left: Quality is good enough that a full container works on arrival
left: You can afford to hold one loop's worth of the part
rightTitle: Skip kanban when
right: You make the part once and never repeat it
right: Demand swings further than the safety factor can cover
right: Refill time jumps around, so the card count only chases it
right: The part is perishable, dated, or costly to hold
right: The mix is so wide that your store would need hundreds of addresses
```

### Three ways a kanban loop fails

**High mix, low volume.** Every part number in a kanban loop requires its own storage location and a dedicated inventory buffer. If you have 400 part numbers that you use only twice a month each, kanban requires you to hold 400 separate loops of inventory. That ties up too much floor space and working capital. For rare parts, build or order them directly as needed, and save kanban for the everyday parts and supplies you use constantly.

**Refill time that jumps around.** The calculation depends on a predictable lead time. If a real refill can take anywhere from two hours to two days, no fixed card count will work properly. You will either run out of parts during long waits or hold far too much stock during short ones. Stabilize your delivery times first. Kanban works well only after your process is stable.

**Demand steps the loop cannot absorb.** A card count remains fixed until someone updates it. If demand suddenly increases by 40 percent, a loop sized for the old rate will run out of parts. Plan regular reviews—such as once a month—to recalculate your card counts whenever demand changes.

Even when kanban is a good fit, there is one common mistake to avoid.

**Kanban is not a schedule.** It does not decide what products you should build for customers. It simply reacts to what you have already used. Customer orders set the schedule at your primary process, and kanban authorizes the replenishment of parts behind it. Teams that miss this difference build to a forecast and call it [just-in-time](/dictionary/just-in-time).

## Simulation | Watch a kanban loop run

Run the simulation below to follow a single card. The card leaves the point of use when a container is emptied, travels to the store, and returns with a full container. The formula on this page determines how many cards travel that route.

<!--SIM:kanban-->

Watch the storage area closely. If the shelves run completely empty, the loop has too few cards or the refill time is too long. If the shelves are always full of containers, the loop has too many cards. You can see both problems on the physical shelves long before they appear in an inventory report.

To see this calculation worked through in a factory setting, read [kanban in manufacturing](/guides/kanban-in-manufacturing). To see how kanban works with no factory involved, where the pick face is the store and the route is the milk run, read [kanban replenishment in a warehouse](/guides/kanban-replenishment-in-a-warehouse).

## Questions | Kanban questions people ask

```kz-qa
q: How do I calculate the number of kanban cards?
a: Multiply average demand by refill time in the same time unit. Multiply that by one plus the safety factor. Divide by the container quantity, then round up. At `120` pieces per hour, a `2` hour refill, `60` per container and `20` percent safety: `(120 × 2 × 1.20) ÷ 60 = 4.8`, so five cards.
q: What safety factor should I use?
a: Start near 20 percent on a new loop. Drive it toward 10 percent as delivery becomes reliable. Past 30 percent you are buying inventory to cover a problem you have not fixed yet.
q: What is the difference between a production kanban and a withdrawal kanban?
a: A production kanban tells someone to make one container. A withdrawal kanban tells someone to move one container from the store to the point of use. They meet at the store and nowhere else.
q: Is kanban the same as a kanban board?
a: They share the word and the idea of limiting work in process. A software kanban board limits tasks per column. A manufacturing kanban limits physical containers of one part, and the arithmetic on this page applies to the second one.
q: Does kanban reduce inventory?
a: It caps inventory, which is different. The cap is cards × container quantity, so `5 × 60 = 300` pieces. Your stock only falls when you shorten the refill time or shrink the container, because that is what lets you take a card out.
```

Source: https://kaizumi.com/dictionary/kanban
Licence: free to quote and cite with attribution to Kaizumi.