Change lead time
elapsed time from commit to deployment in production
What it is
Change lead time is the elapsed time from a change being committed to version control to that change being deployed in production. DORA uses this interval to describe software delivery throughput. It measures both work and waiting after the start event. If a change is committed on Monday morning and its first successful production deployment finishes on Tuesday afternoon, the elapsed interval includes the night and any time spent waiting for review or release.
The interval starts with a recorded commit. Lead time from a customer request, time spent writing code and time until a feature is enabled for users answer different questions. If code is deployed while its feature flag remains disabled, the code may already have a production deployment timestamp. The later exposure can be recorded separately. Define what your organization means by successful production deployment, especially if production has regional waves or several distinct targets.
A chart value is meaningful when its population is clear. Choose a service or application, define the production targets for it and say which source changes enter the calculation. Attribute each change to the first qualifying production deployment that includes it. Some histories record a squash or merge instead of the original commits. A metric based on the merge commit uses a different start and leaves the earlier review time outside the interval. Document the choice so a reader can understand what is being compared.
Why it matters
Waiting is often easier to miss than work. If compilation takes six minutes and the accepted change waits two days for a deployment slot, a faster compiler changes only a small part of the measured interval. Record the handoffs that matter, such as the end of review, artifact creation, staging checks, approval and production. A simple timeline of a few changes can reveal a queue before an elaborate reporting tool is needed.
Use the measure to ask about the delivery system shared by a team. A small production fix and a change that crosses a platform boundary have different constraints. Comparing individual engineers may reward smaller tasks or encourage them to commit late. Comparing a service with its own earlier history after an explicit process change helps the team interpret what moved. Look at slow cases as well as typical ones and pair the finding with evidence about delivery stability.
Separate the metric from the objective. A team may decide that reducing wait at an approval step is worthwhile because a released fix can help customers sooner. It still needs evidence that the faster process catches defects and handles failures. DORA reports deployment recovery and failure-related measures alongside throughput. Changes in several measurements together can help determine whether a shorter path became safer, riskier or merely different.
What it looks like in practice
The case on automating GIS software deployment documents a manual test, build and deploy cycle that moved into GitHub Actions. It reports a shorter release cycle and repeatable configuration. Its public description does not publish commit-level times. A team building on that pattern can measure change lead time by connecting version-control records to deployment events.
Consider a service with two commits, one at 09:00 and the other at 10:30. A build containing both is successfully deployed to production at 14:00. The elapsed values are five hours and three and a half hours. If the same build goes to staging at noon, the staging event helps explain the path, while the production event ends the interval. If the build fails earlier, keep that event for diagnosis. The measure ends when the change reaches the qualifying production state.
Start with records a human can verify. For a few deployments, retain the source revision range or manifest, artifact identifier, environment and completion time. Reconcile those records against the commit history. For a monorepo, record which service each deployment affected. Then add each measurement to a chart with its service and convention visible. Recheck a sample by hand after changing jobs, migrating tooling or introducing a new release strategy.
Where it goes wrong
Deployment records sometimes describe a job finishing rather than a service being available. A job can finish after submitting work to another system, before the new instances are healthy. Establish whether the end event is the accepted production deployment, verified replacement at a defined proportion of traffic or another deliberate convention. Make the convention consistent for the same service and keep transitions visible when it changes.
A report can miss the work that never reached production. An abandoned change has no production endpoint, and an active change can still be aging. Keep the count and current age of unreleased work separately so improved numbers cannot come only from leaving difficult changes out. Investigate missing links between artifacts and commits. Exclude unknown measurements explicitly, with a count, instead of treating them as zero.
A single average can hide long queues. Show a typical result, a slow-end percentile and the number of observations. For a small sample, review the actual timelines rather than reading a precise-looking percentile as a stable fact. If one long wait accounts for most of the change, inspect the stage responsible and test an improvement there. Follow the same service and the same measurement definition after the change.
Further reading
- DORA’s guide to software delivery performance metrics defines change lead time and its place among the delivery measures.
- DORA’s value stream mapping guide explains how to trace work and waiting through handoffs.
- Git documentation for commit formats distinguishes author and committer date fields available for source records.
- DORA’s deployment automation capability describes how to make deployment events repeatable.