In short
Deployment rework rate has been the fifth DORA metric since the 2024 Accelerate State of DevOps report. According to DORA, it measures the share of deployments that are unplanned because an incident in production forces them, and together with change failure rate it forms the instability factor of software delivery. It can be approximated from existing Git and deployment data.
What is Deployment Rework Rate?
According to DORA, deployment rework rate measures the share of deployments that are unplanned because an incident in production forces them; the DORA survey asks about unplanned deployments made to address a user-facing bug. It is therefore not a throughput metric like deployment frequency but, like change failure rate, belongs to the instability side of delivery: it shows how often teams declare "done" while unplanned corrections follow.
For context: DORA originally comprised four metrics: Deployment Frequency, Lead Time for Changes, Change Failure Rate and Time to Restore Service (redefined as Failed Deployment Recovery Time in 2023). Since 2024, Deployment Rework Rate has joined them as the fifth metric. If you are looking for the overview of all five metrics with benchmarks and measurement guidance, start with the complete guide to the DORA metrics; this article goes deep on the new fifth metric only.
For a quick baseline: the free DevOps readiness check scores your DevOps maturity across five dimensions, aligned with the DORA research model — in about 3 minutes, no login required.
The Google DORA team introduced Rework Rate as its fifth metric in the 2024 Accelerate State of DevOps report; according to DORA's own history, this is the most significant structural change to the metrics (see https://dora.dev/insights/dora-metrics-history/). Background according to DORA: change failure rate has long been treated as a proxy for the amount of rework a team does; to test this, DORA added rework rate. Together, the two metrics form a reliable factor for the stability of software delivery (Accelerate State of DevOps report 2024, https://services.google.com/fh/files/misc/2024_final_dora_report.pdf).
The DORA definition (see https://dora.dev/guides/dora-metrics/) names no fixed time window between the original deployment and the corrective deployment; the DORA survey merely asks for the share of unplanned deployments made to address a user-facing bug over the last six months. For measurement from Git and deployment data we use an approximation: any deployment that touches the same application, service, or repository again within 72 hours of a previous deployment counts as a rework candidate. The window is deliberately short: what has to be patched again after three days was probably not production-ready at the original release. Longer time windows tend to blur normal iteration cycles with genuine correction work.
Important: Rework Rate is not suited as a punishment metric. High values can point to systemic weaknesses in test coverage, code review, or specification practices — not "bad" individuals. The DORA metrics guide provides for all five metrics to be applied at the level of an application or service and warns against comparing very different applications and against competition between teams (https://dora.dev/guides/dora-metrics/). We additionally recommend not using Rework Rate in individual performance evaluation.
Rework Rate answers the question Change Failure Rate does not ask: how often did we have to touch the same code immediately after release — regardless of whether it was a classic incident or just a "well, that is still a bug" patch?
Why Now? The AI Amplifier on the Rework Spiral
Rework rate gains weight with the broad rollout of AI-assisted code generation. The Thoughtworks Technology Radar Vol. 34 (April 2026, see https://www.thoughtworks.com/radar/techniques/dora-metrics) states in this context that degradation in stability metrics, particularly rework rate, is an early warning sign of blind spots, technical debt and the risks of unchecked AI-assisted development; measuring productivity by lines of code generated by AI is misleading. Technology Radar Vol. 35 (November 2026) again rates “Coding throughput as a measure of productivity” as Caution: activity metrics such as the share of AI-generated code or tokens consumed are poor proxies for real productivity gains, and to measure meaningful productivity it continues to recommend established frameworks such as DORA metrics (see https://www.thoughtworks.com/radar/techniques/coding-throughput-as-a-measure-of-productivity). What appears to be a productivity gain can later show up as hidden maintenance burden.
Our assessment of the mechanism (not a DORA finding): AI assistants can produce plausible-looking code that passes local tests but makes silent assumptions about interface behaviour, state management, or failure modes that surface only in real operation. Change failure rate captures deployments that require immediate intervention such as a rollback or hotfix; rework rate adds the share of unplanned deployments made to fix bugs.
The Google DORA Report 2025 (see https://dora.dev/research/2025/dora-report/) describes AI as an amplifier that magnifies the strengths of high-performing organisations and the dysfunctions of struggling ones. According to the report, AI adoption now improves software delivery throughput but still increases delivery instability; that instability includes change failure rate and rework rate (https://services.google.com/fh/files/misc/2025_state_of_ai_assisted_software_development.pdf).
For CIOs and Engineering Directors, the fifth metric is therefore not a technical detail question but a governance-relevant control variable: rolling out AI-assisted development broadly without watching Rework Rate in parallel risks a productivity number that points up while actual delivery quality silently erodes underneath.
How to Measure Rework Rate Without New Tooling
The good news: an approximation of Rework Rate can be derived from data that nearly every CI/CD pipeline already produces. The only prerequisite is consistent tagging of each deployment with a stable service or repository identifier and a timestamp. From those two fields you build an hour-window function that, for each deployment, checks whether another deployment of the same identifier took place within the previous 72 hours.
Concretely: if service X is deployed at 10:00 today and the last deploy of the same service was 28 hours ago, today's deployment counts as a rework candidate. If the previous deploy is more than 72 hours old, it is a regular release. The approximate Rework Rate for a period is then the share of rework candidates in all deployments for the same period. The approximation overstates the ratio for teams with several deployments per day, because every regular follow-up deployment counts; it becomes more precise when deployments are linked to incident and bug tickets and only unplanned bug fixes count.
In practice this works with GitHub Actions, GitLab CI, Argo CD, Jenkins, Azure DevOps, or Spinnaker — all tools write deployment events to logs or a database. A simple SQL statement against the deployment table, a Loki query, or a Python script with Pandas is enough to produce an initial baseline. We recommend tracking the other four DORA metrics alongside, so that Rework Rate is always interpreted in the context of throughput and instability values.
The definition of "same code" matters: pure configuration changes, pure infrastructure changes, or scheduled hotfix windows (e.g. weekly security patches) should not count as rework. Tag such deployments in CI as "infra" or "scheduled" and exclude them from the numerator, otherwise the ratio will skew upwards.
Minimal Data Structure per Deployment
Service or repository identifier (string, stable across renames). Deployment timestamp (UTC). Deployment type (feature, hotfix, infra, scheduled). Commit or pull-request reference for traceability. In microservice architectures we additionally recommend an optional "affected_modules" field so that rework becomes measurable at module level.
From these fields, Rework Rate can be derived per service as well as aggregated per team or domain. Service-level values fit engineering retros; aggregated values for management reports should be built with care, because according to the DORA metrics guide the context differs between applications (https://dora.dev/guides/dora-metrics/).
Distribution in the DORA Report 2025: Where Do You Stand?
The DORA Reports 2024 and 2025 and the DORA metrics guide contain no elite/high/medium/low levels and no thresholds for rework rate. The performance levels of the 2024 report were derived solely from the four original metrics (https://services.google.com/fh/files/misc/2024_final_dora_report.pdf); the 2025 report groups teams into seven archetypes and shows the distribution of respondents for each metric.
For rework rate, the DORA 2025 survey (fielded 13 June to 21 July 2025; Figure 15 of the report, https://services.google.com/fh/files/misc/2025_state_of_ai_assisted_software_development.pdf) shows: 6.9% of respondents reported a rework rate of 0–2%, cumulatively 26.5% reported up to 8% and 52.6% up to 16%. The median therefore lies in the 8–16% range. 7.3% of respondents reported more than 64%. These are self-reported figures for the respective last six months, not measured deployment data.
As a common approach to improving all five metrics, the DORA metrics guide names smaller changes: they are easier to assess, to move through the delivery process and to recover from if something fails (https://dora.dev/guides/dora-metrics/).
With infrequent releases, for example two per quarter, rework rate can come out arithmetically low because fewer deployments take place and changes are bundled. A value near 0% is then no proof of quality. Read rework rate together with deployment frequency; DORA stresses that no single metric stands on its own (https://dora.dev/guides/dora-metrics/).
To place Rework Rate alongside the other four DORA metrics, see our in-depth DORA metrics guide at /blog/dora-metrics-guide. How AI shifts the DORA numbers overall is placed in our AI delivery maturity check based on the DORA Report 2025 at /blog/ki-delivery-reifegrad-7-capabilities; which measures beyond the DORA metrics are gaining relevance (SPACE, DevEx, DX Core 4) is covered in the article at /blog/beyond-dora-space-devex-dx-core-4.
| Rework rate (self-reported, last 6 months) | Share of respondents | Cumulative |
|---|---|---|
| 0–2% | 6.9% | 6.9% |
| 2–4% | 5.8% | 12.8% |
| 4–8% | 13.7% | 26.5% |
| 8–16% | 26.1% | 52.6% |
| 16–32% | 24.7% | 77.3% |
| 32–64% | 15.4% | 92.7% |
| > 64% | 7.3% | 100% |
AI-Specific Traps and Countermeasures
When you roll out AI coding assistants broadly, three patterns are, in our view, likely to push Rework Rate upwards (our own assessment, not a DORA finding). First: optimistic edge-case handling — AI generates defensive wrappers that feel solid in tests but take dramatically different paths under production load profiles. Counter: property-based testing or fuzzing in CI as a mandatory step for AI-touched files. Second: silent interface assumptions — the assistant guesses where API documentation is ambiguous. Counter: enforced spec-first practice (see our article on spec-driven development at /blog/spec-driven-development-governance).
Third: configuration drift — AI code changes often reference feature flags or environment variables that exist in one environment but not in another. Counter: a configuration linter in the pre-merge check, complemented by a "promotion diff" stage between staging and production. Whether these levers reduce Rework Rate in your context shows in the trend of your own measurement — without having to reduce AI usage.
For a deeper dive into the AI code quality topic, the Alev-B article on cognitive debt (/blog/cognitive-debt-ki-code) offers the larger systemic framing — Rework Rate is, in a sense, the numerical leading indicator where cognitive debt shows up first, before it wanders into the backlog as maintenance load.
90-Day Implementation
Day 1–14 (baseline): collect 8 weeks of historical deployment data retrospectively from your CI logs. Calculate a first baseline per service and aggregated per team. Deliberately avoid targets at this stage — first understand what "normal" looks like for your architecture and release cadence.
Day 15–45 (visibility): build a simple dashboard showing Rework Rate alongside the other four DORA metrics. Establish a weekly 15-minute standup item: "Which deployments this week were rework, and what root cause stood behind them?" Important: blameless, focused on systemic learning. The first findings will usually be test coverage gaps or missing spec review gates.
Day 46–90 (intervention): choose at most two levers — for example enforced pre-merge test coverage of 65% and a property-based test for AI-touched files. Measure the trend after 30 days, not the absolute value. Treat the metric as a signal, not a target: the DORA metrics guide warns against making metrics a goal because teams are then more likely to game them (https://dora.dev/guides/dora-metrics/).
If you keep this rhythm over several quarters, you build a reliable data basis to place your trend against the DORA distribution and to choose further levers deliberately. Those who want the full maturity check of engineering practices automated will find a fitting template in the Alev-B catalog at /templates/devops-maturity and /templates/dora-metrics.
Key Takeaways
- Deployment Rework Rate has been the 5th DORA metric since the 2024 DORA report, complementing Change Fail Rate as the second instability metric with a view of unplanned rework; throughput is measured by Change Lead Time, Deployment Frequency and Failed Deployment Recovery Time (formerly MTTR).
- According to DORA, it measures the share of deployments that are unplanned because an incident in production forces them; as an approximation from deployment data, this article uses a 72-hour window (our own convention).
- According to the DORA Report 2025, AI adoption improves delivery throughput but still increases delivery instability (change failure rate and rework rate).
- DORA publishes no elite thresholds for rework rate; in the DORA Report 2025, 6.9% of respondents reported 0–2%, and the median lies in the 8–16% range.
- The metric can be approximated from existing CI/CD logs — without new tooling; it becomes more precise when linked to incident and bug tickets.
- Rolling out AI-assisted development without observing Rework Rate risks a productivity illusion: according to Thoughtworks Technology Radar Vol. 34, measuring productivity by lines of code generated by AI is misleading.
Frequently Asked Questions
No, both metrics remain side by side in the DORA model and together form the instability factor of software delivery. Change failure rate captures deployments that require immediate intervention, such as a rollback or hotfix. Rework rate captures the share of unplanned deployments made to fix bugs. DORA added it because change failure rate is treated as a proxy for the amount of rework (Accelerate State of DevOps report 2024).
DORA does not prescribe a fixed time window; the 72-hour window is this article's measurement convention, justified as being long enough to distinguish genuine correction work from a regular follow-up release, and short enough not to catch normal iteration cycles. In industries with very fast release cadence (e.g. consumer-facing SaaS with dozens of deployments per day) a shorter threshold may make sense; in regulated industries with weekly releases (finance, public sector), 72 hours is a pragmatic choice. More important than the exact threshold is consistency: once a threshold is chosen, it should be kept for at least four quarters to allow trend comparisons.
Code Churn measures volatility at the code level — how often a line of code changes before it stabilises. Rework Rate measures at the deployment level — what share of deployments are unplanned fixes for bugs. The two metrics can complement each other but are not interchangeable. High Code Churn without high Rework Rate usually means intensive iteration before release; high Rework Rate without high Code Churn indicates large changes that go into production insufficiently tested. For governance purposes, Rework Rate is more telling because it measures the organisational delivery decision, not just developer behaviour.
Yes, particularly well. In monolithic systems the service identifier is trivial — there is only one — and every deployment by definition affects the same codebase. The typical trap in monoliths is rather that Rework Rate looks artificially low because many changes are bundled into rarer, large releases. A breakdown by code module or domain helps here: even when only one deployment artefact exists, it is possible to track which modules were touched repeatedly within the 72-hour window. This module level becomes the meaningful granularity for monoliths.
Avoid the framing "new metric" — use "blind spot of current reporting" instead. Show concretely with an example from the last two quarters: here Failed Deployment Recovery Time and Change Fail Rate were green, but this team deployed the same service 17 times in four weeks as unplanned bug fixes. Management intuitively understands that this is a problem. Rework Rate is the number that turns this intuitive insight into a repeatable indicator. In practice it takes one concrete case to extend the reporting set permanently — no strategy paper substitutes for this practical evidence.
The DORA metrics guide names no particular platform and suggests starting with conversations and the DORA Quick Check rather than building elaborate integrations for exact data up front (https://dora.dev/guides/dora-metrics/). The Quick Check (https://dora.dev/quickcheck/) has asked for rework rate since the 2025 edition. Commercial vendors offer automated analysis; Faros AI, for example, describes a rework rate dashboard (https://www.faros.ai/blog/5th-dora-metric-rework-rate-track-it-now). Check each vendor's definition: LinearB, for instance, has its own "Rework Rate" metric for changes to code younger than 21 days (https://linearb.io/blog/git-analytics) — that is not the DORA metric. The dora-team/fourkeys project on GitHub is archived and contains no rework rate calculation (https://github.com/dora-team/fourkeys).
DORA defines no thresholds and no performance levels for it: the DORA Reports 2024 and 2025 and the metrics guide contain no elite/high/medium/low values for rework rate. For orientation, the DORA Report 2025 publishes the distribution of self-reported answers (Figure 15, https://services.google.com/fh/files/misc/2025_state_of_ai_assisted_software_development.pdf): 6.9% of respondents reported 0–2%, cumulatively 26.5% up to 8% and 52.6% up to 16%; 7.3% reported more than 64%. Your own trend matters more than an external value: DORA warns against making metrics a goal and against competing with other teams (https://dora.dev/guides/dora-metrics/). At very low deployment frequency (say two releases per quarter), a low value may be a side-effect of too few releases rather than proof of quality — so always read rework rate together with deployment frequency.
According to DORA, deployment rework rate is the share of deployments among all deployments in a period that are unplanned because an incident in production forces them (https://dora.dev/guides/dora-metrics/). As an approximation from Git and deployment data, this article counts a deployment as a rework candidate if another deployment of the same service or repository already happened within the previous 72 hours. Formally: rework rate (approximation) = (deployments with a prior deploy of the same identifier within ≤ 72h) ÷ (all deployments) × 100. You need only two fields per deployment for this — a stable service identifier and a UTC timestamp. Pure infrastructure, configuration, or scheduled patch deployments should be tagged "infra" or "scheduled" and excluded from the numerator, otherwise the ratio skews upwards. A simple SQL statement or a 50-line Python script against your CI logs is enough for a first baseline; it becomes more precise when linked to incident and bug tickets.
Yes. The Google DORA team introduced deployment rework rate as its fifth metric in the 2024 Accelerate State of DevOps report, alongside the four original metrics from the 2018 book "Accelerate" (Deployment Frequency, Lead Time for Changes, Change Failure Rate, Time to Restore Service, redefined as Failed Deployment Recovery Time in 2023). The official definition is in the DORA metrics guide (https://dora.dev/guides/dora-metrics/). It is therefore not a vendor metric but part of the official DORA research programme. A deeper treatment of all five metrics is in our DORA metrics guide at /blog/dora-metrics-guide.