Skip to content

DORA Metrics: What Really Shortens Development Cycles

Lead time, deploy frequency, change fail rate, and recovery time are diagnostic values, not vanity velocity. They show where the cycle gets stuck – and why speed and stability don’t have to be opposites.

≈ 11 min readSoftwareDelivery

Deployment Frequency, Lead Time for Changes, Change Failure Rate, Failed Deployment Recovery Time: four measurements that nobody has to estimate and nobody has to vote on. They come out of systems that are running anyway – the commit timestamp in version control, the deploy event of the CD pipeline, the incident log. No board, no points, no self-reporting. In older DORA texts, the recovery metric was called “Time to Restore Service.”

Editorial note (July 2026): This post describes the model of four delivery metrics as it stood at the time. In 2024, DORA added the Deployment Rework Rate as a fifth metric. The current canon thus consists of three throughput and two instability metrics; the historical group of four in the main text remains as the starting point.

A velocity curve comes about the opposite way. It adds up story points that a team has assigned to itself, and it can point steeply upward while releases stay sluggish, hotfixes pile up, and nobody wants to deploy on Fridays. The four measurements above can’t do that. They describe the path of a change from commit to production – and what happens when that change causes damage.

These four DORA keys come from the DevOps Research and Assessment work around Nicole Forsgren, Jez Humble, and Gene Kim, are backed statistically in the book Accelerate (2018), and have been carried forward every year since in the State of DevOps Report. Their value lies in diagnosis: they show where in the chain things get stuck. What follows is about exactly where the keys make the bottleneck visible and how to collect them without turning them into a new numbers game.

You can first sort the measurements by the question they answer. That prevents speed and instability from merging into a seemingly clear-cut overall grade.

Delivery performance has two axes

  • Deployment Frequency · How often does a change reach production?
  • Lead Time for Changes · How long does the path from commit to deploy take?
  • Change Failure Rate · What share of changes causes an incident?
  • Failed Deployment Recovery Time · How long does recovery take after a failed deploy?
  • Deployment Rework Rate · What share creates unplanned rework?

This split isn’t a ranking. Only together do the two sides show whether a team can deliver quickly without hiding the cost of failed changes.

Two axes instead of one number#

The first reasoning error is treating delivery performance as a single quantity. The four keys deliberately span two axes.

On the throughput axis are Deployment Frequency – how often code goes to production – and Lead Time for Changes – how long it takes from commit to a successful deploy. That is the speed side: small batches, short paths.

On the stability axis are Change Failure Rate – what share of deploys triggers an incident or a rollback – and Failed Deployment Recovery Time – how long recovery takes after a failed deployment. That is the robustness side: how expensive a failure gets.

The central, counterintuitive finding from Accelerate: these two axes are not in opposition. The data shows that elite teams win on both at the same time – they deploy more often and fail less often and are back online faster. The old reflex “If we deliver faster, quality goes down” has been empirically refuted. That is exactly why it is negligent to measure only two of the four metrics. If you track only deploy frequency and lead time, you optimize for speed and ignore stability – and produce exactly the vanity illusion the DORA keys are meant to counter.

quadrantChart
  title Throughput vs. Stability
  x-axis Low Throughput --> High Throughput
  y-axis Low Stability --> High Stability
  quadrant-1 Elite
  quadrant-2 Slow but Safe
  quadrant-3 Low Performer
  quadrant-4 Fragile Speed
  Elite Team: [0.85, 0.85]
  Big-Batch Team: [0.2, 0.6]
  Move-Fast-Break-Things: [0.8, 0.25]
  Stuck Team: [0.2, 0.2]

The matrix makes it clear: the goal is the top right, not a compromise on the diagonal. And it explains why a single number is misleading – a team in the “Fragile Speed” quadrant looks brilliant on a pure speed metric and is still on fire.

Where the cycle gets stuck#

The real value of the keys lies not in the benchmark but in localization. Each metric is attached to a different segment of the value chain from commit to production – and thus shows where things get stuck.

flowchart LR
  A[Commit] --> B[CI Build]
  B --> C[Test]
  C --> D[Deploy Gate]
  D --> E[Production]
  E -->|Incident| F[Restore]
  F --> E
  A -. Lead Time for Changes .-> E
  D -. Deployment Frequency .-> E
  E -. Change Failure Rate .-> F
  F -. Failed Deployment Recovery Time .-> E
  style D fill:#e8543f,color:#fff

An example from practice: a team complains about “slow releases.” The median lead time is eleven days. If you break it down, nine of those days sit between “feature done” and “deploy gate” – the pipeline and the manual approval step are the bottleneck, not the programming. Another team has a good lead time but a change failure rate of 30 percent and a restore time of hours: here the problem isn’t speed but the reversibility of changes. The same four numbers, completely different treatment. An aggregated velocity would only have said “the team is at full capacity” in both cases.

Lead Time for Changes is my most important early indicator here. It is defined as the time from code commit to a successful run in production, and it correlates closely with batch size. Large batches lengthen feedback, increase the risk of failure, and turn every deployment into an event – Donald Reinertsen and Jez Humble have been insisting on this for years, and Accelerate backs it with data. A short lead time almost automatically forces small, continuous changes.

Change Failure Rate and recovery time are coupled#

A widespread misunderstanding is that stability means “no failures.” That isn’t what the DORA data says. The coupling of Change Failure Rate and Failed Deployment Recovery Time says something subtler: what counts is not the absence of failures but their price. High deploy frequency plus a low change failure rate plus a short recovery time means that changes are small and reversible. A failure that I roll back in minutes is cheap. A zero-defect standard that turns every release into a nail-biter is expensive – precisely because it forces rarely practiced, risky deploys.

