DORA Metrics: 4 Metrics to Measure Your DevOps Performance

Your team has just finished a major software release. Months of hard work, countless cups of coffee, and a few too many late nights have culminated in this moment. But as you hit that deploy button, a nagging question lingers: How do you really know if you're consistently delivering value to your users faster and more reliably?

That’s where DORA metrics can help. They’re your benchmarks in the chaotic world of software development. They provide a clear, no-nonsense snapshot of your team's performance to help you focus on what really matters. 

This isn’t just a health monitor. It's a way to measure and improve your development process. We’re talking about shipping features faster, squashing bugs before they reach users, and turning potential disasters into minor, forgettable hiccups.

Below, we’ll walk you through everything you need to know about DORA metrics to better evaluate (and optimize) your software development processes.

What are DORA metrics?

DORA metrics have become the cornerstone of measuring DevOps performance. The DevOps Research and Assessment (DORA) team—a widely recognized DevOps performance research team inside of Google Cloud—identified them after intense research to find key indicators that distinguish high-performing software teams from the rest.

The DORA team found that these four metrics consistently correlate with software delivery performance and organizational success:

1. Deployment frequency
2. Lead time for changes
3. Change failure rate
4. Mean time to restore (MTTR)

Using DORA metrics helps you make better data-driven decisions for building (and improving) your value stream.

1. Deployment frequency

Deployment frequency measures how often an organization successfully releases code to production. It determines if your team can deliver small batches of work quickly (and efficiently).

High-performing DevOps teams often achieve multiple deployments per day, while lower-performing teams have a lower number of deployments (perhaps monthly or less frequently). The aim is to move towards more frequent, smaller deployments rather than large, infrequent releases.

Increasing deployment frequency leads to lower deployment risk, faster time to market, and more rapid user feedback.

2. Lead time for changes

Lead time for changes (also known as change lead time) measures the amount of time it takes for committed code to run successfully in production. This metric covers the entire process from pull requests to production deployment—including code review, testing, and deployment processes.

Elite performers often achieve lead times of less than one day, while low performers might take weeks or months. A shorter lead time indicates an efficient development pipeline and the ability to respond quickly to changing market demands or user needs.

3. Change failure rate

Change failure rate (CFR) represents the percentage of failed deployments that end in a degraded service and require remediation. It’s an incident management metric used to measure stability. This could range from a full system outage to performance issues that majorly impact users.

Top-performing teams maintain a change failure rate between 0-15%. A high change failure rate indicates possible issues in review processes, integration practices, or deployment procedures.

4. Mean time to restore

Mean time to restore (MTTR) (or mean time to recovery) measures how long it takes to recover from a failure in your production environment. This metric isn't limited to fixing bugs—it includes resolving any incident that impacts end users, from system outages and downtime to severe performance degradation.

High-performing teams can often restore service in less than an hour, while lower-performing teams might take days or even weeks. A low MTTR indicates resilience and the ability to quickly respond to and resolve issues.

These four key metrics work together to provide a complete view of DevOps performance. They strike a balance between speed (deployment frequency and lead time for changes) and stability (change failure rate and MTTR) to draw a holistic picture of the software delivery process.

Now, the goal isn't to achieve perfect scores across all metrics immediately. That’s not possible. Instead, these metrics provide a framework for continuous improvement. The objective isn’t necessarily perfection—it’s progress.

How to implement DORA metrics in your organization

Getting started with DORA metrics in your organization is a journey, not a destination. You’ll need commitment, collaboration, and (often) a major shift in mindset. Here's a roadmap to help you get started:

