Crunch Cycle Review

Find the early decision that causes your end-of-cycle crunch, and change it.

Crunch Cycle Review

What this fixes

The same end-of-cycle crunch keeps happening - the late nights, the weekend scramble, every release. Each time, it feels like bad luck or a one-off.

It isn’t. The crunch started weeks earlier, with a decision that looked completely reasonable at the time. This finds that the earliest decision - so you can break the cycle instead of surviving it again.

How this works

Imagine this: every release ends the same way - testing gets compressed, engineers work the weekend, and everyone blames the final week. The team rebuilds the release as a chain of decisions: the date fixed before scoping, the extra requests accepted, integration deferred. When they tip the first domino, they see the crunch actually began weeks earlier.

You rebuild the last crunch as a chain of decisions, laid out as dominoes in time order - from the earliest call to the final scramble. Then you tip the first domino and watch the whole chain fall in sequence. The fall shows that the late panic was already unavoidable early. You finish by finding the earliest decision you could move next cycle - the point where the chain breaks.

The dominoes deliver the moment; the decision cards carry the lesson. The point isn’t the falling tiles - it’s the real decisions written on them and which one to move next time.

Team: one person acts as the facilitator - they run the activity using the Facilitator Guide while everyone else takes part.

Time required

Team ✓   About 45–90 minutes, with a facilitator.

The time required is indicative and will depend on the size of the team and the length of the chain.

The facilitator should read the short facilitation guide first - about 8–10 minutes. It is a downloadable PDF on this page.

When to use

Bring one real crunch the team keeps living through - the recurring late scramble, not a one-off emergency.

Use it whenever:

  • the same deadline crunch keeps happening, release after release
  • each crunch gets blamed on the final week, and nothing changes
  • the team keeps resolving to “plan better next time” and doesn’t
  • you want to break the pattern, not just survive the next one

What you get

  • The chain of decisions that led to the crunch, in time order
  • The earliest decision that made the crunch unavoidable
  • One intervention for next cycle - a decision to move, with a trigger

You’ve done it well when: the team stops blaming the last week and can point to the earliest decision that started the whole chain.

What you’ll notice

  • The crunch you blamed on the deadline started weeks before it
  • No single decision looked dangerous at the time
  • Moving one early decision would have changed everything

Why this works

A recurring crunch is the visible end of an invisible chain of decisions. Each decision looked reasonable on its own, so no one saw the chain until the crunch arrived - and the team fixes the last week while the cycle repeats. Laying the chain out in time and tipping the first decision makes the cause and effect visible: the crunch was started early, not at the deadline.

What you need

One recurring crunch. A real, recent crunch the team keeps repeating - and recognises as a pattern, not bad luck.

One facilitator. They run the flow, keep the room hunting for the earliest decision rather than the last week, and tip the dominoes.

A large table or clear wall space. The chain is a physical layout, built left to right - you need room to lay the whole thing out so every link is visible.

The dominoes + timeline board. One domino represents one real decision that led to the crunch. They are laid out from the start of the cycle to the deadline. Tipping the first shows the chain fall.

Decision cards + pen. Write-on cards to name each real decision, so the chain is the team’s actual story - not a generic demo.

Steps

  1. Name the crunch (5 min). Team: appoint a facilitator first. Pick one recurring crunch and write it as the end state you keep hitting.
  2. Rebuild the chain backwards (16–18 min). Work backwards one decision at a time: what made this necessary? And what decision made that happen? And before that? Keep going until you reach an early, reasonable-looking decision. Write each on a card.
  3. Lay the dominoes in time order (8–10 min). Place the decisions left (earliest) to right (the crunch), leaving a small gap between dominoes so every link is visible. Read the chain aloud from start to finish: “this led to this, which led to this…”
  4. Tip the first (8–10 min). Tip the earliest decision. Watch the chain fall all the way to the crunch. Notice that none of the decisions looked dangerous when they were made - yet together they led straight here.
  5. Find the earliest decision to move and commit (12–15 min). Pick the earliest decision that was a real choice and could have broken the chain. (Familiar examples: a date fixed before scoping; late feature requests accepted without moving the date; development started before interfaces were agreed.) Agree on the new decision, who owns it, and the trigger for making it next cycle.

Output

You leave with:

  • The decision chain that led to the crunch, in time order
  • The earliest decision worth moving - where the chain breaks
  • One intervention with an owner and a trigger for the next cycle

Important rules

  • One domino per real decision - in time order, each leading to the next.
  • Tip the first domino, never the middle - the earliest decision is the point.
  • Find when the chain started, not who to blame. And don’t stop at the first obvious cause - keep going until the team agrees the chain couldn’t have started earlier.
  • End with a moved decision and a trigger - not “more buffer” or “try harder.”

Planning to facilitate this activity? Access the resources below to get started.

MIndn
Execution must be smooth. Not chaotic or stressful.
Built by Witmer.