That is why, in practice, a short restore time beats the demand for zero defects. And that is why the neighboring techniques belong right here: feature flags, to switch changes on or off without a deploy; canary and blue-green releases, to limit the blast radius; circuit breakers and bulkheads from Michael Nygard’s Release It!, to contain outages. Not buzzwords: these are exactly the levers that lower the change failure rate and shorten the restore time.

In code, the coupling of a reversible rollout and automatic recovery looks like this, for example:

// Canary rollout gated by the live error rate.
// Ties Change Failure Rate and recovery time together in one control loop.
interface RolloutConfig {
  canaryPercentage: number;
  maxErrorRate: number;      // e.g. 0.02 -> roll back above 2%
  observationWindowMs: number;
}

async function progressiveRollout(
  release: Release,
  config: RolloutConfig,
): Promise<RolloutResult> {
  await featureFlags.enableForCohort(release.id, config.canaryPercentage);

  const errorRate = await metrics.observeErrorRate(
    release.id,
    config.observationWindowMs,
  );

  if (errorRate > config.maxErrorRate) {
    await featureFlags.disable(release.id); // instant, no redeploy
    return { status: "rolled_back", observedErrorRate: errorRate };
  }

  await featureFlags.enableForCohort(release.id, 100);
  return { status: "promoted", observedErrorRate: errorRate };
}

It isn’t about the specific library; it is about the principle: recovery happens via a flag toggle in seconds, not via an emergency deploy. That is exactly what later shows up as a low restore time.

Measuring the metrics without inventing them#

For the keys to stay honest, they have to come from systems that nobody maintains by hand. Lead time, for example, can be derived entirely from two sources: the commit timestamp in version control and the deploy event of the CD pipeline. No estimate, no self-reporting.

// Lead Time for Changes, derived from VCS + deploy events.
// leadTime = deployedAt(prodDeployment) - firstCommitTime(changeSet)
function leadTimeForChange(deployment: ProdDeployment): number {
  const firstCommit = deployment.changeSet
    .map((commit) => commit.authoredAt.getTime())
    .reduce((min, t) => Math.min(min, t), Infinity);

  return deployment.deployedAt.getTime() - firstCommit;
}

// Aggregate as a median over a rolling window -- means get skewed by outliers.
function medianLeadTime(deployments: ProdDeployment[]): number {
  const values = deployments.map(leadTimeForChange).sort((a, b) => a - b);
  const mid = Math.floor(values.length / 2);
  return values.length % 2 === 0
    ? (values[mid - 1] + values[mid]) / 2
    : values[mid];
}

Two details matter. First, the median instead of the mean – a single branch that sat around for a while would ruin any average. Second, the rolling time window: the number is a trend, not a daily hit.

It gets even more effective when you don’t just display a metric but feed it back into the pipeline. In Building Evolutionary Architectures, Neal Ford, Rebecca Parsons, and Patrick Kua call this a fitness function – an executable rule that makes an architectural property verifiable. A DORA fitness function can turn the pipeline red when the change failure rate is above the threshold:

# Executable fitness function: assert a DORA metric as a CI gate.
def assert_change_failure_rate(window_days: int = 30, threshold: float = 0.15):
    deployments = metrics_db.query_deployments(window_days)
    failed = [d for d in deployments if d.caused_incident or d.rolled_back]

    if not deployments:
        return  # nothing to assert yet

    change_failure_rate = len(failed) / len(deployments)
    assert change_failure_rate < threshold, (
        f"Change Failure Rate {change_failure_rate:.0%} "
        f"exceeds threshold {threshold:.0%} over {window_days}d"
    )

This is how DORA connects with the idea of evolutionary architecture: the metric is no longer a slide for the quarterly meeting but a condition that the system places on itself.

The pitfall: metrics as targets#

That brings us to the biggest danger. As soon as a metric becomes a target, it ceases to be a good measure – Goodhart’s Law in its purest form. Deployment Frequency can be inflated with trivial empty deploys. Change Failure Rate can be prettied up by redefining “failure” until hardly anything falls into it anymore. If you use the keys as a team ranking or a bonus KPI, you get exactly this gaming – and DORA itself explicitly warns against using them to compare teams. The four numbers are diagnosis, not competition.

I often see two other mix-ups. First: the keys are not a replacement for story point velocity in the sense of “same thing, better numbers.” It is a different construct – velocity measures the output of a single team and is neither comparable nor tamper-proof; the keys measure the flow from commit to production across the entire delivery system. Second: fast deploys without impact are “faster to nowhere.” That is why DORA added a fifth dimension in the 2021 and 2022 reports, reliability, or operational performance. The statement from 2022: high delivery performance only pays off for organizational success if reliability in operations is right as well. I deliberately treat reliability as a younger, softer addition – not as a fifth, equal-ranking part of the canon. But the idea belongs in the “honest instead of vanity” framing: speed without operational stability is a vanity metric with better marketing.

Conclusion#

The common thread is simple. Velocity measures what a team claims about itself. The four DORA keys measure what actually happens – from commit to production and back when things break. They do this on two axes, speed and stability, and the core message of Accelerate is that these axes are not a tradeoff: the good teams win on both.

In practice, I use the keys as a searchlight. A long lead time points to large batches or a clogged pipeline. A high change failure rate points to missing reversibility. A long restore time shows that recovery isn’t practiced. Every number points to a concrete, technical countermeasure – small batches, Trunk-Based Development, feature flags, canary releases, circuit breakers. That is the difference between a metric that shortens the cycle and one that just fills a dashboard.

And the discipline in all this: the keys diagnose; they don’t reward. The moment they become a target, they lose their value. If you can stand that – looking at numbers without chasing them – you get something rare: an honest view of where your own cycle really gets stuck.

Further reading#

Revised and translated from German with the help of AI.