Skip to content

DORA Metrics Explained: What They Measure and What They Miss

DORA metrics are the best starting point for engineering performance. But they miss developer experience, quality depth, and value delivery.

8 min read
Inspection tools surround a teal component while frosted glass obscures part of the larger assembly.
On this page

DORA metrics have become the default language for engineering performance. Every VP of Engineering I talk to mentions them within the first five minutes. Tooling vendors plaster them across landing pages. Conference talks treat them as gospel.

And they're genuinely useful. But they're also incomplete in ways that can hurt you if you don't understand the gaps.

I've implemented DORA tracking at three different companies. Each time, I learned something new about where these metrics shine and where they quietly mislead.

The Five Current Metrics

DORA's current model uses five software delivery performance metrics. Earlier versions used four, so check the definitions and report year behind an existing dashboard.[1]

1. Deployment Frequency How often changes are deployed to production. Use a consistent application or service boundary when comparing the measure over time.

2. Change Lead Time The elapsed time from a code commit to that change being deployed in production. Work before the commit belongs in a wider feature cycle-time view.

3. Change Fail Rate The share of deployments requiring immediate intervention, such as a rollback or hotfix, after a production change causes a problem.

4. Failed Deployment Recovery Time The time taken to recover from a failed deployment that needs immediate intervention. This replaces the older, broader MTTR terminology for the delivery-performance measure.[2]

5. Deployment Rework Rate The share of deployments that were unplanned and needed because of a production incident. This adds a direct view of reactive deployment work.

Use current, dated benchmarks when an external comparison is useful. Track your own trend in the context of the application rather than treating historical performance bands as permanent targets.

Five delivery measures, two related views Throughput Frequency and lead time Deployment recovery Instability Change fail rate Deployment rework Application context Read the measures together over time Delivery performance is one part of engineering performance.
Figure 1. Use the five current definitions when reading a delivery dashboard.

What DORA Gets Right

DORA metrics work because of three design decisions:

They measure outcomes, not outputs. DORA doesn't count lines of code or story points. It measures how effectively the system delivers value. This is a critical distinction. A team can write thousands of lines of code and still have terrible DORA numbers if their pipeline is broken.

They measure the delivery system. DORA recommends applying the metrics to one application or service at a time. Investigate structural problems such as flaky tests, slow CI, manual deployment gates and inadequate monitoring. Targets can still encourage gaming, so use the measures to guide improvement.

They balance speed with stability. Deployment frequency, change lead time and failed deployment recovery time describe throughput. Change fail rate and deployment rework rate describe instability. You can't optimize one at the expense of the other and still look good. A team that deploys 50 times a day but breaks production every third deployment has terrible DORA metrics. So does a team that ships once a quarter with zero failures. The framework rewards teams that are both fast and stable.

What DORA Misses

Here's where my experience diverges from the conference talks. DORA has real blind spots, and ignoring them will lead you astray.

1. Developer Experience Is Invisible

DORA metrics can look great while developers are miserable. I've seen this firsthand. A team had elite deployment frequency and solid lead times. Their DORA dashboard was green across the board. But developer satisfaction was in the gutter.

Why? The pipeline was fast because developers had automated everything. But the automation was fragile, poorly documented, and understood by exactly two people. Everyone else lived in fear of the deploy scripts. The "fast lead time" was achieved by skipping code review for "small" changes, which meant bugs crept in that didn't show up as incidents but degraded the user experience.

DORA told us everything was fine. Talking to the team told a different story.

2. Quality Is Underrepresented

Change fail rate and deployment rework rate describe deployment-related instability. They do not provide a complete assessment of software quality. A wider quality review should also examine:

  • Performance regressions that don't trigger alerts
  • Accessibility violations
  • UX degradation that users tolerate but hate
  • Technical debt accumulation
  • Security vulnerabilities that haven't been exploited yet

You can have a 0% change failure rate and still ship garbage. As long as it doesn't break, DORA won't flag it.

3. Value Delivery Is Absent

