---
id: mgmt.delivery-metrics
title: Delivery metrics
kind: practice
domain: management
description: Measure how a project delivers with DORA's five software delivery metrics and a few method metrics taken from records the method already writes, at the level of the application, to improve the way of working and never to rank people or agents.
version: 0.1.1
status: review
authority: uask
applies_to: [core]
sources:
  - title: 'DORA, "DORA''s software delivery performance metrics" (the five metrics, throughput and instability, common pitfalls)'
    url: https://dora.dev/guides/dora-metrics/
    license: CC-BY-4.0
    accessed: 2026-11-21
  - title: 'DORA, "A history of DORA''s software delivery metrics" (why failed deployment recovery time and deployment rework rate)'
    url: https://dora.dev/guides/dora-metrics/history/
    license: CC-BY-4.0
    accessed: 2026-11-21
  - title: 'Forsgren, Humble and Kim, "Accelerate" (the research behind the delivery metrics)'
    url: https://itrevolution.com/product/accelerate/
    license: LicenseRef-All-Rights-Reserved
    accessed: 2026-11-21
requires: [process.project-lifecycle, process.work-packages, ops.incidents-and-postmortems, ops.service-levels, mgmt.roles-and-decision-rights]
related: [quality.quality-release, process.release-spec, mgmt.governance-tiers]
last_reviewed: 2026-11-21
review_every: 6
---

## Summary

A project that delivers in small releases can see how it is doing from a handful of numbers. DORA's research gives five of them for software delivery: change lead time, deployment frequency and failed deployment recovery time,
which show throughput, and change fail rate and deployment rework rate, which show instability. This item adds a few metrics of the method itself, all computed from records the other items already require, sets the pitfalls
to avoid, and fixes the use: the numbers are read by the team and the owner to decide what to improve, never to compare or reward individuals.

## Rules

### What is measured

- **R1.** A project that ships releases MUST, at the standard tier and above (`mgmt.governance-tiers`), define the five DORA metrics for its own application, and MAY at the lightweight tier define only the two instability metrics: what counts as a change, a deployment, a failure that needs immediate intervention and an unplanned deployment caused by an incident. Each
  definition MUST be written once where the project keeps its rules, so that two people compute the same number.
- **R2.** The five metrics MUST be read together: a throughput metric MUST NOT be reported without the instability metrics beside it (change fail rate and deployment rework rate).
- **R3.** A project SHOULD also keep the method metrics below, each defined like the DORA ones and computed from the records that the other items require:
  - the time from a request to the owner's decision at G0, and the owner's time spent at it (`process.project-lifecycle#R4`);
  - estimate against actual, in agent-days, per work package and per release (`process.work-packages#R12`);
  - the share of work packages that the verifier passed without a blocking finding (`process.work-packages#R8`, `process.work-packages#R9`);
  - the defects found after release per release, and how many of them led to a new check (`ops.incidents-and-postmortems#R12`);
  - whether each release ended within its appetite, with scope cut, or over (`process.release-spec#R12`);
  - the attainment of each service-level target in its window (`ops.service-levels#R4`).
- **R4.** Every metric MUST be computed from a record that exists: the project's log, the release records, the incident records or the gate records. A metric whose input nobody writes MUST NOT be reported; it MUST first become a line in the record.

### How it is used

- **R5.** The metrics MUST be measured for the application or service, not for a person, an agent or a session. They MUST NOT be used to rank, reward or blame people or agents, and MUST NOT be compared between applications of different
  kinds.
