Before you redraw the org chart, find out where your work actually waits. A wall, sticky notes, and one honest afternoon are enough.
Every engineering organization has a story about why delivery is slow. QA is backlogged. The DBAs are a bottleneck. Product changes its mind. Those stories are usually partly true and mostly unmeasured.
A Value Stream Mapping (VSM) workshop replaces the stories with data. It traces one real feature from idea to production and measures two things at every step:
- Touch time: how long someone was actively working on it.
- Wait time: how long it sat in a queue before the next step could start.
The result is usually a shock, and that shock is exactly what you need before any restructuring.
What You Need
- People: 6 to 10 people, one from every group the feature passes through: product, frontend, backend, QA, DBA, release engineering.
- Time: four hours, blocked and protected.
- Materials: a long wall, green and red sticky notes, markers.
- Data: access to the ticket history, Git history, and chat logs for the feature you will map.
Below is a script you can adapt, phase by phase.
Phase 1: Pick the Feature (15 Minutes)
“We are going to map exactly what happened when we shipped one specific feature. Not the ideal path. The real path. Pick a feature that shipped recently and felt slow to everyone.”
Avoid features that were unusually fast, or that were blocked by an external crisis. You want an average, painful example.
Phase 2: Map the States (60 Minutes)
“Write every state this ticket went through on sticky notes. Start when the product manager first wrote the idea. End when the code was live in production. Include queues. Include waiting. Include handoffs.”
Two rules for the room:
- Map what did happen, not what should happen. No debating whether a step ought to exist.
- Green notes for active work (coding, testing, reviewing), red notes for waiting (queues, approvals, handoffs).
Watch for the states people forget: waiting for a DBA, waiting for a security review, waiting for product approval, waiting for the staging environment to be free.
Phase 3: Assign Times (45 Minutes)
“Go through every note. For green notes: how many hours of actual work? For red notes: how many calendar days did the ticket sit idle?”
Pull timestamps from the ticket’s status history, the first commit and the merge in Git, and chat threads (“when did someone ask for an update?”). Where data is missing, estimate conservatively. The pattern matters more than the precision.
Phase 4: Calculate Process Efficiency (15 Minutes)
Process Efficiency = Total touch time ÷ Total lead time × 100%
Lead time is the total elapsed time from idea to production: all the touch time plus all the wait time.
Convert everything to hours and do the math in front of everyone. Write the result on the whiteboard in large numbers.
In my experience, siloed organizations usually land somewhere under 15%, and often under 10%. A typical example: 40 days of lead time containing only about 26 hours of real work. Everything else was waiting.
Let that number sit for a moment. It changes the conversation from blame (“QA is too slow”) to systems thinking (“the handoff to QA is where we lose most of our time”).
Phase 5: Identify the Top Three Queues (30 Minutes)
“Look at the red notes. Which three queues had the longest waits? Which handoffs caused the most rework?”
A useful prompt: “If we could magically remove only three waiting periods, which would cut our lead time the most?”
Phase 6: Commit to One Change (45 Minutes)
“Pick one queue to attack in the next two weeks. Not three. One. What is the smallest change that would shrink it?”
Examples:
- Waiting for the DBA: teach backend developers to write their own migrations from a reviewed template.
- Waiting for staging: set up a preview environment for every pull request.
- Waiting for product approval: embed the product owner in the team for one sprint.
Phase 7: Schedule the Follow-Up (15 Minutes)
“We’ll meet again in two weeks. If the queue shrank, we pick the next one. If it didn’t, we ask why and adjust.”
Success is not perfect efficiency. Success is that one queue being smaller than it was.
Wrapping Up
A value stream map is the cheapest diagnostic in software delivery. In one afternoon it shows where your lead time really goes, gives every group in the room the same picture, and points to the first change worth making. Run it before you restructure, and run it again every year afterward, because queues have a way of quietly coming back.
This article is adapted from Chapter 4 of my upcoming book, Vertical Velocity: How to Break Silos, Ship Faster, and Reclaim Engineering Joy. The chapter goes further: how to turn what the map shows into a pilot feature team, and a four-phase framework for growing it across the organization. Follow this blog to hear when it’s out.
No comments:
Post a Comment