DORA Metrics
14 minutes reading time

Complete Guide to Change Failure Rate [2026 Edition]

Change Failure Rate Dora Metric

Change failure rate (CFR), which DORA now calls change fail rate, is the percentage of production deployments that cause a failure requiring a rollback, hotfix, or incident response.

Tracking it shows which kinds of deployments keep breaking production and how much planned work your team loses to fixing them.

What Is Change Failure Rate?

Change failure rate (CFR) is the share of production deployments that fail and need immediate intervention, such as a rollback, hotfix, or incident response. A high CFR usually points to gaps in testing, code review, or release checks that let defects reach production.

Here's a YouTube video explaining this in a bit more detail:

What Counts as a Deployment and a Failure?

A deployment is a change released to production and recorded through a production CI job or webhook event. A failure is a production deployment that causes an incident requiring a hotfix, rollback, or other corrective action.

Teams usually count a deployment as failed when one of these sources records a problem it caused:

  • Incidents opened in an incident management tool (e.g., PagerDuty, Zenduty), the usual source for teams with uptime targets.
  • System degradation or downtime detected by a monitoring tool (e.g., DataDog, AWS CloudWatch, NewRelic, etc.).
  • Error produced by the application (captured in an error tracker like Sentry, for example).
  • User-facing bugs logged in an issue tracker (like Jira).
  • Incidents above a set severity level: some teams only count deployments that cause major outages, such as the application becoming unavailable to customers.
  • Rollbacks: some teams only count deployments that had to be rolled back. This rule is simple to track, but it misses failures fixed with a hotfix.

Minor issues that don’t affect users or system performance, such as a wrong label, don’t count as failures.

A Quick Introduction to DORA Metrics

Along with the CFR, the DORA group defines four more metrics :

  • Deployment frequency (DF): How often your team deploys code to production successfully.
  • Lead time for changes (LTFC): The time from a change’s first commit until that code runs successfully in production.
  • Failed deployment recovery time (formerly MTTR): Measures how long it takes to restore service after a production deployment causes a failure requiring intervention.
  • Rework rate: This metric measures the share of deployments that are unplanned fixes for a production issue. CFR counts the deployments that failed, while rework rate counts the deployments made to fix them.

Together, these are the DORA metrics: deployment frequency and lead time for changes measure delivery speed, while CFR, failed deployment recovery time, and rework rate measure stability.

How to Calculate Change Failure Rate (Step-by-Step)

CFR = (failed deployments ÷ total production deployments) × 100.

You can calculate CFR by hand with the steps below. Axify calculates it automatically from the Git, CI/CD, and incident tools you already use, through read-only integrations.

Here’s what that looks like:

Axify change failure rate chart showing 6 failed deployments out of 126, a 4.8% failure rate.

To calculate CFR manually:

  1. Define what counts as a failure: Pick the failure sources from the list above that your team counts, and decide when a deployment counts as their cause.
  2. Count the total number of deployments: Only count production deployments. Leave out failed pipeline runs and deployments to staging or test environments.
  3. Count the number of failed deployments: Count the production deployments that caused a failure under your step 1 definition. Leave out incidents your deployments didn’t cause, such as third-party outages.
  4. Apply the change failure rate formula: The formula is CFR = (Failed Deployments ÷ Total Deployments) × 100.
  5. Validate the data sources: Check that each incident is tagged with the service and deployment that caused it, so it counts toward the right team.
  6. Review CFR trends over time: Compare CFR week over week or month over month to see whether it’s rising or falling. If you deploy rarely, use longer periods (see Example 1 below).

Example of Change Failure Rate Calculation

Here are two examples:

MetricExample 1Example 2
Deployments630
Failures23
CFR(2 ÷ 6) × 100 ≈ 33%(3 ÷ 30) × 100 = 10%

Change failure rate example with two failures across six deployments.

Example 1 shows why small samples mislead: with only six deployments, each failure moves CFR by about 17 percentage points.

What Is a Good Change Failure Rate?

In the 2025 DORA report, 8.5% of teams reported a change failure rate of 0-2%, while 8.1% reported 2-4%. The 0-2% range is the lowest bucket in the report’s distribution.

