Skip to content

Phased Intensification Gate

Authorization protocol — instantiates Internal Capacity Deepening

Authorizes the next internal density increment only after the last one proves usable capacity, preserved invariants, and acceptable constraint migration — and stops when intensifying stops beating expansion.

Intensification tends to happen all at once — a big density push justified by a model — which is exactly how a system gets crammed past the point it can carry. Phased Intensification Gate breaks the push into increments and releases them one at a time: the next increment is authorized only after the previous one has demonstrated usable capacity, held its invariants (quality, service level, safety), and shown that the binding constraint migrated somewhere acceptable. Its defining discipline is earned progression under irreversibility — each increment must prove itself on the real system before the next is funded, and the gate carries a standing stop condition: the moment the next internal increment stops beating the expansion alternative, it stops authorizing and hands off.

Example

A factory wants to lift a line's output 30% by raising conveyor speed. Rather than dialling it up once, the plant runs the increase through a phased gate in 10% steps. Step one is authorized; after two weeks the gate checks the evidence: throughput genuinely rose, scrap and rework stayed inside their invariants, and the bottleneck moved from the press to the packing station — a migration the packing cell can absorb. Step one passes, step two is authorized. After step two, the gate finds scrap creeping up and the constraint now landing on a manual inspection station that cannot keep pace without overtime. The next increment is not authorized on schedule; the crossover check shows the third 10% would cost more in quality loss and inspection strain than adding a parallel shift. The gate stops the ramp at 20% and routes the rest to expansion.

How it works

The gate is a thin protocol whose substance is the evidence it demands and the cadence at which it demands it. It does not measure or model anything itself; it consumes the audit's capacity demonstration, the slack test's floor check, and the load simulation's constraint-migration read, and it authorizes only on a clean set. Two features distinguish it from a generic stage-gate: it operates on a fixed review cadence tied to real operating data from the last increment rather than a calendar, and it carries the crossover rule as a standing stop — it is not just a go/no-go on this increment but a live test of whether internal intensification still beats expansion at all. A local-fit exception path lets a specific position deviate with a compensating control rather than blocking the whole ramp.

Tuning parameters

  • Increment size — how much density each step adds. Small steps buy more evidence and reversibility per gate but slow the harvest; large steps move faster and risk overshooting before the gate can catch it.
  • Pass criteria strictness — how much demonstrated capacity, invariant preservation, and acceptable migration an increment must show. Loose criteria turn the gate into a rubber stamp; tight ones stall useful intensification.
  • Review cadence — how much operating data accrues before the next gate. Too fast and the increment hasn't revealed its real behaviour; too slow and the ramp crawls.
  • Exception latitude — how freely a local position can deviate under the exception process, trading uniform control against local fit.

When it helps, and when it misleads

Its strength is converting an irreversible cram into a sequence of reversible bets, each validated on the real system before the next is committed — and building the intensify-versus-expand crossover into the operating rhythm so the ramp stops itself rather than running until something breaks.[1]

Its failure modes are governance ones. Gate theater — rubber-stamping increments from cherry-picked evidence — hollows the protocol out; an increment "demonstrated" on a quiet week isn't demonstrated. Gates set too heavy stall intensification that was genuinely safe, pushing teams to route around the gate. And a gate that never invokes its crossover rule quietly becomes a ratchet, authorizing increment after increment past the point expansion became the better mode. The discipline is to demand evidence from representative operating conditions, keep the exception path narrow and logged, and treat the crossover stop as a real outcome the gate is expected to reach — not a formality.

How it implements the components

This gate fills the staged-authorization slice of the archetype — the governance that sequences increments:

  • review_cadence — the fixed rhythm, tied to accrued operating data, at which each increment is evaluated before the next is released.
  • local_fit_exception_process — the narrow, logged path by which a specific position may deviate under a compensating control instead of blocking the ramp.
  • intensification_expansion_crossover_rule — the standing stop condition: authorization ceases the moment the next internal increment stops beating the expansion alternative.

It produces none of the evidence it gates on — usable-capacity demonstration comes from the Occupancy and Idle-Capacity Audit, the reserve check from the Slack-Erosion Test, and the constraint-migration read from the Infrastructure-Load Simulation; the two-mode economics behind the crossover come from the Intensification–Expansion Lifecycle Model.

Notes

The gate governs the intensify side only. Its crossover stop does not itself open a new footprint — it hands off to the Footprint-Expansion Decision Gate, which governs that separate choice. Keeping the two gates distinct is what stops "we should expand" from being decided inside a densification review that was never scoped to weigh a new site.

References

[1] The distinction between reversible "two-way door" decisions and hard-to-undo "one-way door" ones — popularized in corporate practice at Amazon — is why this gate exists: density increments are closer to one-way doors, so each is made to prove itself before the next is committed. ↩