Production worked example

Bottleneck Capacity at 99% expected uptime: a worked example

What does the result look like when expected uptime reaches 99%? The full calculation is worked below with real intermediate numbers. Use before adding labor, overtime, or equipment to confirm which step constrains output.

The inputs for this scenario

  • Step 1 cycle time: 35 sec (unchanged)
  • Step 2 cycle time: 52 sec (unchanged)
  • Step 3 cycle time: 44 sec (unchanged)
  • Step 4 cycle time: 41 sec (unchanged)
  • Hours per shift: 8 hr (unchanged)
  • Shifts per day: 2 shifts (unchanged)
  • Expected uptime: 99 % (raised for this scenario; the documented default is 88)
  • Expected yield: 96 % (unchanged)

Working through the calculation

  • Applying the documented formula (Bottleneck cycle = longest process step cycle time) to the inputs above produces each figure below.
  • At this operating point the engine returns 1,053 units / day for good capacity, the number this scenario is built around.
  • At this operating point the engine returns 52 sec for bottleneck cycle.
  • At this operating point the engine returns 1,108 units / day for gross capacity.
  • At this operating point the engine returns 54.94 units / day for yield loss.

How this compares with the baseline

  • Against the tool's baseline example, where expected uptime sits at 88% and the headline result is 936 units / day, this scenario comes in 12.5% above the baseline at 1,053 units / day.
  • A figure at this level is achievable when expected uptime is genuinely sustained, not just peaked for a shift. It models a balanced serial line governed by a single bottleneck; it does not capture parallel stations, shared resources, changeovers, or variable demand-driven starvation.

Results at a glance

  • Good capacity: 1,053 units / day (headline result)
  • Bottleneck cycle: 52 sec
  • Gross capacity: 1,108 units / day
  • Yield loss: 54.94 units / day

Run it with your numbers

  • Every input above is editable in the live Bottleneck Capacity calculator, which recalculates instantly and can be shared with the inputs intact.

Last reviewed 2026-05-12.