Skip to content
Mental Models

Bottlenecks & the Theory of Constraints

The Theory of Constraints

Eliyahu Goldratt turned 'find the bottleneck' into a procedure: the five focusing steps — identify, exploit, subordinate, elevate, repeat — for squeezing maximum output from any system without throwing money at it first.

12 min Updated Jun 28, 2026

You can now find the neck of the bottle. Last lesson handed you the eyes: a system runs at the speed of its slowest step, and you spot that step by the pile-up of work jamming up in front of it and the starved, idle stages waiting behind it. Genuinely useful. But it leaves the most pressing question completely unanswered. You’ve found the slow step. Now what do you actually do?

Standing in front of a constraint knowing it’s the constraint is like a doctor who can name your disease but has no treatment. This lesson is the treatment — a step-by-step procedure for governing a bottleneck that’s so clean it borders on a recipe. It has a name, an author, and a famous hiking troop, and by the end of it you’ll never look at a slow system the same way again.

Before you read — take a guess

Your build pipeline is slow. After measuring, you find the test stage is the bottleneck — everything queues behind it. You have a budget. What's the FIRST thing you should do?

Meet Goldratt (and Herbie)

In 1984, a physicist-turned-business-thinker named Eliyahu Goldratt published a novel — yes, a novel — called The Goal. It follows Alex Rogo, a plant manager who has ninety days to save his failing factory or watch it close. There are no lectures, just a man slowly realising that almost everything he believes about “efficiency” is making things worse. Out of that story Goldratt distilled the Theory of Constraints (TOC): the claim that every system has a tiny number of constraints — often exactly one — and that managing that constraint, rather than everything at once, is the entire job.

The book’s most famous scene has nothing to do with a factory. Alex takes a troop of Boy Scouts on a hike, and the line keeps stretching out and bunching up, never staying together. The culprit is Herbie — the slowest kid, weighed down by an overstuffed pack. The fast scouts race ahead, the gaps open, and the troop’s actual progress — when the whole line is counted as arrived — is set entirely by Herbie. The troop moves at Herbie’s pace whether anyone likes it or not.

That hike is the whole theory in one image. Herbie is the bottleneck. The trail is the process. The troop’s throughput is whatever Herbie can do. And the moves Alex eventually makes — put Herbie at the front, take weight out of his pack, make everyone walk at his speed — are, almost exactly, the five steps we’re about to learn.

Tip:

The one-sentence version

Goldratt’s Theory of Constraints says a system has very few constraints (usually one), and the way to improve the whole is to run a fixed five-step procedure on that constraint — not to optimise everything everywhere.

The five focusing steps

Here’s the spine of the whole lesson — and the whole practice of constraint management. Goldratt’s five focusing steps are a loop you run, in order, on whatever system you’re trying to speed up. The word “focusing” is doing real work: the steps exist precisely to stop you spreading your attention evenly across a system, which feels responsible and accomplishes nothing.

#StepOne-line jobCosts money?
1IdentifyFind the constraint — the slowest step, the one with the queue in frontNo
2ExploitWring maximum output from the constraint as it already isNo (that’s the point)
3SubordinateMake every other step run at the constraint’s paceNo
4ElevateNow spend money/effort to add capacity to the constraintYes
5RepeatConstraint moved? Go back to step 1. Don’t let inertia winNo

Steps 1 through 3 are free. That is not a coincidence — it’s the most important strategic fact in the whole method. You get to extract a startling amount of improvement before you spend a single dollar, and most organisations skip straight to step 4 and wonder why it was so expensive. Let’s take each step in turn.

1. Identify the constraint

Identify means: find the single step whose limited capacity caps the whole system. You already know how — it’s last lesson’s skill. Look for the step with the queue of work piling up in front of it and the starved, idle steps behind it. That pile-up is the system’s way of pointing at its own neck.

Worked intuition. A coffee shop has an order counter, an espresso machine, and a hand-off counter. At the morning rush, cups-waiting-to-be-made stack up next to the espresso machine while the order-taker and the hand-off person have moments of standing around. The espresso machine is Herbie. Not the friendliest barista, not the slow card reader — the machine, because that’s where the line physically backs up.