- **R6.** A metric MUST NOT be set as a target for people to hit. A project MAY state a direction it wants to move in, and MAY set a target for a service-level indicator under `ops.service-levels`, which is a different thing. When a metric
  becomes a goal it stops measuring (Goodhart's law).
- **R7.** With few deployments the numbers MUST be given as counts with the period ("2 of 7 deployments needed immediate intervention in the quarter"), not as percentages of a tiny sample, and a trend MUST NOT be read from fewer than
  three periods.
- **R8.** The metrics MUST be reviewed at the close of each release and at least quarterly. Each review MUST end in at most one change to the way of working, or in "no change", recorded with its date. A finding that repeats across projects MAY be
  proposed to the Hub.
- **R9.** The first quarter of a project MUST be treated as a baseline: the numbers are collected and read, and a change to the way of working MUST NOT be argued from them alone.
- **R10.** Measurement MUST NOT cost more than it informs. A metric that nobody has used to decide anything in two reviews SHOULD be dropped.
- **R11.** The metrics MUST NOT include a client's or a person's personal data, and a published example MUST be synthetic or from a UK project without client data.

## Guidance

### The five, in plain words

| Metric | Group | What to count in a small project |
|---|---|---|
| Change lead time | throughput | from the merge of a change to its running in production (or from the first commit, if the project always deploys from one) |
| Deployment frequency | throughput | how many deployments to production in a period |
| Failed deployment recovery time | throughput | how long from a deployment that needed immediate intervention until service was restored |
| Change fail rate | instability | the share of deployments that needed immediate intervention (a rollback or a hotfix) |
| Deployment rework rate | instability | the share of deployments that were unplanned because of an incident in production |

DORA groups them as throughput (how many changes move through) and instability (how well deployments go). The point of the pairs is tension: a team that deploys more often and breaks more is not improving.

### Where the inputs come from

Most of the data is already written. The work-package log (`process.work-packages#R12`) gives estimate against actual and the verifier's verdicts; the release record gives dates and deployments; the incident records give recovery times and
rework; the hand-over and service-level statements give the targets. If a line is missing, add it to the log format; do not reconstruct numbers from memory.

### A small project's report

A one-page report per release is enough: the five numbers with counts, the method metrics that apply, one sentence on what the numbers say and the one change decided. Keep the reports in the repository so that the quarter's trend can be read.

### What the owner reads

The owner's own time is the scarce resource the lifecycle protects, so the owner's minutes at each gate and the time between a request and the owner's decision are on the page. They are not a judgement of the owner; they show where the
method asks too much.

### Common mistakes

- Setting "deploy daily" as a goal for a team that deploys a shop twice a month.
- Reporting throughput without the instability metrics beside it.
- Comparing a shop with a firmware project.
- A percentage of three deployments.
- A dashboard nobody reads, and a measurement that costs more than the decision it supports.
- Using the numbers to find who is slow.

## Explanation

**Why these five.** DORA's research reports that speed and stability are not tradeoffs: the metrics are correlated for most teams, and top performers do well across all five. The five give both sides in a form that can be computed from a repository and a
log. DORA has revised the set over time, renaming and redefining mean time to recover as failed deployment recovery time and adding deployment rework rate, which is why this item cites the history page. **Why not a target.** DORA
names setting a metric as a goal as the first pitfall: teams then game it. **Why method metrics.** The Hub's own aim is a method that is cheap for the owner and catches defects early, and its measures (a request to G0 in an agent-hour, under
five owner-minutes at G0, escaped defects that became checks) are of that kind. They are the evidence for changing the method, and the way to see whether a change helped.

## Examples

**Good.** A small UK shop with releases about every two weeks. After the third release the report reads: change lead time one to three days, 7 deployments in the quarter, 1 of 7 needed immediate intervention (a rollback of a mail
template), 0 of 7 unplanned because of an incident, recovery 25 minutes. Method: estimates 24 agent-days, actual 27; 11 of 13 packages passed the verifier at once; 2 defects after release, both now covered by a check; one release ended
within appetite after the second language was cut. The review decides one change: the brief template gets a line for the mail templates it may touch. The owner spent four minutes at G0.

**Bad.** The agent is told to "double deployment frequency this quarter". It splits every change into trivial deployments, the rate doubles, the change fail rate hides in a small denominator, and a real defect ships on the busiest
Saturday. The figures are compared with a different client's project and the supporter is asked why theirs is slower.

## Sources

- [DORA, DORA's software delivery performance metrics](https://dora.dev/guides/dora-metrics/) — DORA, Google; CC BY 4.0; the five metrics, the throughput and instability groups and the common pitfalls. Accessed 2026-11-21.
- [DORA, A history of DORA's software delivery metrics](https://dora.dev/guides/dora-metrics/history/) — DORA, Google; CC BY 4.0; how the set changed. Accessed 2026-11-21.
- [Forsgren, Humble and Kim, Accelerate](https://itrevolution.com/product/accelerate/) — IT Revolution, all rights reserved; the research behind the metrics, named and not copied. Accessed 2026-11-21.
- The measures of the Hub's own pilot (a request to G0 within an agent-hour, under five owner-minutes at G0) and the records of the other items of this wave.