• Establish a baseline: Start by evaluating your current organizational performance. Gather data on your deployment frequency, lead times, change failure rates, and time to restore service. This baseline will be your starting point for improvement.
• Define your measurement approach: Determine how you'll collect data for each metric. This might involve setting up automated tracking in your CI/CD pipeline or establishing manual logging processes.
• Set realistic goals: Based on your baseline, set achievable targets for each metric and initiative. Remember, improvement is gradual. Aim for steady progress rather than dramatic overnight changes.
• Create a data collection plan: Decide who will be responsible for data collection, how often you'll gather data, and where you'll store it.
• Communicate with your team: Double-check that everyone understands what DORA metrics are, why they're important, and how they'll be measured. Transparency builds buy-in and engagement.
• Start small and scale: Consider starting with a pilot project or team before rolling out DORA metrics across your entire organization. This helps you refine your approach and demonstrate value.
• Review and iterate: Regularly review your metrics and your measurement process. Make adjustments as you learn what works best for your organization. Here are some resources to help you take action:
• A definitive guide to releasing your best software
• Modern DevOps: The Shift to Operating Continuously
• 5 Tips for Fostering a Culture of Product Experimentation
• The Next DevOps Frontier: How 5 Leading Companies Ship Software Faster
• Webinar: Beyond DORA Metrics

How to measure your DORA metrics

Understanding the importance of DORA metrics is just the first step. Now, it’s time to actually measure them—and that’s a whole different hurdle. Many engineering teams use a mixture of in-house methods and third-party tools to track their DORA metrics. Here are a few considerations:

In-house measurement approaches

Many organizations start by cobbling together in-house solutions to track their DORA metrics. These methods may lack precision, but they can provide a starting point for teams looking to improve their software delivery performance (and you have to start somewhere). 

Here are some common approaches:

1. Deployment frequency:
2. Use your CI/CD pipeline logs to count the number of successful deployments to production over time.
3. Set up a simple script to parse these logs and calculate deployment frequency.
4. Lead time for changes:
5. Combine data from your version control system and deployment logs.
6. Calculate the time between code commits and their corresponding production deployments.
7. Change failure rate:
8. Track production incidents or rollbacks in a ticketing system like Jira.
9. Compare the number of failed deployments to the total number of deployments.
10. Mean time to restore (MTTR):
11. Use incident management tools or ticketing systems to log the start and resolution times of production issues.
12. Calculate the average time between incident start and resolution.

These DIY methods can get you started, but they sacrifice precision for simplicity. Many teams use them as a way to track directional improvements rather than exact measurements. And when you’re just getting started, that might be all that matters.

Third-party tools for measuring DORA metrics

These solutions provide more accurate and comprehensive data than in-house methods. Here are some popular options:

1. GitLab CI/CD: Offers built-in DORA metrics tracking for teams using GitLab for their DevOps lifecycle.
2. Google Cloud's DevOps Research and Assessment metrics: Provides DORA metrics measurement for teams using Google Cloud.
3. Sleuth: A deployment tracking tool that measures DORA metrics and provides insights for improvement.
4. LinearB: Offers developer productivity metrics with a focus on engineering efficiency.
5. Jellyfish: Provides engineering metrics and insights to help leaders make data-driven decisions.
6. Waydev: Offers Git analytics and DORA metrics tracking to help engineering leaders improve productivity.

These tools often integrate with your existing DevOps stack to pull data from various sources and provide a comprehensive view of your DORA metrics performance.

The goal of measuring DORA metrics isn't just to have numbers—it’s to use those numbers to drive continuous improvement in your software delivery process. Whether you choose an in-house approach or a third-party tool, the key is to start measuring, set benchmarks, and work consistently towards better performance.

DORA metrics challenges (and solutions)

Implementing DORA metrics can be easier said than done. You might run into a few obstacles along the way, and here’s a bit of advice on how to hurdle them:

• Resistance to change: Some team members may be hesitant about new metrics. Address this by clearly communicating the benefits and involving the team in the implementation process.
• Data accuracy issues: Inconsistent or inaccurate data can undermine your efforts. Invest in reliable data collection methods and regularly audit your data for accuracy.
• Metric obsession: Avoid the temptation to focus solely on improving the numbers. Remember, the metrics are a means to an end—better software delivery—not the end itself.
• Lack of context: DORA metrics alone don't tell the whole story. Always consider them in the context of your specific business goals and circumstances.
• Tool limitations: Your existing tools might not easily provide the data you need. Be prepared to invest in new tools or custom solutions (where necessary) to avoid bottlenecks.
• Silos between teams: DORA metrics require collaboration across development, operations, and other teams. Work on breaking down silos and creating a culture of shared responsibility.