DORA tells you how fast you can deliver code. It says nothing about whether that code was worth building. A team can have elite DORA metrics while building features nobody uses. Speed of delivery is necessary but not sufficient. If you're efficiently building the wrong things, you're efficiently wasting money.

4. Cross-Team Dependencies Are Hidden

DORA metrics are typically measured per team. But in any organization of meaningful size, the biggest productivity killers are between teams, not within them. Waiting for another team's API. Coordinating a cross-service migration. Negotiating shared infrastructure changes.

I've watched individual team DORA metrics stay green while organization-wide delivery slowed to a crawl because cross-team coordination was a mess.

5. Cognitive Load Isn't Captured

A team can have fast deployment pipelines and still be slow because every change requires understanding six microservices, three databases, and a message queue. DORA measures the pipeline. It doesn't measure how hard it is to figure out what code to write in the first place.[3]

The Stealable Framework: DORA+3

Here's what I recommend: use DORA as your foundation, then add three supplementary signals. I call this DORA+3.[4]

Five DORA delivery metrics: Deployment Frequency, Change Lead Time, Failed Deployment Recovery Time, Change Fail Rate and Deployment Rework Rate. Track these as delivery-system indicators.

+1: Developer Experience Score Run a quarterly survey. Ask developers to rate (1-5 scale) their satisfaction with: build tools, CI/CD, code review process, documentation, on-call experience, and overall ability to focus. Track the trend. If it's declining while DORA looks good, you have a hidden problem.

+2: Time-to-10th-PR for New Hires How long does it take a new developer to submit their 10th pull request? This single metric captures onboarding quality, documentation, codebase complexity, and team support. I've seen this range from two weeks (great) to three months (terrible). It's a surprisingly sensitive indicator of overall developer experience.

+3: Feature Cycle Time Track the time from "feature kickoff" (product and engineering agree to build something) to "feature in users' hands." This captures all the non-coding time that DORA ignores: design, planning, cross-team coordination, QA, and rollout. If your DORA lead time is one hour but your feature cycle time is three months, the bottleneck isn't your pipeline.

Add context around delivery performance Developer feedback Tools, review and focus Onboarding Time to contribution and support Feature cycle time Planning through release to users The article proposes these supplementary signals around the DORA measures.
Figure 2. Supplement delivery measures with evidence about the surrounding work.

The Bottom Line

DORA metrics are the best starting point we have for measuring engineering performance. Use them. But don't stop there.

The teams I've seen get the most value from DORA are the ones that treat the five delivery metrics as part of a wider view of engineering performance. They combine DORA with direct developer feedback, quality indicators, and business-level cycle times to get the full picture.

The teams that struggle are the ones that optimize for DORA scores. They hit elite benchmarks on the dashboard while their developers are burned out, their codebase is rotting, and their customers are waiting months for simple requests.

Measure the system. But remember that the system includes the humans operating it.

Frequently asked questions

How many DORA metrics are there now?

Current DORA guidance lists five software delivery performance metrics. Deployment rework rate joins the earlier measures, and failed deployment recovery time narrows recovery measurement to failures caused by a production change.

Is failed deployment recovery time the same as MTTR?

Failed deployment recovery time concerns recovery after a deployment causes an impairment and needs intervention. A general incident recovery average can also include outages with other causes, so check the definition behind an existing dashboard.

Can DORA metrics measure an individual developer?

DORA recommends measuring an application or service in its delivery context. Use the measures to discuss the delivery system and shared constraints. Individual activity and contribution require different evidence and should not be inferred from deployment counts.

What should I add to a DORA dashboard?

The post proposes developer feedback, onboarding progress and feature cycle time as supplementary signals. These help investigate tooling friction and delays before a commit. Choose the added measures according to the question your team needs to answer.

Sources

  1. [1]DORA’s software delivery performance metrics · DORA
  2. [2]A history of DORA’s software delivery metrics · DORA
  3. [3]DevEx: What actually drives productivity · DX, Abi Noda and research co-authors
  4. [4]The SPACE of Developer Productivity: There’s more to it than you think · Microsoft Research

Checked against these sources on

Related Articles