Dependency Snapshot

Find the real blocker when work has stalled.

Dependency Snapshot

What this fixes

Work has stalled, and the cause isn’t obvious. Several things are stuck; everyone’s chasing the item in front of them - but clearing it doesn’t help, because the thing that’s stuck usually isn’t the thing that’s blocking you. The real hold-up is often several hidden “waiting on” links further up the chain. This traces the chain to the source, so you fix the blocker instead of the symptom.

How this works

A feature hasn’t shipped for two weeks. Everyone says QA is blocking it, so the team pushes QA harder. When they trace the dependency chain, QA is actually waiting on a security review, Security is waiting on an infrastructure approval, and Infrastructure is waiting on a vendor certificate nobody realised had expired. QA wasn’t the blocker - it was just where the delay became visible.

So you write the stuck item, then ask “what are we waiting on?” and draw an arrow to it. You repeat from there - what is that waiting on? - until the arrows stop. The node at the far end is the real blocker. You circle it and pick one move to clear it.

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

Time required

Team ✓ · About 15–25 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 10 minutes. It’s a downloadable PDF on this page.

When to use

Use it when work has stalled, and you can’t tell why.

Good signs it’s the right tool:

  • several things are stuck at once and clearing the obvious one doesn’t help
  • people keep chasing the task in front of them with no effect
  • progress has stopped but no single cause is clear
  • you suspect you’re waiting on something, but not sure what

What you get

  • A map of what’s waiting on what
  • The source blocker - the far end of the chain - circled
  • One owned action aimed at the source blocker - not the visible symptom

You’ve done it well when: the team agrees on the real blocker (not the symptom) and leaves with one owned move aimed at it.

What you’ll notice

  • The blocker is rarely the task you were focused on
  • Effort stops going into the wrong thing
  • Work starts moving once the source is cleared

Why this works

When work stalls, people naturally push on the task they can see. But that task is usually waiting on something else. Tracing each dependency reveals the real source of the delay, so effort goes where it actually unblocks the work.

What you need

A real piece of stalled work. Something that has stopped moving and where the cause isn’t obvious. The tool only works with a real blockage.

A board or wall. Somewhere to place the nodes and draw the dependency chain.

Sticky notes and a marker. One note per dependency.

Roles - Team: a facilitator (keeps the team tracing to the far end, not stopping at the first link) and participants (name the dependencies and trace the chain).

Steps

  1. Put up the stuck work (2–3 min). The item that has visibly stopped moving.
  2. Ask: “What is this waiting on?” (3–4 min) Write the answer as a node and connect it with an arrow. Write only one dependency per note - if it’s waiting on two things, make two notes.
  3. Keep tracing (4–6 min). For each new node, ask again: “What is this waiting on?” Don’t stop at the first dependency. If a node is waiting on several things, follow each one separately until it ends.
  4. Find where the chain ends (3–4 min). The node with no further dependency - the thing waiting on nothing else - is the source blocker. It’s often nowhere near the task you started with. Circle it.
  5. Make one move at the source (3–4 min). Choose the smallest action most likely to clear the circled blocker - not the visible task - and assign an owner and a date.

Output / Takeaways

  • The dependency map, with the source blocker circled
  • One move aimed at the source - and its owner
  • A record you can re-trace as the blocker moves

Important rules

  • Trace to the far end - don’t stop at the first “waiting on”
  • Don’t stop tracing because you’ve hit a difficult dependency - stop only when there’s nothing else it’s waiting on
  • Aim the move at the source, not the visible task
  • Keep it light - nodes, arrows, a circle; no scoring or symbols
  • One move, with an owner - not a 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.