How feature management impacts DORA metrics

Feature management is one of the most powerful tools for improving your DORA metrics. It’s a DevOps practice that allows teams to modify system behavior without code changes. They let you implement conditionals in your code that control the visibility or behavior of features.

Here’s what you can do with feature flags:

• Decouple deployment from release
• Conduct A/B tests and gradual rollouts
• Quickly disable problematic features without rolling back entire deployments
• Personalize user experiences based on various criteria

These functions directly improve DORA metrics by improving deployment safety, speed, and flexibility. Here’s how:

1. Increased deployment frequency: With feature flags, engineering teams can deploy code more frequently because new features can be deployed in a dormant state. This lets you continuously integrate code into the main branch without affecting the user experience.
2. Reduced deployment risk: Feature flags allow for gradual rollouts that let you release features to a small subset of users first. This approach (often called canary releases) helps catch potential issues before they affect the entire user base—and this reduces the change failure rate.
3. Faster recovery time: If a deployed feature causes issues, you can turn it off instantly without needing to roll back the entire deployment. This reduces the mean time to restore metric.
4. Simplified testing: Feature flags let you test in production with real-time user data, leading to more thorough testing and reduced change failure rates.

How real-life companies impact DORA metrics with feature management

Many well-known companies are already demonstrating the value of implementing feature management. Here’s how some of our customers have improved their DORA metrics:

Christian Dior shortens time to market from 15 minutes to instant updates

Christian Dior implemented LaunchDarkly to streamline their feature management process. They shifted from a process that could take hours to one that now takes minutes, and it lets them target features based on geographic location, user segments, and even individual sales associates. This improved their deployment frequency and significantly reduced their lead time for changes.

Atlassian moves faster and continuously delivers software

Atlassian adopted LaunchDarkly to separate code deployments from feature releases (enabling more frequent and safer deployments). Within a year of implementation, one team saw their MTTR improve by 97%.

Jackpocket streamlines regulatory compliance and accelerates mobile app development

Jackpocket leveraged LaunchDarkly to address complex regulatory requirements while maintaining a fast-paced development cycle. They reduced deployment incidents by 90% and increased their deployment frequency from 3 deploys per month to daily deployments. Plus, they decreased their mean time to recovery from 30 minutes to less than 10 minutes.

Coles Transforms the Digital Retail Experience for Millions of Customers

Coles Digital used LaunchDarkly to accelerate their deployment frequency from monthly to multiple times per week. This granular control over feature rollouts reduced deployment risks and enabled quick rollbacks (when needed). This transformation improved their deployment frequency and also led to a lower change failure rate.

Paramount improves developer productivity 100X with LaunchDarkly 

Paramount's implementation of LaunchDarkly helped them go from twice a month deployment frequency to 6-7 times a day. They reduced their time to fix bugs from up to a week to just a day, majorly improving their lead time for changes and mean time to restore. 

Improve your DORA metrics with LaunchDarkly

LaunchDarkly’s feature management platform helps you improve your DORA metrics with feature flags, gradual rollouts, targeting, and experimentation. You can use these tools to deploy more frequently with less risk, respond quickly to issues, and make more informed decisions about feature releases:

• Deployment frequency: Integrate with CI/CD pipelines to deploy code frequently without exposing unfinished features.
• Lead time for changes: Develop and deploy features independently to reduce lead times with adequate approval workflows and scheduling capabilities.
• Change failure rate: Implement gradual rollouts to a small percentage of users to minimize the impact of potential issues with instant kill switch functionality.
• Mean time to restore: Quickly disable problematic features and identify the source of issues with comprehensive audit logs.

Try it for yourself. Start your free trial to see how LaunchDarkly can improve your DORA metrics.