9 min

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.

Flow Visualization: Deconstructing Lead Time and Cycle Time
1. Request Created
Backlog / Triage
Upstream Queue Time
Prioritization & refinement
2. Work Started
Transition to "In Progress"
Active Engineering Work
Coding, review, testing
3. Work Delivered
Transition to "Done" / Released
LEAD TIME (Total End-to-End Delivery Time)
CYCLE TIME (Active Engineering Duration)

Direct Comparison

These three indicators answer complementary operational questions:

MetricStarting PointEnding PointWhat It MeasuresKey Question
Lead Time (Total System Time)Issue Creation / Request ExpressedResolution / Production ReleaseTotal 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 / DoneActive 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 CreationActive Work StartedTime 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:

PAY-42: Add instant bank transfer payment option
  • 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)
Lead Time = 4 days (Monday 09:00 → Friday 17:00, i.e. 4 days and 8 hours; Cauba keeps whole calendar days).
Cycle Time = 2 days (Wednesday 09:00 → Friday 17:00, i.e. 2 days and 8 hours; Cauba keeps whole calendar days).
Upstream Queue Time = 2 days (Lead Time − Cycle Time), i.e. 50% of the Lead Time spent waiting before work even started.

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:

Team A (5 items): 4 d, 5 d, 5 d, 5 d, 6 d ➔ Mean = 5.0 days | Tight spread.
Team B (5 items): 1 d, 2 d, 2 d, 3 d, 17 d ➔ Mean = 5.0 days | One severely blocked item at 17 days.
Both teams share the exact same 5.0-day average, yet Team A delivers steadily while Team B has a severe bottleneck masked by quick tickets.

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)

Hypothesis: Multiple tasks advance in parallel, multiplying context switches.
Action to test: Test explicit WIP limits on the In Progress column.

2. Code Review Waiting Time

Hypothesis: Pull requests sit open for days waiting for review.
Action to test: Prioritize reviewing open PRs before starting new tickets.

3. QA or Staging Queues

Hypothesis: Code is ready but waits for a test environment or manual sign-off.
Action to test: Automate core checks or bring testing earlier into the workflow.

4. Unsynchronized External Dependencies

Hypothesis: Tickets stall while waiting on another team or third-party approval.
Action to test: Flag blockers visibly on the board and map dependencies before starting.

5. Oversized Tickets

Hypothesis: Multi-week items enter active work without vertical slicing.
Action to test: Slice stories into smaller, independently shippable increments.

6. Mid-Flight Requirement Changes

Hypothesis: Scope shifts after implementation has already started.
Action to test: Clarify acceptance criteria before pulling items into progress.

7. Technical Debt and Flaky CI/CD

Hypothesis: Unreliable builds or manual releases trigger recurring rework.
Action to test: Invest in build reliability and deployment automation.

8. Shift in Work Mix

Hypothesis: The share of complex bugs or infrastructure tasks temporarily increased.
Action to test: Break Cycle Time down by issue type (Story, Bug, Task) before drawing conclusions.

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:

1. Limit Work in Progress (WIP)Fewer concurrent tasks accelerate how quickly each item crosses the board (Little's Law).
2. Cut Review and Verification WaitsFinish items closest to "Done" before starting new work.
3. Slice Work into Smaller IncrementsSmaller tickets carry fewer unknowns and move through the workflow more steadily.
4. Make Blockers VisibleHighlight stalled items and examine recurring root causes in retrospectives.
5. Track the P85 − P50 SpreadFocus first on shrinking the long tail of stalled tickets rather than speeding up already fast items.

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)

Cycle Time vs Velocity

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

Product Lead Time vs DORA "Lead Time for Changes"

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:

Created → Done (Full Lead Time)End-to-end delay seen by the requester, useful for overall responsiveness.
Selected for Development → Done (Commitment Cycle Time)Elapsed time from the team's formal commitment point to delivery.
In Progress → Done (Engineering Cycle Time)Most common convention for tracking active implementation and verification.
In Progress → In Review / QA (Pure Development)Isolates coding duration prior to review and QA queues.

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.

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

Track both: they answer different questions. Lead Time reflects what the requester experiences, including backlog waiting; Cycle Time shows how quickly the team moves once work has started. A large gap between the two points to upstream queues, while a long Cycle Time points to bottlenecks during the work itself (review, QA, blockers).

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.