Most teams sit between 4% and 32%: the 4-8%, 8-16%, and 16-32% buckets together hold 65.1% of respondents.

Here’s the full distribution from the 2025 report:

CFR range% of teams
0-2%8.5%
2-4%8.1%
4-8%19.6%
8-16%26.0%
16-32%19.5%
32-64%12.5%
More than 64%5.9%

For guidance on applying these metrics to your team, see our guide on how to implement DORA metrics.

In earlier DORA reports, CFR was reported alongside the team’s performance category. The 2024 report gives the following values:

Teams by performance levelChange failure rateDORA report edition
Elite5%2024
High20%2024
Medium10%2024
Low40%2024

Interestingly, in 2024 medium-performance teams had a lower CFR than high-performance teams, but the high-performance teams delivered changes faster. DORA assigned each category from all four delivery metrics at once, so a team’s category reflects its speed as well as its stability.

Pro tip: A low change failure rate is a good sign, but it doesn’t tell the whole story. Look at it alongside the other DORA metrics to understand how your team balances delivery speed and stability.

The 2025 report replaced these four performance tiers with seven team archetypes, so its CFR buckets do not carry elite, high, medium, or low labels.

Why 0% CFR Is Not Realistic [And Why a Low Change Failure Rate Isn’t Always Better]

A 0% CFR isn’t a realistic target, and pushing toward it can slow delivery without making releases safer. Here’s why:

Complexity of modern systems.

Most production systems depend on third-party services, shared libraries, and infrastructure that changes outside your team’s control. Some failures only appear in production, under real traffic and data, whatever your test suite covers.

Over-testing and slow delivery.

Chasing zero failures usually adds test runs, approval steps, and manual QA to every release. Releases then wait longer, changes pile up into bigger batches, and bigger batches are harder to review and roll back.

Fast recovery limits the damage.

A failure that your team detects and rolls back within minutes affects few users. That’s why CFR needs to be read with failed deployment recovery time, as the section on the other DORA metrics below shows.

Change Failure Rate and AI-Assisted Development

The 2025 DORA report associates AI adoption with higher software delivery throughput, but also with higher delivery instability: AI does not fix instability on its own.

Why does this happen?

AI can raise CFR if faster code generation leads to bigger PRs and faster merges without enough review. Reviewers then have less time per line, which makes bugs easier to miss before deployment.

AI-generated code still needs careful review before it reaches production, though.

In a study of 567 Claude Code-generated PRs across 157 open-source projects, 45.1% of merged PRs required revisions before integration, most often to fix bugs.

The study measured changes made before merging so it doesn’t show how often AI-generated code caused incidents.

But it does show why teams should leave enough time for review: catching bugs before deployment can help prevent changes from becoming production failures.

How to Check Whether AI Is Affecting Your CFR

When measuring AI coding tools, compare CFR for AI-assisted and non-assisted teams, or the same team before and after adoption. Use the same type of work and the same reporting periods on both sides.

In Axify’s Explore, you can put AI usage next to CFR, deployment frequency, or PR throughput for the same teams and periods, and see whether failures rise as adoption grows.

Axify Explore view comparing AI token usage with deployment frequency for one team over six months.

Then interpret CFR in the context of your AI adoption data.

A high AI acceptance rate (the share of AI suggestions developers accept) paired with rising CFR can signal that developers trust suggestions faster than they review them. Check PR size and review time to investigate.

Axify’s AI adoption score adds context through reflexive use, reliance, and trust. Axify measures them as active days over the last 28 days, gross cost per active day, and how regular the gaps between usage days are.

Axify AI adoption leaderboard comparing team adoption scores, variation and score distribution.

You can read that score alongside AI cost per team to decide where to investigate rising failures across your AI SDLC. For example, start with a team whose AI spending and CFR both increased after adoption.

Why Is Change Failure Rate Important?

CFR shows whether your release process catches defects before users see them. It matters for three reasons:

Identify Weak Points in Your Deployment Process

A high CFR shows that defects get past your tests and code reviews. For example, if 30% of your deployments require rollbacks, it may be time to rethink your testing environments to catch issues earlier.

Reduce Downtime and Improve Reliability