Get this step wrong and everything downstream is wasted, because you’ll spend the next four steps lovingly optimising a part that was never the problem. Measure; don’t guess. The step that feels slow (the grumpy customer, the noisy printer) is often not the step where work actually accumulates.

2. Exploit the constraint

Exploit means: get the absolute maximum output from the constraint exactly as it is now, without spending money to enlarge it. You have a fixed amount of bottleneck capacity — the rule is to waste none of it.

What “wasting it” looks like, and how to stop:

  • Never let it sit idle. If the espresso machine stops during the lunch rush because everyone took their break at once, that capacity is gone forever — you can’t make it up later. Stagger breaks so the machine never stops while there’s demand.
  • Never feed it defective work. If a drink gets remade because the order was wrong, the machine did that work twice and the second time produced nothing new. Inspect before the constraint, not after — catch the bad order at the counter, not at the cup.
  • Move setup and cleanup off it. Grinding beans, restocking cups, wiping down — anything that doesn’t require the machine should happen on something else’s time, not the machine’s. Pre-grind during lulls so the machine is only ever pulling shots.
  • Protect it from interruptions. Don’t pull the one espresso machine off to make a free sample for a meeting. The constraint’s time is the most expensive time in the building.

Here is the rule that powers all of this, and it’s worth memorising word for word:

An hour lost at the bottleneck is an hour lost for the entire system — and you can never get it back. An hour saved anywhere else is a mirage.

Because the bottleneck sets throughput, every minute it runs is a minute the whole system produces, and every minute it sits idle is a minute the whole system produces nothing. That asymmetry is why exploit comes so early: the cheapest capacity you will ever find is the capacity you’re currently throwing away.

3. Subordinate everything else to the constraint

This is the radical, counter-intuitive one — the step that makes people uncomfortable. Subordinate means: every non-constraint step should run at the constraint’s pace, not flat out. Faster stages must deliberately pace themselves to the bottleneck, releasing work only as fast as the bottleneck can swallow it.

Read that again, because it contradicts everything a productivity culture trains into you: a non-bottleneck running at full speed is a problem, not a virtue. If the order-taker takes orders as fast as humanly possible, all they accomplish is a towering pile of unmade drinks next to a machine that can’t go any faster. That pile — work-in-progress inventory — costs money, hides problems, and makes the whole line slower and more chaotic, while adding exactly zero finished drinks.

Back to the hike. Subordinating is the moment Alex makes the fast scouts walk at Herbie’s pace. Their instinct is to race ahead — they can, they’re faster! — but every metre they gain just stretches the line and helps nobody arrive sooner, since the troop isn’t “there” until Herbie is. So you tie the line to Herbie: nobody outruns the constraint.

The liberating consequence: idle time on a non-bottleneck is free. If the order-taker sometimes stands around because the machine is caught up, that’s not waste — that’s the system working correctly. The non-constraint is supposed to have slack. Slack on a non-bottleneck costs nothing; slack on the bottleneck costs everything.

Warning:

The pitfall: skipping straight to ELEVATE

The classic, expensive mistake is to leap to step 4 — buy more capacity — before exploiting and subordinating. You spend real money on a second machine while the first one still sits idle over lunch and remakes defective orders. The free wins were right there. (The other half of the trap is botching step 1: optimising the wrong step entirely, so every later step pours effort into a non-constraint.) Exploit before you elevate — always.

4. Elevate the constraint

Elevate means: now, having squeezed every free drop, actually increase the constraint’s capacity — and this is the step that’s allowed to cost money. Buy the second espresso machine. Hire another nurse. Add a parallel test runner. Offload some of the constraint’s work to a vendor.

Notice it’s step four, not step one. By the time you get here, you’ve already learned exactly how much capacity you truly need (because you’ve seen the constraint running at its real, fully-exploited maximum), and you often discover you need far less than your first panicked instinct said — or sometimes none at all, because exploiting and subordinating already moved the bottleneck somewhere else. Elevating last means you spend money precisely, on a constraint you understand, instead of blindly, on a guess.

