How to Measure Cycle Time and Lead Time Correctly
Contents
Measure the first and last real timestamps, then split waiting time out instead of burying it.#
Cycle time is the time a team spends actively working on a unit, from work start to work finish. Lead time is the full elapsed time from request to completion, including waiting, queues, approvals, batching, and handoffs. If you mix those two together, you end up arguing about speed when the real problem is delay.
Start with the clock that matches the question#
The first mistake is using whatever timestamp is easiest to export. In messy operations, that usually means the logged-open time in a ticket system, the time a form was submitted, or the moment someone remembered to update a spreadsheet. That is not always the start of work.
Use the timestamp that matches the operational event you are trying to measure.
- For lead time, start at the moment the request becomes real work for the operation. That might be order received, ticket created, claim submitted, or job released into the queue.
- For cycle time, start when the team actually begins active work, not when the request sits waiting for approval or batching.
- For both, end at the first timestamp that proves completion, not the later timestamp when someone closed the record.
If you are measuring a warehouse pick, for example, “wave released” is often a better start point than “order entered,” because the order may sit in the queue until the next pick wave. In a service workflow, “request approved” may be the real start of cycle time, while “request submitted” is the start of lead time.
The rule is simple: measure from the first event that changes the state of the work, and stop at the first event that proves the work is done. If the timestamp only reflects admin behavior, not process behavior, it will distort both metrics.
Separate waiting from active work, or the numbers will lie#
The hardest part is not the math. It is deciding what counts as delay versus work.
Waiting periods in process metrics should stay in lead time, but they should not be hidden inside cycle time if the team is not actively working. That includes:
- Approval waits
- Customer response gaps
- Vendor or supplier delays
- Queue time between steps
- Weekend gaps and shift-change gaps
- Batching delays, where work waits until enough items accumulate
If a request is paused because someone is waiting on information, that pause is part of lead time. It is not cycle time unless the process requires active work during the pause, such as chasing the customer, reconciling missing data, or reworking the file.
That distinction matters because a team can look “slow” on cycle time when the real issue is upstream waiting, or look “fast” while lead time is exploding in the queue.
Key takeaway: Lead time tells you how long the customer or downstream user waits. Cycle time tells you how long the team actually spends working. If you collapse them into one number, you lose the diagnosis.
A practical way to handle pauses is to tag them by reason, not just by duration. On a ticket, order, or job record, the delay reason should be one of a few clean buckets:
| Delay type | Count in cycle time? | Count in lead time? |
|---|---|---|
| Waiting for approval | No | Yes |
| Waiting for customer reply | No | Yes |
| Waiting for material or inventory | No | Yes |
| Hands-on processing | Yes | Yes |
| Rework caused by bad input | Yes | Yes, if it delays completion |
| Queue before the next shift | No | Yes |
That table sounds basic, but it is where most workflow timing metrics go wrong. Teams often mark a ticket as “open” for two days while nobody touches it, then claim the cycle time is two days. It is not. It is lead time, with a long wait inside it.
If you need a deeper diagnostic structure, this is the same logic used in an operations diagnostics review and in a two-week operations diagnostic: separate the work from the wait before you try to fix anything.
Pick the timestamp that survives bad handoffs#
Handoffs are where measurement gets messy. One team logs “sent,” another logs “received,” and a third logs nothing until the task is closed. If you use the wrong timestamp, you can make the process look faster or slower by accident.
Use the earliest timestamp that is both:
- Operationally meaningful, and
- Consistently recorded across most cases
Usually that means one of these:
- The timestamp when the item enters the next work queue
- The timestamp when the receiving team acknowledges receipt
- The timestamp when the system changes status from one stage to the next
If only one side of the handoff is logged, trust the side that is closest to the actual state change. For example, in a purchase order workflow, “sent to supplier” is not the same as “supplier accepted.” If supplier acceptance is the real start of the next phase, use that when it exists. If it does not exist reliably, use the outbound send timestamp and state the limitation.
Do not average two timestamps together to “split the difference.” That creates false precision. It looks neat in a dashboard and useless in a review.
For handoffs and lead time, the safer rule is this: use the timestamp that marks when the next owner can actually begin work. If that does not exist, use the closest proxy and call it out.
Batch size and calendars can distort the story#
Batching delays, shift changes, and weekend gaps can make a stable process look broken. They can also hide a bottleneck by spreading delay across days when the real issue is one short processing window.
A few examples:
- An order released Friday afternoon and picked Monday morning did not take three days of active work.
- A request queued until a daily approval meeting did not sit idle because the team was slow, it sat because the calendar was fixed.
- A batch of 200 claims processed in one afternoon may show a short cycle time, even if the queue built for four days before the batch ran.
If you do not separate calendar time from processing time, you will misread the operation. This shows up a lot in Remote / nationwide teams with distributed approvals, and in Danville, California businesses that run across Bay Area hours but still depend on fixed-shift warehouse or admin coverage.
The fix is to track both elapsed time and active time, then segment the delay.
- Elapsed lead time: calendar time from request to completion
- Active cycle time: time actually spent being worked
- Queue time by stage: time waiting between handoffs
- Non-working time: nights, weekends, holidays, and planned shutdowns
If your data system cannot calculate business hours cleanly, do not fake it with a rough average. Pull the raw timestamps and calculate the gap manually for a sample first. That is often enough to see whether the problem is queueing, batching, or actual process slowness.
This is also where baseline targets for operations metrics matter. A target built on calendar time alone can punish the wrong team and reward the wrong fix.
Minimum reliable method when the data is ugly#
If all you have is ticket data or spreadsheet notes, you can still measure cycle time and lead time correctly enough to diagnose the issue. You just need to be disciplined about the sample.
Use this minimum method:
- Pick a narrow workflow, not the whole department.
- Define one start event and one end event.
- Pull 20 to 30 recent cases that are representative, not cherry-picked.
- Record the timestamps for request received, work started, each handoff, and completion.
- Mark every gap as either active work, waiting, or unknown.
- Calculate lead time from first request to completion.
- Calculate cycle time from first active work to completion, or by summing only the active work segments if the job has multiple work periods.
- Note every assumption beside the number.
If the spreadsheet only has notes like “waiting on customer” or “sent to ops,” that is still usable. You can turn those notes into stage boundaries. What you cannot do is treat every note as equal. A vague note is a clue, not a timestamp.
For a messy dataset, the most reliable output is often a range, not a single number. For example: “Median lead time was 4.2 days, with 1.8 days of active work and 2.4 days of waiting, based on 24 cases from March.” That is far more useful than a clean-looking average built on guessed timestamps.
If you need the findings to hold up with leadership, this is the same discipline used in turnover-cost baselines that leaders trust: be explicit about scope, assumptions, and what the number does not include.
When the team’s story and the numbers disagree#
When people say “the delay is in approval” but the data says “the delay is in processing,” do not pick a side too quickly. Check which measure actually isolates the bottleneck.
Usually, lead time reveals the customer-facing pain, but cycle time reveals where the operation is spending hands-on effort. If lead time is bad and cycle time is fine, the bottleneck is usually waiting, queueing, or handoff delay. If cycle time is bad too, the work itself is slow, inconsistent, or reworked too often.
A quick check:
- If lead time is high and cycle time is low, look at approvals, batching, inventory, staffing coverage, or handoff lag.
- If both are high, look at process design, rework, training, or system friction.
- If cycle time is low but throughput is still down, the issue may be demand mix, staffing coverage, or upstream starvation, not effort per task.
That last point matters. A team can be “busy” and still not move work. If you are trying to tell whether throughput dropped because of staffing, process, or demand, cycle time alone will not answer it. You need to compare work volume, queue size, and time in each stage.
If the numbers and the floor story still disagree, check three things:
- Whether the timestamps are tied to real state changes
- Whether waiting periods were separated from active work
- Whether handoffs were logged from both sides or only one
That is often enough to find the mismatch. In operations diagnostics, the problem is rarely that the team is wrong. It is usually that the metric was defined loosely enough to prove two different stories.
Common questions#
What timestamp should I trust when handoffs are logged inconsistently?#
Use the timestamp that marks when the next owner can actually start work. If that is missing, use the closest proxy that is recorded consistently, and note the limitation right next to the metric.
How should I count waiting on approval, information, or a customer reply?#
Count it in lead time, not cycle time, unless someone is actively working during the wait. Keep the pause as its own delay bucket so you can see whether the problem is approval lag, customer lag, or internal queueing.
How do I keep weekend gaps and batching from distorting the metric?#
Track elapsed calendar time and active work time separately. Then break the delay into queue time, non-working time, and processing time so a Friday-to-Monday gap does not get mistaken for three days of effort.
What is the minimum reliable way to calculate these metrics from messy data?#
Use a small sample, one start event, one end event, and explicit waiting tags for each gap. If the data is rough, report a median and a range, not a fake-precise average.
Measure the process, then decide whether to fix it yourself#
If you want the cleanest read, start with one workflow, pull 20 to 30 recent cases, and separate active work from waiting time before you calculate anything. That gives you a defensible cycle time and lead time view, even when handoffs are messy.
If you want that done faster, Operations Diagnostics is built for this kind of problem. It identifies where the operation is actually slowing down, quantifies the annual cost, and pins findings to SCOR stages so you can see whether the delay sits in Plan, Source, Make, Deliver, Return, or Enable.


