liveBook · Manning

Theory of constraints

As explained in Build High Value Software Systems

A management discipline that improves system performance by identifying and addressing the constraint that limits throughput.

When work piles up, making every stage faster is rarely the answer. The theory of constraints (ToC) focuses improvement on the stage that currently limits end-to-end throughput. In a development workflow, that might be code review; in a service architecture, it might be a shared database. Speeding up work elsewhere can simply enlarge the queue ahead of the constraint. section 6.4 section 11.4

Look for a necessary stage where demand persistently exceeds capacity, not just a task that takes a long time. Growing queues, longer waits, aging work items, and a low activity ratio are useful signals. If six developers open 15 pull requests a week but reviewers close only 10, five more requests wait each week. Faster coding or deployment will not clear that queue. section 6.4

Improve flow in this order:

  • Identify the binding constraint using queues, capacity, and observed slowdowns. section 6.4
  • Exploit its existing capacity: remove avoidable work or make better use of the capacity already available. section 6.4.1 section 11.4
  • Subordinate upstream work to its pace. Limit work in progress or sequence integrations so the constraint is not overloaded. section 6.4.1
  • Elevate its capacity if needed, then look again: removing one bottleneck can reveal the next. section 11.4

A shared database at peak demand

During a dinner rush, three services using the same PostgreSQL database slow sharply, while a payment service that does not use it barely changes. The shared database is the likely constraint. First improve its existing use, including queries and connection pooling. Then reduce demand through caching, batching, or moving suitable workloads elsewhere. If that is insufficient, consider read replicas, scaling, or splitting the database. Diagnose the next constraint after the change rather than assuming the system is finished. section 11.4

Table 6.1 Practical strategies for elevating the constraint
Type
Symptoms
Strategy
Example
Code review
Aging PRs, long review wait time
Reduce demand
Cap PR size at 200 lines
Code review
Reviewers spend too much time on formatting and flagging internal standards
Remove trivial work
Automate linting, formatting
Code review
Limited reviewer bandwidth
Increase capacity
Dedicate a review block daily in the calendar
CI runtime
Long build queue
Parallelize
Split integration tests across runners
CI runtime
Flaky failures
Remove instability
Stabilize or remove flaky tests
Deployment approval
Manual gate delay
Replace gate with policy as code
Automated compliance checks
External dependency
API blocking progress
Decouple or mock
Contract testing with stubbed services

Compare symptoms with targeted interventions for review, CI, approvals, and external dependencies; the useful fix depends on which stage is actually binding. section 6.4.1

The practical question is not “What can we make faster?” but “What currently sets the pace for completed work?” Protect that stage from overload, improve it deliberately, and recheck the whole flow. section 6.4.1 section 11.4

How Build High Value Software Systems covers it

How deep it goes
Develops a diagnostic and improvement sequence through queue signals, subordination, elevation, and reassessment rather than a formal throughput model.
Examples
Uses an accumulating pull-request review queue, a congested staging environment, and peak-load slowdowns at a shared database.
What it assumes
Assumes familiarity with pull requests or service workflows while explaining constraints through capacity, queues, and throughput.
What you can do after
Diagnose/debug with it by locating the binding stage, matching interventions to it, and checking where the constraint moves.
How it connects
Links work-in-progress limits, value stream mapping, backpressure, and drum-buffer-rope to end-to-end flow.

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Build High Value Software Systems. The section links point to the parts of the book it draws on.