For Herbie: elevate is redistributing the heavy gear from his pack into the fast scouts’ packs. That genuinely raises Herbie’s pace — but notice you only knew how much to move, and to whom, because you’d already watched him struggle and seen who had spare capacity.

5. Repeat — and beware inertia

Repeat means: once you’ve elevated the constraint enough that it’s no longer the slowest step, the constraint has moved to a new step — so go back to step 1 and start over on the new bottleneck. The bottleneck never disappears; it relocates.

Goldratt attached a famous warning to this step: “do not let inertia become the constraint.” The danger is that you build rules, schedules, and habits around managing the old bottleneck, and you keep enforcing them long after the constraint has moved. You stagger everyone’s breaks around the espresso machine for a year — even after you bought a second machine and the new bottleneck is the single card reader at the counter. The policy outlived the problem. Re-identify, every time.

This is the loop you’ll come to ride rather than fight: fix one constraint, reveal the next, run the five steps again. (Lesson 5 of this course, The Constraint Always Moves, is entirely about living inside that cycle.)

Match each of the five focusing steps to its one-line job.

Pick a term, then click its definition.

Worked example: a craft brewery

Let’s run one real scenario through all five steps, with numbers, the way you’d actually do it. Hop & Helix is a small craft brewery. The beer flows through four stages, each measured in batches per week:

StageWhat it doesCapacity (batches/week)
BrewingMash, boil, cool the wort22
FermentationYeast does its slow work in tanks10
BottlingFill, cap, label18
PackagingBox and palletise for shipping25

Step 1 — Identify. Throughput equals the minimum, so the brewery ships 10 batches a week, set by fermentation. The tell is unmistakable: cooled wort backs up waiting for an open tank (pile-up in front), while bottling, packaging, and the loading dock have idle stretches (starvation behind). Fermentation is Herbie.

Step 2 — Exploit. The brewers look at how the fermentation tanks are actually used and find leaks. A tank sits empty for half a day between batches while someone gets around to cleaning it (idle constraint). Two batches a month get dumped because contaminated wort reached the tank (defective work fed to the constraint). They fix both for free: a clean-in-place routine ready the moment a tank empties, and a quality check on the wort before it’s pumped in. Fermentation effective capacity climbs from 10 to 13 batches/week — a 30% gain, zero dollars spent.

Step 3 — Subordinate. Brewing can do 22, but there’s no point: brewing 22 batches when fermentation can only take 13 just leaves cooled wort sitting around going stale and clogging the floor. So brewing is told to pace to 13 — release wort only as fast as tanks open up. Bottling and packaging do the same. The brewers, accustomed to “keep every station busy,” have to be convinced that the brew kettle sitting idle part of the week is correct. Work-in-progress on the floor drops; chaos drops; finished output is unchanged at 13 (which is now the honest ceiling).

Step 4 — Elevate. Only now, with fermentation fully exploited at 13 and everything paced to it, do they spend money — and because they’ve measured the real bottleneck, they spend it exactly. They lease two more fermentation tanks (the cheapest capacity, not a whole new brewhouse), lifting fermentation to 18 batches/week.

Step 5 — Repeat. Throughput is now 18 — but wait: bottling caps out at 18 too, and it’s about to. The constraint has moved from fermentation to bottling. Time to go back to step 1 and run the whole loop again on the bottling line. And the brewers must drop the old rule of pacing everything to fermentation’s 13 — that inertia would now strangle the very capacity they just paid for.

StepActionThroughput afterCost
Start10
ExploitClean-in-place + pre-tank QC13$0
SubordinatePace brewing/bottling/packaging to 1313 (less chaos, less WIP)$0
ElevateLease two more fermentation tanks18$$
RepeatNew constraint = bottling → restart(next loop)

Look at what the free steps bought: a 30% throughput gain before any spending, and a precise, confident decision about what to buy when they finally did. That’s the entire argument for doing the steps in order.

Sort each brewery action into whether it's an EXPLOIT move (free — squeeze the constraint as-is) or an ELEVATE move (costs money — add capacity).

