The cost of waiting: where your process time actually goes

When a client asks us to make a process faster, the first instinct in the room is usually to automate the slowest step. It is almost always the wrong place to start. In the last three years we have timed more than two hundred business processes end to end — loan approvals, purchase orders, insurance claims, customer onboarding — and the pattern is remarkably consistent. The work itself takes a small fraction of the elapsed time. The rest is a file sitting in a queue, waiting for someone to notice it.

Lean practitioners call the ratio between working time and elapsed time flow efficiency.¹ In the processes we have measured, the median is seven per cent. A nine-day loan approval might contain five hours of genuine work.

Walk the work, not the process map

Process maps describe how work is supposed to flow. They are rarely how it does. The most useful thing we do in the first week of an engagement is pick twenty to forty real cases and follow each one from start to finish, recording every handover, every wait and every rework loop.

“The slowest step is rarely the problem. The space between the steps is.”

You need surprisingly little tooling for this. A shared spreadsheet with one row per case, one column per handover and a timestamp in each cell will tell you more than most process-mining software. If your systems keep audit logs, a simple query can do the same thing at scale:

select
  case_id,
  max(event_at) - min(event_at)                         as elapsed,
  sum(case when state = 'in_progress'
           then next_event_at - event_at end)           as active,
  round(100.0 * extract(epoch from sum(
    case when state = 'in_progress'
         then next_event_at - event_at end))
    / extract(epoch from max(event_at) - min(event_at)), 1) as flow_efficiency_pct
from (
  select *, lead(event_at) over (partition by case_id order by event_at) as next_event_at
  from workflow_events
) e
group by case_id
order by elapsed desc;

Three common sources of waiting

• —Batching: work collected and processed once a day or once a week, so every item waits for the slowest.
• —Invisible queues: files sitting in an inbox or a shared folder with no owner and no age.
• —Rework: incomplete applications sent back to the customer, restarting the clock each time.

Each of these is cheaper to fix than a new system. Making queues visible — a simple board showing every open item and how long it has waited — often cuts elapsed time by a third within a month.² Technology helps most once the flow is clear: capturing documents completely the first time, routing work automatically, and showing every case’s age to the person responsible for it.

Where to start on Monday

Pick one process that customers complain about. Follow twenty cases. Write down every wait. You will likely find that the business case for change is larger, and the first fix smaller, than anyone expected.