Every failed deployment disrupts users until your team rolls it back or ships a fix. Fewer failed deployments mean fewer of those disruptions and fewer support tickets after each release.

Improve Team Accountability and Feedback Loops

CFR gives developers and operations engineers one shared number for release quality. When it rises, both groups review the same failed deployments and agree on specific fixes, such as a missing test or a skipped review step.

Best Practices to Monitor Change Failure Rate Accurately

The CFR formula is simple, but what you count in it decides whether the number is accurate. Four rules keep it consistent:

1. Define What Failure Means and Establish a Formal Process to Track Failures

Use one written definition of failure across all teams, and record failures in the same tools every time. Otherwise, you can’t compare CFR between teams or between months.

Pro tip: Axify reads incidents from New Relic, Jira, Azure DevOps, GitLab, or a webhook and ties each one to a production deployment, so failures logged outside Jira still count toward CFR.

2. Exclude “Failures to Deploy” From the Number of Failed Deployments

Exclude deployment jobs that fail before changing production. If a deployment changes production and causes a failure requiring intervention, count it in CFR, including failures caused by configuration or infrastructure changes.

3. Disregard Failures Due to External Factors

Exclude third-party outages and network incidents unrelated to your production deployments. If a deployment caused the incident, include it in CFR.

4. Regularly Review and Adjust Your Definition of Failure

Review your failure definition every quarter and after major changes, such as a new incident tool or a move to microservices, so CFR keeps counting the failures your users notice.

How to Reduce Change Failure Rate

To lower CFR, catch defects before a change reaches production and limit how many users a failed change can reach. These practices do both without slowing your release pace:

  • Test automation: Automated unit, integration, and end-to-end tests check every change before it reaches production. That’s important because projects with more mature test automation have higher product quality and shorter release cycles, according to recent data.
  • Deployment automation: Fully automated deployments remove the need for manual intervention during release. This reduces configuration drift, timing mistakes, and last-minute fixes that commonly increase failure rates.
  • Trunk-based development: Keep fewer than three active branches and merge each one within a day. Short-lived branches cause fewer merge conflicts and surface integration problems while changes are still small.
  • Continuous integration: Merge to the main branch several times a day, and build and test every merge automatically. Conflicts and dependency issues then show up within hours, while the change is still easy to fix.
  • Feature flags: Use feature flags to enable new functionality for a small group of users first, then expand access as you confirm it works. If a flagged feature causes problems, you can disable it without redeploying the application.

Other best practices to minimize CFR include:

  • Failure detection: Automated monitoring and testing help surface failures as soon as changes hit production. Alerts tied to a specific deployment show which change caused the problem before it affects more services or users.
  • Small, frequent deployments: Shipping smaller changes more often usually limits the consequences of a failed or faulty deployment. With less change per deployment, failures are easier to trace, and fixes can be deployed faster.
  • “Fix-it-twice” approach: After resolving an incident, revisit the underlying problem and add safeguards that prevent it from happening again. For example, add an automated test that catches the same defect before the next deployment.
  • Swarming incident response: Bring all relevant team members together as soon as an incident occurs so they can pool their expertise, identify the cause, and restore service quickly. Working together reduces handoffs and helps the team coordinate under pressure.

For each failure, also record how long the outage lasted and the steps your team took to restore service. Outage duration feeds failed deployment recovery time, and the restoration steps become the runbook for the next similar incident.

How to Read Change Failure Rate With the Other DORA Metrics

CFR by itself can’t tell you if a team is as productive as it can, given its unique context and project you’re working on. Read it next to speed and recovery metrics to understand how quickly your team delivers changes, how often deployments fail, and how quickly service is restored.

Use the tables below to decide what to check first. Compare the same application or service over consistent reporting periods before drawing conclusions.

Lead Time for Changes

In the 2025 DORA survey, 9.4% of respondents reported lead times of less than one hour.

Here’s how lead time and CFR can be read together:

CombinationLead timeCFRWhat it likely meansWhat to check
Shorter lead time with a lower CFRDecreasingDecreasingSmaller batches and automation may be paying off.Keep going, and confirm that smaller changes and automated checks are supporting the improvement.
Shorter lead time with a higher CFRDecreasingIncreasingYour team may be shipping faster than it can verify changes.Check PR size and review time, especially when AI generates large PRs.
Longer lead time with a lower CFRIncreasingDecreasingDelivery is becoming more stable, but changes take longer to reach production.Look for manual approvals, change advisory boards, and repeated testing that adds little coverage.
Longer lead time with a higher CFRIncreasingIncreasingLarge batches and long-lived branches may be making changes harder to review and integrate.Check batch sizes and branch lifetimes. Split work into smaller changes and move toward trunk-based development.

Deployment Frequency

In the 2025 DORA survey, 16.2% of respondents reported deploying on demand, with multiple deployments per day.

Here’s how deployment frequency and CFR can be interpreted together:

CombinationDeployment frequencyCFRWhat it likely meansWhat to check
More frequent deployments with a steady or lower CFRIncreasingStable or decreasingYour pipeline is handling more releases without a higher failure rate, which suggests mature delivery practices.Confirm that changes stay small and automated tests and release checks remain effective.
More frequent deployments with a higher CFRIncreasingIncreasingYour team may be releasing more changes without enough safeguards.Check test coverage, code reviews, and whether release checks are being skipped.
Less frequent deployments with a lower CFRDecreasingDecreasingYour team may be playing safe by holding changes and batching releases.Check release queues, batch sizes, and approval delays.
Less frequent deployments with a higher CFRDecreasingIncreasingReleases may be getting bigger and riskier.Look for accumulated changes and integration conflicts, then split releases into smaller batches.

Failed Deployment Recovery Time

In the 2025 DORA survey, 21.3% of respondents reported recovering from failed deployments in less than one hour.

Let’s see how you can read recovery time and CFR in context:

CombinationRecovery timeCFRWhat it likely meansWhat to check
High CFR with fast recoveryShortHighYour team restores service quickly, but too many deployments fail.Invest in prevention. Review recurring causes, testing gaps, and code review practices.
Low CFR with slow recoveryLongLowFailures are rare but painful when they happen.Practice rollbacks and check alerts, recovery instructions, and incident ownership.
High CFR with slow recoveryLongHighFrequent failures and prolonged disruption need urgent attention.Prioritize recurring failure causes and the steps delaying service restoration.
Low CFR with fast recoveryShortLowDeployments rarely fail, and your team recovers quickly when they do.Maintain the testing, monitoring, and recovery practices supporting this healthy pattern.
"When you improve the engineering culture, DevOps practices will lead you to smaller, but more frequent changes. With smaller changes, incidents are easier to spot and manage, hence reducing the time it takes to fix them. It will be safer to deploy more changes. It is less risky for a business to have a team that can deploy more changes with fewer failures and can fix a mistake quickly (e.g., in less than 30 minutes). Also, high CFR and high MTTR mean more time spent on fixing bugs and service degradation, which is a dollar spent that doesn't create more business value."
- Alexandre Walsh, CTO & Co-Founder, Axify

What Is the Cost or Impact of the Change Failure Rate on Businesses?

A high CFR costs money in three places: engineering hours spent on fixes, revenue lost while the service is down, and customers who stop trusting your releases.

Here is a list of the main issues that can arise from having a high CFR:

  • Decreased productivity: Each failed deployment pulls developers off planned work to fix production, and switching back costs more time, which delays features. In GitHub’s 2021 study of 40 engineers, developers had an 82% chance of reporting a good day with minimal interruptions, compared with 7% when interruptions occupied most of the day.
  • Increased maintenance costs: Rollbacks, hotfixes, and incident reviews take engineering hours away from new features. Developers already spend more than 17 hours of a 41-hour work week on maintenance such as debugging and refactoring, according to Stripe’s Developer Coefficient report.
  • Lower competitiveness: Users who keep hitting outages or broken features after releases have a reason to try a competitor.
  • Security risks: Changes rushed out with less testing can ship security flaws, such as broken access checks, along with functional bugs.

The dollar cost of a failed deployment depends on its severity, how many customers it reaches, and your industry, so there’s no single acceptable figure. Alexandre Walsh recommends estimating it regularly:

"In order to reduce the change failure rate and its associated financial costs, it is good practice to conduct regular assessments of the CFR costs and compare them with similar organizations within your industry. By doing this, you will understand the relative costs and can set realistic goals and objectives."
- Alexandre Walsh, CTO & Co-Founder, Axify

