liveBook · Manning

Lead time

As explained in Build High Value Software Systems

The elapsed time between the start of work and delivery of its result.

Fast coding and frequent deployments do not guarantee fast delivery. Lead time is the calendar time from a request entering the system to the customer receiving the result. For a software change, measure from request creation to deployment in production. Backlog, coding, review, CI, deployment, and every wait between them count. section 9.2.1 section 9.5

Daily deployments, a 23-day wait

A team deployed daily, yet customer-reported issues took an average of 23 days to reach production. Roughly three days involved active work. The remaining time was consumed by queues, handoffs, reviews, and deployment windows. Deployment frequency alone had hidden the customer’s wait. section 9.1

To measure a representative set of completed changes:

  • Record when each request arrived, work started, and the change reached production. Issue trackers, Git history, and deployment records can supply the timestamps. section 9.5
  • Calculate lead time in calendar days. Compare it with cycle time, which starts when work begins. Their difference is the pre-work backlog wait; delays during review or deployment remain inside cycle time. section 9.5 section 9.2.1
  • Report the median (p50) for a typical ticket and p90 for slower common cases. Investigate exceptional outliers separately rather than letting an average obscure typical flow. section 9.2.1
Listing 9.1 Lead time calculation from issue tracker data
from datetime import datetime
 
def lead_time_days(request_created: datetime, deployed_at: datetime) -> float:
    """Calendar days from request creation to production deployment."""
    return (deployed_at - request_created).total_seconds() / 86400
 
def summarize_lead_times(items: list) -> dict:
    """Compute median and percentiles for a set of completed work items."""
    lead_times = sorted(
        lead_time_days(i.created, i.deployed) for i in items
    )
    n = len(lead_times)
    return {
        "p50": lead_times[n // 2],
        "p75": lead_times[int(n * 0.75)],
        "p90": lead_times[int(n * 0.90)],
        "min": lead_times[0],
        "max": lead_times[-1],
    }
 
items = fetch_completed_items(last_n=20)
stats = summarize_lead_times(items)
print(f"Median lead time: {stats['p50']:.1f} days")
print(f"90th percentile: {stats['p90']:.1f} days")

A small Python listing calculates request-to-deployment durations and summarizes completed tickets with percentiles; a dedicated analytics platform is not required to begin. section 9.2.1

Use the number to find a delay, not to judge how busy developers look. Trace one shipped feature backward through its states, locate its longest sustained wait, and test a small change there. Measure the next feature again: did lead time fall, or did the constraint move? Track the median over weeks and pair speed measures with quality guardrails so an apparent improvement is not mistaken for better delivery. section 6.6 section 9.6

How Build High Value Software Systems covers it

How deep it goes
Defines calendar-day endpoints, distinguishes related durations, and gives a timestamp-based exercise and percentile calculation.
Examples
Uses a 23-day issue-resolution case, completed-ticket timestamps, and a Python percentile calculation.
What it assumes
Assumes access to completed work items and their timestamps; teaches the lead-time calculation without requiring a dedicated analytics platform.
What you can do after
Diagnose/debug with it by locating the longest delivery delay, testing an intervention, and checking whether total lead time improves.
How it connects
Connects cycle time and activity ratio with queues, control charts, Kanban work-in-progress, and quality guardrails.

Also explained in

Compare how 10 books explain lead time →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Build High Value Software Systems. The section links point to the parts of the book it draws on.