Place each item in the right group.

  • Hire a contract brewery to ferment some batches for you
  • Stagger the brewers' breaks so a tank is never left waiting on a person
  • Clean a fermentation tank the instant it empties so it's never idle
  • Check the wort for contamination before pumping it into the tank
  • Lease two additional fermentation tanks
  • Stop pulling the fermentation crew off for unrelated chores

A trap to feel in your gut

Let’s make the most violated step — exploit — concrete with a scenario, because it’s the one people skip without noticing.

A factory's bottleneck is a single CNC machine. Every day at noon, all the operators go to lunch together, and the machine sits idle for 40 minutes. Which focusing step is being violated?

The fix costs nothing — stagger the breaks — and the people still get fed. But notice how invisible the loss is: nobody is doing anything obviously wrong, everyone’s just having lunch, and the factory quietly produces 40 minutes less every single day. Bottleneck losses hide in reasonable-looking habits. That’s why you have to hunt for them on purpose.

Fill in the logic of the five steps.

Pick the right option for each blank, then check.

After you the constraint, you it for free before spending any money, then every other step to run at the constraint's pace rather than flat out. Only then do you it by adding capacity — and once it stops being the bottleneck, the constraint has , so you go back to step one.

When to use it

Reach for the five focusing steps whenever a system has a clear flow of work through stages and you want more output from the whole thing — a factory line, a hospital’s patient flow, a kitchen, a software delivery pipeline, an approvals process, even your own week. The method shines exactly when your instinct is to “improve everything” or to “buy our way out”: it forces you to find the one step that governs the whole, extract the free wins first, and spend money last and precisely. It’s less useful when there’s no real flow (a pile of fully independent tasks with no shared chokepoint) — but those are rarer than they look.

The discipline to build: never skip a step, and never reorder them. Most failures here are sequence failures — elevating before exploiting, or never subordinating because idle non-bottlenecks feel “lazy.”

Put the five focusing steps in their correct order.

Check yourself: the five focusing steps

Question 1 of 50 correct

Why does 'exploit' come before 'elevate' in the five focusing steps?

Check your answer to continue.

Recap

Big picture

The Theory of Constraints — the five focusing steps

  • Theory of Constraints
    • The idea (Goldratt, The Goal)
      • Every system has very few constraints — usually one
      • Manage THAT constraint, not everything at once
      • Herbie the slow scout sets the whole troop's pace
    • 1. Identify
      • Find the slowest step — pile-up in front, starvation behind
      • Measure, don't guess — wrong target wastes everything after
    • 2. Exploit (free)
      • Never let the constraint sit idle
      • Never feed it defective work
      • Move setup/cleanup off it; protect from interruptions
      • An hour lost on the bottleneck = lost for the whole system
    • 3. Subordinate (free)
      • Pace every other step to the constraint, not flat out
      • Non-bottlenecks SHOULD be idle sometimes — that's free
      • Running them full speed just piles up WIP inventory
    • 4. Elevate (costs money)
      • Only now add capacity: buy, hire, offload
      • You now know exactly how much to spend — and on what
    • 5. Repeat
      • Constraint moved → go back to step 1
      • Don't let inertia (old rules) become the constraint

Where this goes next

You now have the procedure — the five focusing steps, in order, with the free wins extracted before any money is spent. But there’s one step in it that deserves a whole lesson of its own, because it’s the one people fight the hardest: subordinate. The idea that a fast step should deliberately slow down, that idle time on a non-bottleneck is free, runs so against the grain of “keep everyone busy” that it’s worth proving in detail.

Next up, lesson 4 — Don’t Polish the Wrong Stone — is exactly that proof. It shows why pouring effort into a non-bottleneck does nothing for output (and can actively hurt, by burying the system in inventory it can’t use), names the local-optimisation trap that fools well-meaning managers everywhere, and turns “looking busy” versus “being productive” into a distinction you can measure. If exploit was the step everyone skips, polishing the wrong stone is the work everyone does — and shouldn’t.

Mark lesson as complete