DORA’s software delivery metrics have become the default vocabulary for talking about software delivery performance. That’s mostly a good thing: they are simple, they balance speed against stability, and they come out of years of research by the DevOps Research and Assessment program rather than a vendor’s marketing team.
But “we track DORA metrics” can mean anything from a carefully defined, automatically collected set of measures to a quarterly slide filled in by hand. The second kind is worse than useless — it creates the appearance of rigor while hiding what is really going on. This post is about getting the first kind.
The metrics, precisely
Each metric is easy to state and surprisingly easy to get subtly wrong. Before building any dashboard, write down what each one means for your organization and where the data comes from.
| Metric | What it measures | Typical data source |
|---|---|---|
| Change lead time | Time from a commit to that commit running in production | Commit timestamps joined to deployment events |
| Deployment frequency | How often a service is deployed to production | Deployment events from your CD tooling |
| Failed deployment recovery time | How long it takes to recover when a deployment fails | Incident or rollback start and end times |
| Change fail rate | Share of production deployments that need immediate intervention | Deployments linked to rollbacks, hotfixes or incidents |
| Deployment rework rate | Share of deployments that are unplanned, made because of a production incident | Deployment events tagged as incident fixes |
DORA’s research has refined the set over time. “Time to restore service” became failed deployment recovery time, and recent reports add a fifth measure, deployment rework rate. The metrics are now grouped into throughput (change lead time, deployment frequency, failed deployment recovery time) and instability (change fail rate, deployment rework rate). The intent has stayed the same: read them together.
Decide the definitions before the dashboards
Most arguments about delivery metrics are really arguments about definitions. Settle these early and write the answers down where everyone can find them:
- What is a deployment? A production release of one service? Does a configuration-only change count? What about a deployment that was rolled back after two minutes?
- When does lead time start? First commit on a branch, the pull request being opened, or the merge to the main branch? Each answer is defensible; mixing them across teams is not.
- What is a failure? A rollback, a hotfix, an incident above a certain severity — or all three? Make sure failures are linked to the deployment that caused them, not just counted.
- When is service restored? When the incident is resolved, or when the rollback completes? Pick one and apply it consistently.
There are no universally right answers here. There are only consistent and inconsistent ones.
Collect events, not opinions
Surveys are a useful way to benchmark against industry research, but they are a poor way to run a feedback loop. The data you need already exists in your tools — it just has to be captured as events and joined together.
The single most important link is between a deployment and the commits it contains. If every deployment event records the commit SHA it shipped, lead time and change fail rate become straightforward queries instead of manual detective work:
{
"service": "checkout-api",
"environment": "production",
"commit": "9f2c1e7",
"previousCommit": "4b81d0a",
"startedAt": "2026-10-14T09:12:03Z",
"finishedAt": "2026-10-14T09:18:47Z",
"status": "succeeded",
"trigger": "merge-to-main"
}
With commit and previousCommit, you can list every commit that went out in this deployment and compute its lead time. When an incident is later attributed to this deployment, the change fail rate and recovery time follow from the same record, and a trigger that marks incident fixes gives you the rework rate.
Read distributions, not averages
Delivery data is heavily skewed. One pull request that sat in review over a holiday can drag an average lead time up for weeks. Medians and percentiles describe the typical experience far better, and looking at the full distribution often reveals two populations — fast, small changes and slow, risky ones — that need different fixes.
Trends matter more than snapshots. A single week tells you very little; a quarter of weekly medians tells you whether things are getting better.
Keep speed and stability together
The metrics deliberately balance throughput against instability. Optimizing deployment frequency on its own is easy: deploy more often and stop caring what breaks. Optimizing change fail rate on its own is just as easy: deploy rarely and test forever. The research finding that matters is that high-performing teams tend to do well on both, because the practices that make delivery fast — small batches, automation, fast feedback — also make it safer.
If a dashboard shows only throughput or only instability, it will eventually be gamed.
Don’t rank teams with them
The fastest way to ruin a metric is to turn it into a target. Comparing teams with different architectures, risk profiles and customers on a single leaderboard invites exactly the behavior you don’t want: splitting deployments to inflate frequency, reclassifying incidents to protect a failure rate.
Use the metrics where they help most:
- in team retrospectives, to ask what slowed work down last month;
- in platform planning, to find the bottlenecks worth investing in;
- in leadership reviews, to show the direction of travel for the organization as a whole.
Break lead time apart
A single lead-time number says that work is slow, not why. Splitting it into stages usually points straight at the problem:
- Coding time — first commit to pull request opened.
- Pickup time — pull request opened to first review.
- Review time — first review to approval and merge.
- Deploy time — merge to running in production.
Long pickup times suggest review capacity or batch-size problems. Long deploy times point at the pipeline, release trains or manual approvals. Each calls for a very different fix.
A starting checklist
- Definitions for deployment, failure and restoration written down and shared.
- Every production deployment emits an event with the commit SHA it shipped.
- Incidents and rollbacks can be linked back to a deployment.
- Metrics reported as medians and trends, per service and per team.
- Throughput and instability always shown side by side.
- Metrics reviewed in retrospectives, never used for individual performance reviews.
Get these right and the dashboard almost builds itself. Skip them and no amount of charting will make the numbers trustworthy.
This is the problem Zentral Pulse is designed around: collecting delivery events directly from your tools and making every metric’s definition explicit. If you’d like to compare notes on measuring delivery in your organization, get in touch.