Playbooks & Templates

Process Flow Template

This is a row-per-step map of a single workflow, from a clear start to a clear end, that records what happens, who owns it, how long the step actually takes, and how long the work waits before it. The output is one ranked list of bottlenecks, the steps where the work sits longest or breaks most often, so you can argue about a fix from evidence instead of opinion. It earns its place the moment a process feels slow but nobody can point to where.

TemplateWorkflowProcess

When to use this

  • A request takes days to come back and nobody can say which step ate the time.
  • Two people describe the same process differently and you need one agreed picture before changing anything.
  • You are about to automate a step and want proof it is the real constraint, not just the loudest complaint.
  • A handoff between teams keeps stalling and you cannot tell whether the delay is in the work or in the wait before it.
  • A new hire keeps asking how a process runs and the only answer lives in one person's head.
  • You suspect rework: the same item bounces back to an earlier step and you want to see how often.
  • Before a tool or vendor pitch, you want the current state on one page so you can judge what the change would actually remove.

What it helps clarify

  • Where the time goes: the split between active work time and the wait time that sits in front of each step.
  • The single slowest step and whether the delay is processing or queueing, which point to very different fixes.
  • Who owns each step and where ownership is unclear, which is usually where work goes quiet.
  • Every handoff between people, teams, or systems, since handoffs are where items wait and context gets lost.
  • Where the process loops back: the rework paths that quietly double the real cost of a step.
  • Which steps add value the customer would pay for and which exist only to move, check, or wait.

Why a row-per-step map beats a tidy flowchart

Most teams already have a diagram of their process. A box, an arrow, a diamond for a decision, all neat. It tells you the order of the work and almost nothing about the cost of it. The reason a process feels slow is rarely visible in the shapes, because the slow part is usually the empty space between two boxes, the time an item spends waiting for someone to pick it up.

The numbers are stark. Lean studies of real workflows find that the time a unit is actively worked on is often only 5–15% of the total time it spends in the process, and the other 85–95% is waiting. Knowledge work is no better. Kanban University reports that teams who have never measured it typically land around 15% flow efficiency, meaning roughly 85% of a request’s life is spent queued, blocked, or sitting in someone’s inbox. If your map only shows steps and arrows, it is describing the 15% and hiding the 85% that actually makes you slow.

This template fixes that by giving wait time its own column, separate from process time, on every row. That one split is the whole point. When you fill it in honestly, the read-out usually surprises the people who run the process every day: the step everyone complains about (the export script, the long form, the slow tool) is fast, and the real loss is a two-day queue with no owner that nobody ever named. You cannot argue for the right fix until the map shows you which kind of problem you have. A slow process step wants better tooling or a smaller batch. A long wait wants an owner, an SLA, or a removed approval. Pour automation onto a step that was never the constraint and the work comes out the other end exactly as slow, because the bottleneck just moved to the next queue.

How to fill it in, with a strong row versus a weak one

Map the process that runs, not the one written in the policy doc. The fastest way is to walk one real item from trigger to done, asking at each step: what started this, who did it, how long were they actually on it, and how long did it sit before they started. Write the messy truth. A row that says "unclear" under owner is doing more work than a row that names a role nobody really fills.

A weak row looks like this: Step 2 | Data team | takes a while | sometimes slow. It blames a team, gives no split between work and wait, and offers nothing to act on. "Takes a while" cannot be ranked against anything.

A strong row for the same step looks like this: Step 2: sits in data queue | Owner: unclear | Trigger: ticket tagged "data" | Process: 0 | Wait: 2 days | Handoff: none | Loop: none | Value: waste | Note: no SLA, ordered by hand FIFO. Now the step is observable. Process time is zero because no one is working, the cost is 2 days of pure wait, the owner is honestly marked unclear, and the value tag calls it what it is. A reader can immediately see the fix is an owner and an SLA, not a faster tool.

Work the columns in this order. First the easy four with the team in the room: step name, owner, trigger, handoff. Then the two that take real data: process time and wait time. Estimate them live to start the conversation, then go get the truth, a week of timestamps from your ticket or build system beats anyone’s memory, and the gap between the estimate and the measurement is itself a finding. Tag value last, from the customer’s point of view. Three tags are enough. Value-add is a step the customer would happily pay for. Necessary is a step you must do but the customer would not pay for on its own, like a compliance check or a required approval. Waste is everything that only moves, copies, re-keys, or waits. Most queues are waste. Most checks are necessary. Be ruthless, because every waste tag is a candidate for removal before you reach for any tool.

