Lead Time vs Cycle Time: How to Measure and Understand Software Delivery Speed
A practical, methodology-first guide to separating active work from waiting queues, calculating flow metrics without statistical bias, and diagnosing engineering bottlenecks.
When a feature takes weeks to reach production, active development often accounts for only a small fraction of the calendar time: most of the delay sits in queues (refinement, backlog waiting, code review, or QA). Cycle Time and Lead Time make those waiting times visible so teams can move from vague impressions ("we feel slow") to concrete discussions about their workflow.
The essentials in 30 seconds
- Lead Time and Cycle Time measure two distinct segments: Lead Time covers total wait from request creation to delivery, while Cycle Time covers active work from start to completion — both depend on consistent start and end boundaries.
- An average alone hides very different realities: software durations are skewed, so reading available percentiles (P50 and P85 in Cauba) alongside the average exposes spread and stalled items.
- These metrics are for discussing how flow works, not judging people or chasing universal benchmarks: they measure individual ticket duration (distinct from backlog delivery horizons).
1. Distinguishing Cycle Time and Lead Time
In software delivery, Cycle Time generally refers to the elapsed time between the start of active work on a work item and its completion (Done / Resolved). The exact boundary events depend on the team's workflow and measurement conventions (commonly "In Progress" → "Done").
It reflects operational turnaround time once work is genuinely underway.
Lead Time (end-to-end duration)
Lead Time measures total elapsed time from the requester's or customer's perspective: from initial request intake to final delivery.
Unlike Cycle Time, Lead Time includes upstream waiting, triage, and prioritization in the backlog. Depending on your workflow, the entry boundary is either ticket creation or the formal commitment point where the team accepts the request.
Direct Comparison
These three indicators answer complementary operational questions:
| Metric | Starting Point | Ending Point | What It Measures | Key Question |
|---|---|---|---|---|
| Lead Time (Total System Time) | Issue Creation / Request Expressed | Resolution / Production Release | Total end-to-end duration perceived by the requester (including backlog waiting). | “How long does it take from an idea being logged to being delivered?” |
| Cycle Time (Active Delivery Time) | Active Work Started (In Progress) | Resolution / Done | Active processing time by the team. | “Once we start working on a ticket, how long does it take to finish?” |
| Upstream Queue Time (Waiting Time) | Issue Creation | Active Work Started | Time spent waiting before active work begins. | “How long do requests sit idle before being picked up?” |
2. Concrete Ticket Example and Calculation Formulas
Follow a feature ticket (PAY-42) moving across a team board:
- Created: Monday, Oct 5 at 09:00 (Created in Backlog)
- Started: Wednesday, Oct 7 at 09:00 (Picked up — Transition to In Progress)
- Resolved: Friday, Oct 9 at 17:00 (PR merged, verified, and moved to Done)
If the team focuses solely on coding speed, it can only influence the 2 days of Cycle Time while half of the total customer wait sits upstream.
General Definition vs Calculation in Cauba
Methodologically, these durations come from subtracting two timestamps. In Cauba, the calculation is 100% deterministic and expressed in whole calendar days (the integer part of the gap; leftover hours are not counted):
3. Reading Results: Averages, Spread, and Percentiles
In software delivery, cycle times almost always follow a right-skewed, heavy-tailed distribution: most tickets finish quickly while a handful get stalled for much longer. An average alone can hide opposite realities:
Inspecting dispersion alongside the average surfaces those bottlenecks instead of relying on a single summary figure.
Reading Available Percentiles (P50 and P85)
To describe a skewed delivery distribution clearly, Lean/Agile practices rely on historical percentiles:
- P50 : P50 (Median): 50% of observed tickets finished in X days or less. This central benchmark is far less sensitive to extreme outliers.
- P85 : P85: 85% of observed tickets finished in Y days or less. Read alongside the median, it reveals the spread of delivery times (P85 − P50).
In Cauba, Cycle Time metrics compute P50 and P85 only (in whole calendar days, once at least 10 completed tickets carry both a start date and a completed date). Cauba does not compute a P95 on Cycle Time and never falls back to Created Date when Started Date is missing.
Do not confuse ticket duration with a backlog forecast: Cycle Time P85 describes the historical duration of a single ticket (in days), whereas Monte Carlo P50, P85, and P95 horizons estimate how many sprints or weeks are needed to complete a batch of remaining items.
Percentiles also feed delivery forecasts for a whole backlog: Forecasting backlog delivery with Monte Carlo
Is There a "Good" Cycle Time?
Claims like "a good Agile cycle time must be under 3 days" have no methodological basis.
Cycle Time depends on ticket slicing, architecture, compliance constraints, and CI/CD automation. The only meaningful benchmark is comparing your team against its own historical baseline.
4. Practical Questions to Ask the Team
A rising Cycle Time never proves a single cause on its own: it opens a team conversation around concrete hypotheses to check on recent tickets:
1. Excessive Work in Progress (WIP)
2. Code Review Waiting Time
3. QA or Staging Queues
4. Unsynchronized External Dependencies
5. Oversized Tickets
6. Mid-Flight Requirement Changes
7. Technical Debt and Flaky CI/CD
8. Shift in Work Mix
Oversized tickets are a frequent driver of end-of-sprint spillover: Sprint predictability and rollover
5 Concrete Levers to Improve Flow
To improve delivery flow without overburdening the team, focus on small system experiments:
Scrum, Velocity, and DORA: Three Common Mix-Ups
Cycle Time in Scrum: contrary to a common myth, Cycle Time is not just for Kanban. A Sprint Burndown can look healthy while hiding tickets only closed on the final day; tracking Cycle Time supports steady intra-sprint delivery and reduces spillover.
The spillover mechanism is covered in detail: Sprint predictability and rollover (carryover)
Velocity counts delivered volume per sprint (in tickets or estimates), whereas Cycle Time measures factual calendar duration per ticket.
Velocity informs periodic capacity; Cycle Time measures workflow responsiveness and fluidity.
To move from velocity to date forecasts: From estimates to forecasts based on real deliveries
DORA's Lead Time for Changes measures technical pipeline duration from commit to production deployment.
Product Lead Time (covered in this guide) starts when the request is logged in the backlog: both are useful, but they measure different segments of delivery.
5. Required Data, Boundaries, and Interpretation Limits
There is no single universal Cycle Time boundary: choose start and end statuses that match the question your team wants to answer, and keep that convention consistent over time:
Required Data from Jira (and Common Pitfalls)
To compute Lead Time and Cycle Time accurately from Jira, a targeted CSV export is enough as long as the right timestamps are present:
- Created Date: required for Lead Time.
- Started / In Progress Date: required for Cycle Time. If missing, never substitute Created Date.
- Resolved / Completed Date: finish boundary for completed tickets.
- Status: isolates genuinely completed items (and keeps discarded/cancelled items out).
- Reopened tickets or skipped statuses: a ticket jumping straight from Backlog to Done without a start date cannot yield a reliable Cycle Time.
What Cauba Actually Computes
From your CSV export (Jira, Azure DevOps, Linear, GitHub, GitLab), Cauba runs 100% deterministic calculations:
- Lead Time (Created → Completed) and Cycle Time (Started → Completed) in whole calendar days, with no fallback when a date is missing.
- Cycle Time P50 (median) and P85 percentiles (computed once at least 10 completed items have both start and completed dates) plus spread (P85 − P50).
- Rule FLOW-002 (detecting excessive Lead Time vs Cycle Time gaps on items with all three consistent dates) and Rule TREND-005 (trend correlation between rising WIP and rising Cycle Time).
When a required field is missing or the sample is too small, Cauba explicitly marks the metric as unavailable along with the reason.
Recommended Methodology Guides
Sprint Predictability & Rollover (Carryover)
Understand how unmanaged cycle time drives end-of-sprint spillover and how to stabilize team commitments.
Preparing a Jira Export to Analyze Software Delivery Flow
Step-by-step guide to extract a CSV without plugins, map statuses, and compute flow metrics in Cauba.
Moving from Estimates to Forecasts Grounded in Real Delivery Data
Learn how to complement per-ticket durations with observed throughput to forecast when a backlog scope will be delivered.
Forecasting Backlog Delivery with Monte Carlo
Understand what the P50, P85 and P95 horizons of a Monte Carlo forecast mean, and where their limits lie.
Frequently Asked Questions about Cycle Time and Lead Time
References and Recommended Reading
- Daniel S. Vacanti — Actionable Agile Metrics for Predictability (2015). Foundational text on flow metrics, cycle time distribution skewness, and percentile forecasting.
- David J. Anderson — Kanban: Successful Evolutionary Change for Your Technology Business (2010). Formal definitions of Commitment Points, Lead Time, and Work In Progress (WIP) constraints.
- Scrum.org & ProKanban — The Kanban Guide for Scrum Teams (2020). Official guide integrating the 4 core flow metrics (Cycle Time, WIP, Throughput, Work Item Age) with Scrum.
- DORA (DevOps Research and Assessment) — State of DevOps Report. Defines Lead Time for Changes (commit to deploy) in continuous delivery engineering.
