Constraint Snapshot

Find where work is waiting between steps, and fix the worst delay.

Constraint Snapshot

What this fixes

Everyone looks busy. Meetings happen. But work still takes longer than expected to move through the team - and no single cause is obvious. That’s because work doesn’t slow down where people are working. It slows down where work is waiting - in the handoffs and queues between the steps that look busy, where nobody is watching. This activity finds those stalls, so you can fix the real delay instead of pushing harder on the parts that already move. 

How this works

A feature takes three weeks to deliver, even though the team estimates only five days of actual work. When they map the journey, coding takes two days, testing takes one, and deployment takes a couple of hours. But the feature spends eight days waiting for code review, four days waiting for QA, and three days waiting for release sign-off. Nobody was working slowly. The work was simply waiting. Constraint Snapshot makes those invisible waits visible, so the team fixes the real delay instead of pushing people to work harder. 

As a team, you map how one piece of work actually moves from start to finish. Then you mark every place where the work waited before the next step could begin - not where someone is working on it, but where it sits between steps. The biggest wait, not the busiest step, is where your delivery is really losing time. 

Time required

Team ✓ · About 25–30 minutes, with a facilitator. 

The time required is indicative and will depend on the nature of the problem and the size of the team. 

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

When to use

Use it when delivery feels slow but no single cause stands out. 

Good signs it’s the right tool: 

  • work takes longer to finish than the actual effort it contains 
  • people are busy, but things still don’t move 
  • you can’t point to one obvious bottleneck 
  • work seems to be delayed without visibility, between steps or teams 

What you get

  • A simple map of how the work flows 
  • The stalls marked and sized - where time is actually lost 
  • The one delay that will shorten overall delivery the most if removed 

You’ve done it well when: the team agrees where flow really breaks - and can point to a stall they’d been missing. 

What you’ll notice

  • The delay wasn’t in the busy step everyone watches 
  • Most of the lost time is spent waiting, not working 
  • The worst stall sits in a gap nobody owns 

Why this works

People naturally focus on the work they can see. But work often spends much more time waiting than being worked on - in handoffs, approvals and queues. By separating waiting time from working time, the biggest delay becomes visible - and that’s usually where the biggest improvement comes from. 

What you need

One real piece of work. Something the team recently delivered, or is delivering now - this is the critical ingredient; without it the exercise has nothing to map. 

A whiteboard, wall or large sheet of paper. Room to lay out the steps of that work, left to right. 

Sticky notes and a marker. One note per step; a way to mark the stalls between them. 

Roles - Team: a facilitator (keeps the map fast and rough, and holds the team to marking the waiting) and participants (map the work and size the waits). 

Steps

  1. Pick one piece of work (3–4 min). Choose something real that moved through the team from start to finish. 
  2. Map how it moved (5–6 min). Lay out the steps in order - the path the work took. Map what actually happened, not what the process document says should happen. Keep it quick and rough. 
  3. Mark the waiting (4–5 min). At each point where the work sat and waited - between steps, in a queue, awaiting a handoff - mark it. Mark every wait, even if it lasted only a few hours; small waits add up. 
  4. Size the waits (5–6 min). Estimate each wait - was it hours, days or longer? Rough estimates are enough; you’re after proportion, not precision. Don’t argue about exact numbers - relative size is what matters. Note it next to each mark. 
  5. Name the worst stall (3–4 min). The biggest wait is the constraint - not the busiest step. Circle it. 
  6. Decide on one move (5 min). Choose the smallest change most likely to reduce the biggest wait, and who owns it. 

Output / Takeaways

  • A flow map with the stalls marked 
  • The worst stall circled 
  • One agreed move to shorten it, with an owner 

Important rules

  • Map the waiting, not the working - that’s where the time goes 
  • Keep the map fast and rough - this is not detailed process mapping 
  • The biggest wait wins - don’t fix the busy step out of habit 
  • Fix one constraint first, then measure again - don’t redesign the whole process at once 
  • End with one owned move, not a long list 

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

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