Finally, fill the read-out block. Add up process time for total active work. Add work plus wait for total end-to-end. Divide the two for flow efficiency. Name the single slowest step and, crucially, whether its cost is process or wait. Name the biggest rework loop. Then commit to one fix aimed at the top constraint. One per pass is deliberate.

Pitfalls, and what changes when a team relies on the map

Four traps make a map feel finished while leaving the work undone.

  • Mapping the ideal, not the real. The cleanest maps describe how the process is supposed to run. The useful ones describe the workaround everyone actually uses, the approval that gets skipped when the approver is out, the spreadsheet kept on the side. If your map has no "unclear" owners and no rework loops, you probably mapped the brochure.
  • Collapsing process and wait into one number. A single "duration" column erases the most common finding. Keep the two columns apart on every row, even when one of them is zero, because a zero in process time next to two days of wait is exactly the picture you are hunting for.
  • Ranking from feelings. The loudest step is rarely the slowest one. Estimates open the conversation, but do not declare a bottleneck until you have pulled real timestamps. The export script in our example feels slow and gets all the complaints; the queue in front of it is four times more expensive and silent.
  • Fixing everything at once. Relieve one constraint, let the process settle, then re-measure. The bottleneck moves. A queue you drained last month is no longer the problem this month, and a second map taken after the fix is the only honest way to know it worked.

On a team, the map stops being a one-time exercise and becomes a shared baseline. Put one role’s name in the owner column for the map itself, the way you put owners on the steps, so it gets re-walked on a cadence (a quarter is a reasonable default) and after any real change. The rows tagged handoff deserve special attention at scale: a handoff is where an item waits for a new person to notice it and where context gets dropped, so those rows are where most of your wait time and most of your rework will cluster. When two teams share a process, map it together in one room; the disagreement about how a step really works is the finding, and resolving it on the page is half the value.

When the map points at a fix, hand off to the right companion. For the symbols and the basics of drawing the flow, see Process Flow Basics in Better Ways of Working. For the rows you tagged as handoffs, Handoff Quality covers what must be complete and traceable before work moves on. And when the fix you land on is to automate or delegate a step to an agent, run that one step through the Agent Readiness Checklist first, naming its blast radius and rollback, before you let it approve, send, or write anything on its own. On your next real task, pick one process that everyone agrees is slow, walk a single item through it, and fill just the process-time and wait-time columns. The split alone will usually tell you where to start.

The template

One row per step, in order, from a named trigger to a named end state. Fill the easy columns live with the team, then go get the real numbers.

  • Step number and name : a short verb phrase for what happens, like "QA reviews export" or "Manager approves refund", numbered so you can refer to step 4 in a meeting.
  • Owner / role : the role accountable for this step, not a person's name, so the map survives someone leaving. Mark a step "unclear" honestly when no one owns it.
  • Trigger : what causes this step to start, like "ticket tagged ready" or "previous step done", so you can see what the step is actually waiting on.
  • Process time : how long the work itself takes when someone is actively on it, in real units (25 minutes, 2 hours), measured or estimated and labeled which.
  • Wait time : how long an item typically sits before this step starts, in a queue, an inbox, or pending an approval. This is usually the biggest and most ignored number.
  • Handoff : whether the step ends by passing work to a different person, team, or system, and to whom. Mark "none" when the same owner continues.
  • Rework / loop : whether work can bounce back to an earlier step from here, where it goes, and roughly how often, like "back to step 2, about 1 in 5".
  • Value : tag each step value-add (the customer would pay for it), necessary (required but not value, like a compliance check), or waste (pure transport, duplicate entry, idle wait).
  • Pain / notes : the known problem at this step in one line, like "two systems re-keyed by hand" or "approver out, no backup".

Example

