Introduction
For decades, software teams struggled with a fundamental question: How do we know if we're doing well? Lines of code? Story points completed? Number of deploys? These metrics either incentivised wrong behaviour or measured activity rather than outcomes.
DORA (DevOps Research and Assessment) studies how software delivery capabilities relate to organisational outcomes. Its current framework uses five metrics: three throughput measures and two instability measures. The set has evolved over time; the DORA metrics history explains those changes.
Use these measures to understand a service's delivery performance over time and guide improvement. They are not a score for comparing teams with different products, risk profiles, or operating contexts.
The Accelerate Research
The findings were published in Accelerate: The Science of Lean Software and DevOps (2018) and the annual State of DevOps Reports (2014–present, now published by Google Cloud DORA team). Key findings include:
- Elite performers deploy 973x more frequently than low performers
- Lead time for elite teams is 6,570x shorter than low performers
- Change failure rate is 3x lower for elite performers
- Recovery time is 6,570x faster for elite performers
- High-performing teams are 2x more likely to exceed organisational goals
- These capabilities predict commercial outcomes, not just technical ones
The research methodology uses cluster analysis to identify natural performance groups, structural equation modelling to establish causation, and survey-based measurement validated against objective data. It's the most rigorous empirical research in software engineering.
The Five Key Metrics
DORA groups delivery performance into throughput (how efficiently value moves to users) and instability (how often delivery creates unplanned work or disruption). The current framework has three throughput metrics—deployment frequency, change lead time, and failed deployment recovery time—and two instability metrics—change fail rate and deployment rework rate.
flowchart LR
subgraph T[Throughput]
A[Deployment frequency]
B[Change lead time]
C[Failed deployment recovery time]
end
subgraph I[Instability]
D[Change fail rate]
E[Deployment rework rate]
end
Deployment Frequency (DF)
Definition: How often your organisation deploys code to production (or releases it to end users).
Deployment frequency is the clearest indicator of batch size. High deployment frequency means small batches, which means lower risk per change, faster feedback, and easier debugging when something goes wrong. If you deploy 100 lines of code and something breaks, you know exactly where to look. If you deploy 10,000 lines, good luck.
The performance bands shown below are historical report snapshots, not universal targets. DORA's framework and research distributions evolve; compare a service with its own trend and check the current DORA guide for context.
| Performance Tier | Deployment Frequency | Batch Size Implication |
|---|---|---|
| Elite | Multiple times per day (on demand) | Individual commits, feature flags |
| High | Once per day to once per week | Small feature branches, few days work |
| Medium | Once per week to once per month | Sprint-sized releases |
| Low | Once per month to once per six months | Large batches, release trains |
Lead Time for Changes (LT)
Definition: The time from when code is committed to when it is running in production and available to users.
Lead time measures the efficiency of your entire delivery pipeline — from the moment a developer finishes writing code to the moment it creates value for users. It encompasses code review, CI pipeline execution, approval gates, staging environments, and deployment processes.
| Performance Tier | Lead Time | Where Time is Spent |
|---|---|---|
| Elite | Less than 1 hour | Automated pipeline, trunk-based dev |
| High | 1 day to 1 week | Code review + automated deploy |
| Medium | 1 week to 1 month | Manual testing, approval committees |
| Low | 1 month to 6 months | Change advisory boards, manual deployments |
Change Fail Rate (CFR)
Definition: The percentage of deployments that cause a failure in production — requiring a rollback, hotfix, patch, or incident response.
Change failure rate measures the quality of your delivery process. A low CFR means your testing, review, and deployment practices catch problems before they reach users. It doesn't mean you never fail — it means you fail infrequently and predictably.
| Performance Tier | Change Failure Rate | What This Means |
|---|---|---|
| Elite | 0–15% | Extensive automated testing, canary deployments |
| High | 16–30% | Good test coverage, some gaps in integration |
| Medium | 16–30% | Variable testing, reactive quality practices |
| Low | 46–60% | Insufficient testing, large batches mask root causes |
Deployment Rework Rate (DRR)
Definition: The percentage of deployments that are unplanned work caused by a production incident. Unlike change fail rate, which measures how often deployments cause a failure, rework rate captures follow-up deployments made to address production incidents.
Failed Deployment Recovery Time (FDRT)
Definition: The time needed to recover from a deployment that causes a failure and requires immediate intervention. Measure from the failed deployment to restoration of service. This is narrower than generic incident MTTR: unrelated outages and incidents not caused by a deployment do not belong in this DORA metric.
Recovery time is one of DORA's throughput measures because fast recovery lets teams deliver changes in small batches without accepting prolonged disruption. Track the median for deployment-caused failures and report the period and service scope.
Interpreting the Metrics
Published performance bands are snapshots from particular DORA research reports, not universal targets. Use them as historical context only; definitions and distributions evolve. Compare a service with its own trend and interpret results in context, rather than ranking unlike teams.
| Metric | What to examine over time |
|---|---|
| Deployment frequency | Whether the service can release changes in small batches at a sustainable cadence. |
| Change lead time | Where work waits between commit and production, and whether those delays are shrinking. |
| Failed deployment recovery time | How quickly service is restored when a deployment fails and needs immediate intervention. |
| Change fail rate | How often deployments cause production failures requiring intervention. |
| Deployment rework rate | How much deployment work is unplanned follow-up responding to production incidents. |
Historical research context
Older State of DevOps reports grouped survey respondents into performance categories to summarize patterns in their samples. Those categories describe research findings from specific periods; they are not permanent grades or quotas for individual teams. Consult current DORA research for recent findings, and use the measures to guide local improvement rather than rank teams with different contexts.
Measuring DORA Metrics
Measurement must be automated and objective. Self-reported metrics are unreliable due to cognitive biases. Pull data from your systems:
flowchart LR
A[Git Repository] -->|Commit timestamps| E[Metrics Engine]
B[CI/CD Platform] -->|Build/Deploy events| E
C[Incident Manager] -->|Incident open/close| E
D[Monitoring/Alerting] -->|Detection time| E
E --> F[Dashboard]
E --> G[Trend Analysis]
E --> H[Team Comparisons]
style E fill:#3B9797,color:#fff
style F fill:#f8f9fa,stroke:#333
Data Sources by Metric
| Metric | Data Source | Calculation |
|---|---|---|
| DF | CI/CD deployment events | Count of successful production deploys / time period |
| LT | Git + CI/CD timestamps | Median(deploy_time - first_commit_time) per change |
| Change fail rate | Incident tracker + deploy logs | Failed deploys / total deploys × 100% |
| Deployment rework rate | Incident tracker + deploy logs | Incident-driven unplanned deployments / all deployments × 100% |
| Failed deployment recovery time | Deployment events + incident tracker | Median(service restoration time − failed deployment time) for deployment-caused failures requiring intervention |
Tools & Dashboards
import datetime
import statistics
def calculate_dora_metrics(deploys, incidents, period_days=30):
"""
Calculate DORA metrics from deployment and incident data.
Args:
deploys: List of dicts with timestamps, 'caused_incident',
and 'unplanned_for_production_incident'
incidents: List of deployment-caused failures with
'failure_deployed_at' and 'restored_at'
period_days: Measurement period in days
"""
# 1. Deployment Frequency
deployment_frequency = len(deploys) / period_days
# 2. Lead Time for Changes (median)
lead_times = []
for deploy in deploys:
lt = (deploy['timestamp'] - deploy['commit_time']).total_seconds() / 3600
lead_times.append(lt) # in hours
median_lead_time = statistics.median(lead_times) if lead_times else 0
# 3. Change Fail Rate: deployments that caused a production failure
failed_deploys = sum(1 for d in deploys if d['caused_incident'])
change_failure_rate = (failed_deploys / len(deploys) * 100) if deploys else 0
# 4. Deployment Rework Rate: unplanned deployments responding to incidents
rework_deploys = sum(1 for d in deploys if d['unplanned_for_production_incident'])
deployment_rework_rate = (rework_deploys / len(deploys) * 100) if deploys else 0
# 5. Failed Deployment Recovery Time (median)
recovery_times = []
for incident in incidents:
rt = (incident['restored_at'] - incident['failure_deployed_at']).total_seconds() / 3600
recovery_times.append(rt) # in hours
median_recovery = statistics.median(recovery_times) if recovery_times else 0
return {
'deployment_frequency_per_day': round(deployment_frequency, 2),
'change_lead_time_median_hours': round(median_lead_time, 1),
'change_fail_rate_percent': round(change_failure_rate, 1),
'deployment_rework_rate_percent': round(deployment_rework_rate, 1),
'failed_deployment_recovery_median_hours': round(median_recovery, 1),
}
# Example usage with sample data
deploys = [
{'timestamp': datetime.datetime(2026, 5, 13, 14, 0),
'commit_time': datetime.datetime(2026, 5, 13, 12, 30),
'caused_incident': False, 'unplanned_for_production_incident': False},
{'timestamp': datetime.datetime(2026, 5, 13, 16, 0),
'commit_time': datetime.datetime(2026, 5, 13, 14, 45),
'caused_incident': False, 'unplanned_for_production_incident': False},
{'timestamp': datetime.datetime(2026, 5, 12, 10, 0),
'commit_time': datetime.datetime(2026, 5, 12, 8, 0),
'caused_incident': True, 'unplanned_for_production_incident': True},
]
incidents = [
{'failure_deployed_at': datetime.datetime(2026, 5, 12, 10, 0),
'restored_at': datetime.datetime(2026, 5, 12, 10, 35)},
]
metrics = calculate_dora_metrics(deploys, incidents, period_days=7)
for name, data in metrics.items():
print(f"{name}: {data}")
Purpose-built DORA measurement tools include:
- Four Keys (Google) — Open-source DORA dashboard using BigQuery and Cloud Build events
- LinearB — Git analytics platform with built-in DORA tracking
- Sleuth — Deployment tracking focused specifically on DORA metrics
- Jellyfish — Engineering management platform with DORA and business alignment
- Faros AI — Open-source connector that aggregates data from 50+ tools
- Backstage + plugins — Internal developer portal with DORA metric widgets
Beyond DORA
DORA's current delivery framework contains five metrics. Teams often pair them with reliability and developer-experience measures to understand outcomes that delivery metrics alone cannot capture.
Reliability as a complementary measure
Reliability (for example, SLO attainment) is valuable operational context, but it is not the fifth DORA delivery metric. DORA's fifth measure is deployment rework rate. Pairing delivery metrics with SLOs helps teams see whether delivery improvements preserve user-facing reliability.
The SPACE Framework
Published by Forsgren, Storey, Maddila, Zimmermann, and others at Microsoft Research (2021), SPACE measures developer productivity across five dimensions:
| Dimension | What It Measures | Example Metrics |
|---|---|---|
| Satisfaction | Developer happiness and fulfilment | Survey scores, eNPS, retention |
| Performance | Outcomes and quality of work | Customer impact, reliability, code quality |
| Activity | Volume of actions (use carefully) | PRs merged, deployments, code reviews completed |
| Communication | Collaboration and knowledge flow | PR review time, documentation, onboarding speed |
| Efficiency | Minimal friction and interruptions | Flow state time, context switches, wait time |
Flow Metrics
Flow metrics (from Mik Kersten's Project to Product) measure value stream efficiency:
- Flow Time — Total time from work item creation to delivery (includes wait time)
- Flow Efficiency — Active work time / total flow time × 100% (typically 15–40%)
- Flow Load — Work items in progress (correlates with lead time via Little's Law)
- Flow Velocity — Number of items completed per time period
- Flow Distribution — Ratio of features vs defects vs debt vs risk work
Improving Each Metric
Improving Deployment Frequency
The path from monthly to daily (or multiple daily) deployments requires changes across code, process, and culture:
- Trunk-based development — Short-lived branches (hours, not weeks). Merge to main daily
- Feature flags — Decouple deployment from release. Deploy dark features that can be enabled independently
- Automated deployments — Every merge to main triggers production deployment (with gates)
- Smaller batches — Break large features into independently deployable increments
- Decouple services — Independent deployability means one team's changes don't block another's
# GitOps: Automated deployment on merge to main
# ArgoCD Application watching main branch
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: payment-service
namespace: argocd
spec:
project: default
source:
repoURL: https://github.com/my-org/payment-service
targetRevision: main
path: k8s/overlays/production
destination:
server: https://kubernetes.default.svc
namespace: payments
syncPolicy:
automated:
prune: true
selfHeal: true
syncOptions:
- CreateNamespace=true
- PrunePropagationPolicy=foreground
Improving Lead Time
Lead time is the sum of all wait times and processing times in your pipeline. To reduce it, identify and eliminate bottlenecks:
import datetime
# Lead time breakdown analysis
def analyse_lead_time(change):
"""Break down where time is spent in the delivery pipeline."""
stages = {
'coding': change['pr_opened'] - change['first_commit'],
'review_wait': change['first_review'] - change['pr_opened'],
'review_cycles': change['approved'] - change['first_review'],
'ci_pipeline': change['ci_complete'] - change['approved'],
'deploy_wait': change['deploy_start'] - change['ci_complete'],
'deployment': change['deploy_complete'] - change['deploy_start'],
}
total = sum(stages.values(), datetime.timedelta())
print(f"Total Lead Time: {total}")
print(f"\nBreakdown:")
for stage, duration in stages.items():
pct = duration / total * 100
bar = '█' * int(pct / 2)
print(f" {stage:20s}: {str(duration):>15s} ({pct:.0f}%) {bar}")
# Identify biggest bottleneck
bottleneck = max(stages, key=stages.get)
print(f"\nBottleneck: {bottleneck} ({stages[bottleneck]})")
return stages
# Example: typical team before optimisation
sample_change = {
'first_commit': datetime.datetime(2026, 5, 10, 9, 0),
'pr_opened': datetime.datetime(2026, 5, 10, 11, 0),
'first_review': datetime.datetime(2026, 5, 11, 14, 0), # Next day!
'approved': datetime.datetime(2026, 5, 12, 10, 0),
'ci_complete': datetime.datetime(2026, 5, 12, 10, 45),
'deploy_start': datetime.datetime(2026, 5, 13, 9, 0), # Next deploy window
'deploy_complete': datetime.datetime(2026, 5, 13, 9, 15),
}
analyse_lead_time(sample_change)
Common lead time improvements:
- Reduce review wait time — Set team SLAs for PR review (e.g., first review within 4 hours)
- Parallelise CI — Run tests concurrently; aim for sub-10-minute pipelines
- Eliminate manual gates — Replace change advisory boards with automated policy checks
- Deploy continuously — Remove "deploy windows"; deploy any time CI passes
Improving Change Fail Rate
- Comprehensive automated testing — Unit, integration, contract, and end-to-end tests in CI
- Canary deployments — Route 1–5% of traffic to new version; monitor before full rollout
- Progressive delivery — Ring-based deployments, starting with internal users
- Feature flags with kill switches — Instant disable without redeployment
- Smaller batch sizes — Fewer changes per deployment = fewer failure modes
Improving Deployment Rework Rate
- Link incidents to deployments — Record which changes triggered incidents and which follow-up releases were unplanned remediation.
- Reduce recurring causes — Use blameless reviews to address repeat failure modes in tests, rollout controls, configuration, and dependencies.
- Keep the measure distinct from change fail rate — Track incident-causing deployments and incident-response deployments separately to avoid double-counting concepts.
- Review by service and over time — Investigate changes in the service's own baseline instead of setting a quota that discourages reporting or remediation.
Improving Failed Deployment Recovery Time
- Observability — Distributed tracing, structured logging, real-time dashboards
- Automated rollback — One-click (or zero-click) revert to last known good state
- Runbooks — Pre-written incident response procedures for known failure modes
- Incident response automation — PagerDuty/Opsgenie escalation, auto-creation of war rooms
- Chaos engineering — Practice recovery regularly so it's muscle memory during real incidents
# Argo Rollouts: Automated canary with auto-rollback
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
name: payment-api
spec:
replicas: 10
strategy:
canary:
steps:
- setWeight: 5 # 5% traffic to canary
- pause: {duration: 5m}
- analysis:
templates:
- templateName: success-rate
args:
- name: service-name
value: payment-api
- setWeight: 25 # 25% if analysis passes
- pause: {duration: 10m}
- analysis:
templates:
- templateName: latency-check
- setWeight: 50
- pause: {duration: 10m}
- setWeight: 100 # Full rollout
# Auto-rollback if any analysis fails
rollbackWindow:
revisions: 2
---
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
name: success-rate
spec:
metrics:
- name: success-rate
interval: 60s
successCondition: result[0] >= 0.99
provider:
prometheus:
address: http://prometheus:9090
query: |
sum(rate(http_requests_total{service="{{args.service-name}}",status=~"2.."}[5m]))
/
sum(rate(http_requests_total{service="{{args.service-name}}"}[5m]))
Anti-Patterns in Metrics
Metrics are powerful — but they can be weaponised. Goodhart's Law states: "When a measure becomes a target, it ceases to be a good measure." Here's how teams game DORA metrics and why it's destructive:
| Anti-Pattern | What It Looks Like | Why It's Harmful |
|---|---|---|
| Empty Deploys | Deploying trivial changes to inflate DF | Measures activity, not value delivery |
| Skipping Reviews | Auto-merging to reduce lead time | Trades quality for speed numbers |
| Hiding Incidents | Not reporting failures to keep CFR low | Destroys learning and trust |
| Premature Closure | Closing incidents before full resolution | Artificially lowers reported recovery time while problems recur |
| Individual Rankings | Using metrics to compare/rank developers | Kills collaboration, incentivises gaming |
| Target Fixation | Setting rigid targets ("deploy 10x/day or else") | Context-free targets drive wrong behaviour |
Case Studies
Etsy: From Monthly Releases to 50+ Deploys Per Day
In 2009, Etsy deployed once every two weeks with a dedicated "deploy day" that took 4+ hours and frequently caused outages. By 2014, they averaged 50+ deploys per day with a change failure rate below 5%. How?
Key changes: (1) Eliminated the release branch — all developers committed to trunk. (2) Built "Deployinator" — a one-click deploy tool any engineer could use. (3) Adopted feature flags for everything — deploy code dark, enable separately. (4) Invested heavily in monitoring — every deploy correlated with real-time metrics dashboards. (5) Made deploy responsibility distributed — the person who wrote the code deploys it.
Result: Deployment time dropped from 4 hours to 15 minutes. Incident rate dropped 80%. Engineer satisfaction improved dramatically because "deploy fear" disappeared. Revenue grew 40% YoY during the transformation period.
Capital One: DORA-Driven Transformation in Financial Services
Capital One faced a common financial services challenge: heavy regulation demanding stability, but business requirements demanding speed. They adopted DORA metrics as their transformation compass.
Approach: (1) Baseline measurement across 300+ engineering teams. (2) Identified that 80% of lead time was wait time (approvals, manual testing, deploy windows). (3) Replaced manual change advisory boards with automated policy-as-code. (4) Invested in test automation to replace manual QA gates. (5) Moved to immutable infrastructure and blue-green deployments for safe rollbacks.
Result over 3 years: Deployment frequency improved from monthly to daily for most teams. Lead time dropped from 2 weeks to under 1 day. Service recovery time improved from days to under 2 hours. All while maintaining regulatory compliance and passing SOC2 audits with automated evidence collection.
Building a Metrics Program
Implementing DORA metrics isn't a one-day project. It's a cultural shift that requires careful introduction:
Phase 1: Baseline (Weeks 1–4)
- Identify data sources (CI/CD platform, incident tracker, source control)
- Instrument measurement collection (automated, not manual)
- Calculate current state for all five metrics
- Share results transparently with the team (no blame, just facts)
Phase 2: Understand (Weeks 5–8)
- Discuss what the numbers mean with the team
- Identify the biggest constraint (often lead time, deployment rework, or failed-deployment recovery)
- Map the value stream to find where time is lost
- Generate improvement hypotheses collaboratively
Phase 3: Improve (Ongoing)
- Pick one metric to improve first (the biggest constraint)
- Run time-boxed experiments (2–4 weeks)
- Measure the impact of each change
- Celebrate improvements publicly
- Iterate — once one metric improves, address the next constraint
{
"metrics_program": {
"team": "payments-squad",
"baseline_date": "2026-04-01",
"baseline": {
"deployment_frequency": "2 per week",
"lead_time_hours": 72,
"change_fail_rate_pct": 22,
"deployment_rework_rate_pct": 8,
"failed_deployment_recovery_time_hours": 0.75
},
"current_tier": "High",
"target_tier": "Elite",
"focus_metric": "lead_time",
"improvement_hypothesis": "Reducing PR review wait time from 18h to 4h will cut lead time by 40%",
"experiment": {
"intervention": "Implement async code review SLA: first review within 4 hours",
"start_date": "2026-05-13",
"duration_weeks": 4,
"success_criteria": "Median lead time drops below 24 hours"
},
"review_cadence": "Bi-weekly metrics retro"
}
}
Exercises
Over 30 days, a team made 45 production deployments, had a median commit-to-production time of 6.5 hours, 4 deployments caused production failures, and 3 deployments were unplanned incident response. Recovery from the four failed deployments took 25 minutes, 40 minutes, 2 hours, and 45 minutes. Calculate all five metrics and explain why a single overall team ranking would be misleading.
A team has the following lead time breakdown: Coding (2h), PR wait (22h), Review (3h), CI pipeline (45min), Deploy approval (8h), Deployment (10min). Total: ~36 hours. (1) Identify the two biggest bottlenecks. (2) Propose specific interventions for each. (3) Estimate the new lead time if your interventions succeed. (4) What tier would the team move to?
Your team deploys weekly, has a two-week median change lead time, a 25% change fail rate, a 10% deployment rework rate, and an 18-hour median failed-deployment recovery time. Design a 12-week improvement plan. For each measure, set a context-specific goal, list technical or process changes, identify dependencies and risks, and define how progress will be reviewed without using the measures to rank unrelated teams.
Choose your team's actual CI/CD system (GitHub Actions, GitLab CI, Jenkins, etc.) and design a measurement pipeline that automatically calculates DORA metrics. Document: (1) Which events/webhooks provide the data, (2) How you'll store historical data, (3) How you'll visualise trends (tool choice + dashboard mockup), (4) How you'll handle edge cases (reverts, hotfixes, maintenance deploys).
Conclusion & Next Steps
DORA metrics give you an evidence-based compass for software delivery improvement. They tell you where you are, where you can go, and — when measured over time — whether your investments in tooling, process, and culture are actually working.
The key lessons: speed and stability are not tradeoffs — they reinforce each other. Smaller batches reduce risk rather than increasing it. Metrics are for learning, not punishment. And the gap between elite and low performers is growing — the time to invest in delivery performance is now.
Remember: you can't improve what you don't measure, but you can destroy what you measure badly. Use DORA metrics with wisdom — as a mirror for self-reflection, not a weapon for judgement.
Next in the Series
In Part 26: Reliability & Observability, we'll build on delivery recovery practices by learning to instrument systems for deep observability — distributed tracing, SLOs, error budgets, and reliable incident response.