Best Tools to Measure Change Failure Rate

A spreadsheet works until deployments and incidents are recorded in different tools and someone has to match them by hand. Axify reads deployments from your Git and CI/CD tools and incidents from your incident tools, then calculates CFR for every team automatically.

While each team’s CFR is calculated independently to avoid unfair normalization, you can easily toggle between a per-team breakdown or an aggregated organization-level average. You can also break CFR down by project or group and open the list of deployments and incidents behind each number.

You can track change failure rate alongside deployment frequency, lead time for changes, and failed deployment recovery time inside our DORA dashboard.

Axify DORA metrics dashboard showing deployment frequency, lead time, change failure rate and recovery time with performance levels.

With Axify Intelligence, you can ask in plain language why CFR changed for one team. For example, ask, “Why did Team X’s CFR increase this month, and what should we investigate first?” Axify Intelligence reads your team’s deployment, pull request, and incident data, explains what drove the change, recommends where to act, and lets you implement the change directly from the platform.

Axify Intelligence explaining why pull request cycle time went up, with pickup time as the main cause.

You can also ask these questions from Claude, ChatGPT, or Cursor through the Axify MCP server. The MCP server is read-only and uses the same data and access permissions as the app.

Axify’s engineering metrics dashboard also shows pull request cycle time, workflow stability, throughput, and time spent in each workflow stage, among other essential engineering metrics.

When CFR rises, these show whether pull requests waited longer for review or moved through testing faster than usual before the failed deployments.

How to Use Change Failure Rate in Your Engineering Process

Once you track CFR, use it in three recurring decisions about your software delivery process:

  • For quality baseline setting: Record your current CFR before you change your testing, review, or deployment process, and set a target, such as staying below 15%. Comparing later months with that baseline shows whether each change reduced failures.
  • For release readiness signals: Use recent CFR trends to flag recurring release risks, then check the current release’s tests, reviews, and rollback plan before deciding whether to deploy. For example, if CFR doubles after an architecture change, hold risky releases until you know which part of the new architecture fails.
  • For incident response prioritization: Group failed deployments by service and failure type, then fix the combination that causes the most failures first. That single fix lowers CFR the most.

Lower Your Change Failure Rate With Axify

Change failure rate shows how often your releases break production.

To lower it, you need to see which deployments failed, what changed before they failed, and whether AI coding tools play a part as your teams adopt more of them.

Axify works with engineering leaders as a long-term partner for these decisions.

It gives you visibility into AI usage, AI cost, and AI’s effect on delivery, shown with CFR and the other DORA metrics for each team. Axify Intelligence turns that data into insights: it explains why a team’s CFR changed, recommends where to act, and lets you implement the change directly from the platform.

As your teams and AI tools change, you keep deciding where to invest in code reviews, testing, or AI licenses based on your own delivery data.

See how Axify tracks your DORA metrics and AI impact on your own data. Get started with a free 14-day trial, no credit card required.

FAQs

Does turning off a feature flag count as a failed deployment?

Yes, if you turned the flag off because the new feature broke something for users. Switching it off was the immediate intervention, so the deployment that shipped the feature counts as failed. If you turned it off for a product reason, such as low usage, it doesn’t count.

How do you count one incident caused by several deployments?

CFR counts failed deployments, not incidents. If the incident traces back to one deployment, count only that one. If two deployments each shipped a change that had to be fixed or rolled back, count two failed deployments.

Do hotfixes count as deployments in the CFR calculation?

Yes. A hotfix released to production is a deployment, so it goes into your total. If the hotfix causes a new failure, it also counts as a failed deployment.

How long after a release can a failure still count toward CFR?

DORA counts failures that need immediate intervention, so most teams only count failures found soon after a release. Pick one window, such as until the next deployment of the same service, and apply it to every team. A defect found months later belongs in your bug metrics.

Should you use CFR to evaluate individual developers?

No. A failed deployment usually comes from gaps in tests, code reviews, or release checks that the whole team owns. Ranking developers by CFR pushes them to deploy less often or report fewer incidents, so the number stops reflecting release quality.