Worked example: Priya maps the paginated orders export request
Process: customer asks support to export their orders to CSV. Trigger: ticket created. End: file delivered. 1. Support logs request | Owner: Support agent | Trigger: ticket created | Process 10m | Wait 0 | Handoff: to Data team | Loop: none | Value: necessary | Note: free-text, no template 2. Sits in Data queue | Owner: unclear | Trigger: ticket tagged data | Process 0 | Wait 2 days | Handoff: none | Loop: none | Value: waste | Note: no SLA, FIFO by hand 3. Engineer runs export | Owner: Backend dev (Maya) | Trigger: dev picks up | Process 40m | Wait 0 | Handoff: to QA | Loop: none | Value: value-add | Note: manual script, paginates by hand 4. QA spot-checks file | Owner: QA | Trigger: file ready | Process 20m | Wait 4 hours | Handoff: back to dev or to Support | Loop: back to step 3, about 1 in 4 | Value: necessary | Note: missing rows on big accounts 5. Support sends to customer | Owner: Support agent | Trigger: QA passed | Process 10m | Wait 6 hours | Handoff: to customer | Loop: none | Value: value-add | Note: agent may be offline Read-out: active work is about 80 minutes. End-to-end is roughly 3 days. The constraint is step 2 (a 2-day wait with no owner), not the export script everyone blames. Step 4's 1-in-4 loop is the second target.

Usage notes

  • Map the process that runs, not the one in the policy doc. Walk one real item end to end and write what actually happened, then mark the gaps where the doc and reality disagree.
  • Fill process time and wait time as separate columns every time. Collapsing them into one "duration" hides the most common finding, that the work is fast and the waiting is slow.
  • Get the numbers before you rank. Live estimates start the conversation; pull a week of real timestamps from your ticket tool before you call a step the bottleneck.
  • Fix one step per pass. Relieve the top constraint, let the process settle, then re-measure, because the bottleneck usually moves to the next slowest step once you free the first.
  • Pair this with Process Flow Basics in Better Ways of Working for the mapping symbols, and with Handoff Quality for the rows tagged as handoffs.
  • When the fix is an automation or an agent, run the candidate step through the Agent Readiness Checklist before you hand it over, especially anything that approves, sends, or writes.

Copyable template

PROCESS: <name> Trigger (start): End state (done): Mapped by / date: STEPS (one row each) # Step name | Owner/role | Trigger | Process time | Wait time | Handoff to | Rework/loop | Value (add/necessary/waste) | Pain note 1. 2. 3. 4. 5. READ-OUT - Total active work time: - Total end-to-end time (work + wait): - Flow efficiency (work / end-to-end): - #1 bottleneck (step, and is it process or wait?): - Biggest rework loop: - One fix to try first:

Downloadable version

A row-per-step process map with a read-out block that turns the rows into a ranked bottleneck.

Preview

FieldWhat to captureWorked example
Frame the process
Process nameThe one workflow this map covers, narrow enough to fit on a pageExport a customer's orders to CSV on request
Trigger (start)The single event that begins the process, so the map has a clean edgeSupport ticket created and tagged "data"
End state (done)What "finished" looks like, the moment you stop countingCSV file delivered to the customer
Mapped by / dateWho built the map and when, so a stale map is obviousPriya, walked one real ticket on 2026-06-10
One row per step
Step nameA short verb phrase, numbered, for what happens here3. Engineer runs the export script
Owner / roleThe accountable role, not a name; mark "unclear" when noneBackend developer; step 2 owner is unclear
TriggerWhat makes this step start, so you see what it waits onDev picks the ticket off the data queue
Process timeActive work time when someone is on it, with units40 minutes, estimated (not yet measured)
Wait timeHow long an item sits before this step starts2 days in the data queue, no SLA
HandoffWho the work passes to at the end, or "none"Hands off to QA for a spot-check
Rework / loopWhere work can bounce back, and how oftenBack to step 3 on missing rows, about 1 in 4
Value tagValue-add, necessary, or waste, from the customer’s viewStep 2 wait is waste; QA check is necessary
Pain / noteThe known problem here, in one lineScript paginates by hand, misses big accounts
Read-out (fill after the rows)
Total active workSum of process time across all stepsAbout 80 minutes of real work
Total end-to-endWork plus wait, the time the customer feelsRoughly 3 days door to door
Flow efficiencyActive work divided by end-to-end, as a percent80 min of 3 days is well under 5 percent
Top bottleneckThe slowest step, and whether it is process or waitStep 2: a 2-day wait, not the export script
Biggest loopThe rework path that costs the mostStep 4 to step 3, hit on 1 in 4 exports
First fix to tryOne change aimed at the top constraint onlyAssign a data-queue owner and a same-day SLA
Process Flow Template