The Theory of Constraints in Software Development: Finding and Fixing the Real Bottleneck

In the world of software development, we often talk about flow, value moving smoothly from idea to customer. But if you’ve ever felt like progress slows to a crawl despite everyone working flat out, you’ve likely encountered what the Theory of Constraints (TOC) calls a bottleneck.

Developed by Dr Eliyahu Goldratt, the Theory of Constraints is a powerful systems thinking approach that helps teams identify what’s truly limiting their performance and focus their improvement efforts there. It’s based on a simple but profound idea: your system can only move as fast as its slowest part.

Once you have identified your bottleneck, you can start to apply the five focusing steps of Theory of Constraints (TOC).

Theory of Constraints

Step 1: Identify the Constraint

In a software context, constraints often appear in unexpected places, and each constraint can be classified as availability or capacity. It might be:

  • The single test environment that everyone queues for. (Availability)
  • The overloaded UX designer who’s shared across five teams. (Capacity)
  • The manual deployment process that requires sign-off from operations. (Availability)

These are not just minor inconveniences; they define the pace of your entire system. If one part can only handle 10 features a month, it doesn’t matter if the rest of the pipeline could theoretically handle 30. The constraint sets the limit.

Step 2: Exploit the Constraint

Once you’ve identified the bottleneck, the first step isn’t to throw more people or tools at it. It’s to make the most of what you already have.

For example, if code reviews are the constraint:

  • Can you reduce unnecessary rework by better educating people in your coding standards or design patterns?
  • Can pairing or mob programming reduce the time spent on code review? In fact, perhaps you could remove code review entirely, as it happens by default?
  • Can you prioritise smaller, more frequent merges?

You’re squeezing more throughput from the existing capacity, not yet changing the constraint itself, just getting it to flow more effectively.

Step 3: Subordinate Everything Else

This step is where systems thinking really shines. Once you know your constraint, everything else should align around it.

If testing is your constraint, there’s no point in developers pushing more work into the queue, as doing so only increases inventory in front of testing, and inventory is waste. Instead:

  • Limit work in progress upstream to match testing capacity.
  • Prioritise critical features to align with test capacity.
  • Balance or reduce the scope of a Sprint to allow for sufficient time to test.

It can feel counterintuitive, but subordinating to the constraint keeps the system balanced. Otherwise, you’re just creating piles of half-finished work and more frustration.

Outside of software, as an example, you will find subordination of a constraint in the London underground system. If a platform becomes full and dangerous for passengers, the bottleneck is the safe space available on the platform; the system is subordinated by closing the underground station until the bottleneck is under control.

Step 4: Elevate the Constraint

Only when you’ve optimised and aligned do you look to increase capacity. In software teams, that could mean:

  • Automating regression tests.
  • Adding another skilled tester.
  • Improving test data management or infrastructure.

The key here is to invest wisely in the area that will genuinely increase flow.

Step 5: Repeat – Because the Bottleneck Moves

Here’s the beauty (and challenge) of the Theory of Constraints (TOC): once you remove one bottleneck, another will emerge.

  • Fix the manual deployment process, and suddenly, test data creation becomes the constraint.
  • Streamline QA automation, and the constraint shifts to UX design capacity.
  • Improve code review turnaround to improve flow through development, and the constraint moves to test.

This dynamic nature is what makes the Theory of Constraints (TOC) so powerful and so relevant to Agile environments. Continuous improvement isn’t about local optimisation; it’s about continuously discovering where the system truly needs your attention next.

Another example outside of software development of a constraint moving was in a bottling factory, where the initial constraint was not being able to palletise the cartons of bottles fast enough at the end of the production line. This was resolved by automating the palletisation process. This action resolved the bottleneck in palletisation, but the bottleneck then moved downstream to the warehouse, which ran out of space as goods were leaving the production line much faster.

Why It Matters for Agile Teams

In Agile, we often celebrate how fast teams deliver. But the Theory of Constraints (TOC) reminds us that speed without flow is chaos. True agility comes from balancing throughput and learning, not from pushing everyone to go faster.

By applying the Theory of Constraints (TOC), you create a culture of focus, flow, and feedback. Teams learn to see work as part of a connected system and to make decisions that optimise the whole, not just their part.

Final Thoughts

Every software delivery system has a constraint, and that’s not a bad thing. Constraints focus attention and energy. They show us where to act, where to collaborate, and where improvement really matters.

So, the next time you feel like progress has slowed, don’t just push harder. Step back. Find the bottleneck. Exploit it, subordinate to it, elevate it, and then look for the next one. That’s the rhythm of continuous improvement, and if you want to learn more about understanding flow through your system, then consider one of our Kanban training courses.

If you found this useful, please share:

Previous Post
What is Kanban STATIK? A Complete Guide to the Kanban System Design Method
Next Post
Effective and Impactful Facilitation
Menu