Back to Software Engineering & Delivery Mastery Series

Part 25: DORA Metrics & Delivery Performance

May 13, 2026 Updated November 1, 2026 Wasil Zafar 44 min read

"What gets measured gets managed." DORA's current framework tracks five software delivery metrics across throughput and instability. This article explains how to measure, interpret, and improve them. See the current DORA metrics guide for definitions and context.

Table of Contents

  1. Introduction
  2. The Five Key Metrics
  3. Interpreting the Metrics
  4. Measuring DORA Metrics
  5. Beyond DORA
  6. Improving Each Metric
  7. Anti-Patterns in Metrics
  8. Case Studies
  9. Building a Metrics Program
  10. Exercises
  11. Conclusion & Next Steps

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.

Key Insight: The DORA research destroyed the myth that speed and stability are tradeoffs. Elite performers are simultaneously faster (multiple deploys per day) and more stable (lower failure rates, faster recovery). Speed and stability reinforce each other when the right practices are in place.

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.

DORA Metrics: Throughput vs Stability
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
The Batch Size Paradox: Intuition says "deploy less often to reduce risk." The data proves the opposite. Deploying more frequently with smaller changes reduces risk because: (1) each change is simple enough to understand, (2) failures are isolated to a known change, (3) rollbacks are trivial, and (4) the feedback loop is tight enough to catch problems early.

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.

Calculation: unplanned deployments made in response to production incidents ÷ all deployments in the period × 100%. Agree on what counts as incident-driven rework and apply the same rule consistently.

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.

Recovery time vs. MTBF: Mean time between failures (MTBF) describes the interval between failures; it is not a current DORA delivery metric. DORA's recovery measure focuses specifically on restoring service after a failed deployment that requires intervention.

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.

MetricWhat to examine over time
Deployment frequencyWhether the service can release changes in small batches at a sustainable cadence.
Change lead timeWhere work waits between commit and production, and whether those delays are shrinking.
Failed deployment recovery timeHow quickly service is restored when a deployment fails and needs immediate intervention.
Change fail rateHow often deployments cause production failures requiring intervention.
Deployment rework rateHow 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:

DORA Metrics Measurement Pipeline
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
Critical Warning: DORA metrics are team-level and system-level metrics. They should never be used to evaluate individual developers. The moment you tie metrics to performance reviews, you incentivise gaming. Use metrics for learning and improvement, not judgement and punishment.

Case Studies

Case Study

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.

Trunk-Based Dev Feature Flags Continuous Deployment
Case Study

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.

Financial Services Policy as Code Automated Compliance

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"
  }
}
Best Practice: Start with team-owned dashboards, not management reports. When teams own their metrics and use them for self-improvement, adoption is organic. When metrics are imposed top-down for reporting, they become a compliance burden that teams resent and game.

Exercises

Exercise 1: Calculate DORA Metrics
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.
Exercise 2: Identify Bottlenecks
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?
Exercise 3: Design an Improvement Plan
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.
Exercise 4: Set Up Measurement
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.