Blog
/
/
DORA metrics: improving DevOps performance
Internal Developer Portal

DORA metrics: improving DevOps performance

Jul 3, 2024
Netta Borowitsh
Internal Developer Portal

Managing the performance of development teams can often be challenging without a structured approach. One of the most widely used frameworks for defining and measuring the performance of DevOps teams are DORA metrics. 

In this blog, we’ll explore each of the five DORA metrics, their significance, and how they can help your organization improve DevOps performance. We’ll also discuss best practices for implementing and sustaining these metrics to ensure continuous improvement and high-quality software delivery. We will then discuss how they can be measured in an internal developer portal.

Introduction to DORA metrics

DORA metrics are a commonly used measurement framework for evaluating the performance of DevOps teams and the efficiency of software delivery processes. Developed by the DevOps Research and Assessment (DORA) team, these metrics offer a standardized framework for assessing various aspects of software development, allowing organizations to benchmark their performance and identify areas for improvement.

The DORA team, founded by industry experts Nicole Forsgren, Gene Kim, and Jez Humble, conducted extensive research involving 31,000 software professionals over six years. This research identified key metrics that have since become the gold standard for measuring software delivery performance.

Understanding DORA metrics is crucial for organizations aiming to optimize their DevOps practices, providing insights into:

  • How effectively teams are deploying code
  • How quickly teams can recover from failures
  • The overall stability of a team’s software

By leveraging these metrics, organizations can drive continuous improvement, enhance collaboration between development and operations teams, and ultimately deliver higher-quality software more efficiently.

The 5 key DORA metrics

Let's delve into each DORA metric and understand its significance.

1. Deployment Frequency

Deployment Frequency (DF) measures how often an organization deploys code to production. This metric reflects the agility and responsiveness of the development team. High-performing teams deploy multiple times per day, enabling continuous delivery of features and fixes.

  • Elite performers: Deploy on-demand or multiple times per day
  • High performers: Deploy once per day to once per week
  • Medium performers: Deploy once per week to once per month
  • Low performers: Deploy less than once per month

A higher deployment frequency indicates that the team can deliver value to end-users more quickly and adapt to changing requirements rapidly. However, it's important to ensure that frequent deployments do not compromise the quality of the code.

2. Lead Time for Changes

Lead Time for Changes (LTC) is the time it takes from committing code to deploying it in production. This metric highlights the efficiency of the development pipeline and the team's ability to implement changes promptly.

  • Elite performers: Lead time of less than a day
  • High performers: Lead time between one day and one week
  • Medium performers: Lead time between one week and one month
  • Low performers: Lead time longer than one month

A shorter lead time for changes suggests that the team can quickly respond to feedback and iterate on their software, which is crucial for maintaining a competitive edge in the market. To reduce LTC, teams should focus on optimizing their CI/CD pipelines and minimizing bottlenecks.

3. Failed Deployment Recovery Time or Mean Time to Recovery

Failed Deployment Recovery Time (FDRT), previously called Mean Time to Recovery (MTTR) measures the time it takes to restore service after a failed deployment. This metric assesses the team's ability to handle incidents and minimize downtime, which directly impacts user satisfaction and trust.

  • Elite performers: Recover in less than an hour
  • High performers: Recover in less than a day
  • Medium performers: Recover in one day to one week
  • Low performers: Recover in more than a week

A low MTTR indicates that the team can quickly identify and resolve issues, ensuring that users experience minimal disruption. Implementing robust monitoring, alerting systems, and automated recovery processes can help improve this metric.

4. Change Failure Rate

Change Failure Rate (CFR) is the percentage of deployments that result in a failure requiring immediate remediation, such as a rollback or a hotfix. This metric reflects the quality and stability of the software being delivered.

  • Elite performers: Have a failure rate of 0-5%
  • High performers: Have a failure rate of 5-15%
  • Medium performers: Have a failure rate of 15-30%
  • Low performers: Have a failure rate of more than 30%

A lower change failure rate indicates that the team consistently delivers reliable and stable software. To reduce CFR, teams should invest in thorough testing, code reviews, and continuous improvement practices.

5. Reliability

The Reliability metric, added in 2021, assesses the software's operational performance and stability. It includes factors such as availability, latency, performance, and scalability, offering a holistic view of its dependability.

Reliability is critical for customer retention and satisfaction. Organizations can improve reliability by setting performance targets, conducting regular health checks, and ensuring robust incident management practices. Monitoring these factors helps in maintaining high standards and quickly addressing any issues that arise.

Why DORA metrics matter

There’s a reason why DORA metrics have become the gold standard for measuring the performance and efficiency of DevOps teams. In fact, there are at least seven. Let’s take a look at why DORA metrics matter.

1. Objective measurement of performance

DORA metrics offer an objective framework for evaluating the effectiveness of DevOps practices. By providing clear, quantifiable data, these metrics enable teams to assess their performance accurately. This objective measurement is crucial for identifying strengths, pinpointing areas for improvement, and tracking progress over time.

2. Enhanced visibility and transparency

One of the significant benefits of DORA metrics is the enhanced visibility they provide into the software development lifecycle. These metrics offer a clear picture of how code moves from development to production, how often deployments occur, and how quickly issues are resolved. This transparency helps stakeholders understand the health of the software delivery process and make informed decisions.

3. Data-driven decision making

DORA metrics empower organizations to make data-driven decisions. By analyzing these metrics, teams can identify bottlenecks, inefficiencies, and areas that require attention. This data-driven approach ensures that decisions are based on empirical evidence rather than intuition, leading to more effective and strategic improvements.

4. Improved collaboration and communication

Tracking DORA metrics fosters better collaboration and communication among development, operations, and other stakeholders. These metrics provide a common language for discussing performance, aligning goals, and addressing challenges. Improved communication and collaboration lead to a more cohesive team and a more efficient software delivery process.

5. Enhanced customer satisfaction

Ultimately, the goal of tracking DORA metrics is to deliver better software faster and more reliably. By optimizing deployment frequency, reducing lead time for changes, minimizing mean time to recovery, and lowering change failure rates, organizations can enhance the quality of their software. This leads to higher customer satisfaction, as users experience fewer disruptions, quicker updates, and more reliable services.

6. Competitive advantage

Organizations that can deliver high-quality software quickly have a distinct advantage. DORA metrics help organizations stay ahead by continuously improving their DevOps practices. High-performing teams that leverage these metrics effectively can outpace competitors by responding to market changes swiftly and delivering superior products.

7. Continuous improvement

DORA metrics are not just about assessing current performance; they are also about fostering a culture of continuous improvement. By regularly monitoring these metrics, teams can set benchmarks, track progress, and strive for incremental improvements. This continuous improvement mindset is essential for maintaining high standards and adapting to evolving challenges.

Implementing DORA metrics in your DevOps team

DORA metrics, along with other engineering productivity metrics as well as developer experience metrics, are an important tool for engineering managers who want to “turn on the light” with data about their engineering. These metrics can be measured in various tools, but it’s important to unify them in one place. This can happen in a Software Engineering Intelligence tool, and also, in an internal developer portal

Measuring DORA metrics in an internal developer portal, along with other engineering metrics, presents a benefit in that the portal, though developer self-service, ability to drive better standards compliance etc, is both the tool for measuring DORA metrics and the tool to implement programs to drive change and improve them.

Implementing DORA requires a strategic approach to integrate these metrics into your workflows and culture. Here’s how to effectively implement DORA metrics in your DevOps team.

1. Define clear goals

Start by establishing clear goals for what you want to achieve with DORA metrics. These goals should align with your organization's broader objectives and could include improving deployment frequency, reducing lead time for changes, minimizing mean time to recovery, and lowering change failure rates. Having clear goals helps in focusing efforts and measuring progress effectively.

2. Select appropriate tools

Choose the right tools to capture and analyze DORA metrics. Many CI/CD platforms, like Jenkins, CircleCI, and GitHub Actions, offer built-in capabilities to track these metrics. Additionally, Software Engineering Intelligence platforms provide deeper insights and visualizations. Internal developer portals can consolidate data from various tools, offering a unified interface for tracking and visualizing DORA metrics. The internal developer portal ties the measurement to actual action plans to improve DORA metrics, since productivity can be improved through a better developer experience driven by the portal (using self-service), standards and reliability can be promoted through the portal’s scorecards and initiatives and certain behaviors, such as quick reviews and process improvements, can also be achieved through the portal.

3. Automate data collection

Automate the collection of DORA metrics to ensure accuracy and consistency. Manual data collection can be error-prone and time-consuming. By automating this process, you can continuously monitor your metrics without disrupting your team’s workflow. Automation also provides real-time data, enabling quicker response to issues and more informed decision-making. This can be easily set up in an internal developer portal.

4. Establish baselines and benchmarks

Before making any changes, establish baselines for each DORA metric to understand your current performance levels. Once you have these baselines, set benchmarks for what you consider to be elite, high, medium, and low performance. These benchmarks will help you track progress and measure the impact of your improvement initiatives.

5. Integrate metrics into workflows

Integrate DORA metrics into your regular workflows and review processes. This can be done through dashboards that display real-time data, regular reports, and team meetings where metrics are discussed. By making these metrics a part of your daily routine, you can keep the team focused on continuous improvement. These dashboards can be prepared, by persona, in an internal developer portal.

6. Foster a culture of continuous improvement

Encourage a culture where metrics are used for continuous improvement rather than as punitive measures. Use the data to identify areas for growth, celebrate successes, and learn from failures. This positive approach helps in fostering a growth mindset within the team. A weekly meeting examining these metrics, in a common view in the portal, and strategizing how to  drive change to improve them, can be a first step in fostering such a cultural change.

7. Iterate and improve

Regularly review your DORA metrics and adjust your strategies based on the insights gained. Continuous iteration is key to improving your DevOps performance. As your team becomes more familiar with these metrics, you’ll be able to refine your processes further and set more ambitious goals.

Best practices for sustaining DORA metrics

Once you’ve implemented DORA metrics within your DevOps team, the next challenge is to sustain and continuously improve these metrics over time. Here are some best practices to help you maintain high performance and derive ongoing benefits from DORA metrics.

Regular monitoring and reporting

Consistent monitoring and reporting of DORA metrics are crucial for sustaining performance. Set up dashboards to display real-time data and generate regular reports for review. Use these insights to track progress, identify trends, and address issues promptly. Regular monitoring helps keep the team informed and aligned with performance goals.

Encourage continuous feedback

Create a feedback loop where team members can share their insights and experiences related to DORA metrics. Encourage open discussions about challenges and successes in regular meetings or retrospectives. This continuous feedback helps in identifying potential improvements and fosters a culture of transparency and collaboration.

Invest in training and development

Continuous learning is essential for sustaining high performance. Provide ongoing training and development opportunities for your team to stay updated with the latest DevOps practices and tools. Encourage team members to attend workshops, conferences, and online courses. Well-informed and skilled team members are better equipped to improve and sustain DORA metrics.

Automate wherever possible

Automation reduces manual errors and frees up time for more strategic tasks. Automate as many aspects of your DevOps processes as possible, including testing, deployment, monitoring, and reporting. Automation ensures consistency, speed, and accuracy, all of which are critical for maintaining high DORA metrics.

Focus on incremental improvements

Instead of aiming for drastic changes, focus on incremental improvements. Small, consistent enhancements can lead to significant long-term gains. Regularly review your processes, identify areas for improvement, and implement changes gradually. This approach minimizes disruption and allows the team to adapt smoothly.

Prioritize code quality and testing

High deployment frequency and low lead time for changes should not come at the expense of code quality. Prioritize thorough testing and code reviews to ensure that changes are stable and reliable. Implement automated testing and continuous integration to catch issues early and maintain a high standard of code quality.

Foster a culture of collaboration

Effective collaboration between development, operations, and other stakeholders is essential for sustaining DORA metrics. Promote a collaborative culture where team members work together towards common goals. Use tools and practices that facilitate communication and coordination, such as DevOps platforms, chat integrations, and regular sync meetings.

Celebrate successes

Recognize and celebrate the team’s achievements in improving and maintaining DORA metrics. Acknowledge individual and team contributions in meetings, through awards, or other forms of recognition. Celebrating successes boosts morale and motivates the team to continue striving for excellence.

Conclusion

Understanding and implementing DORA metrics is essential for optimizing your DevOps performance. By evaluating your organization’s specific needs and integrating these metrics into your workflows, you can gain valuable insights into your software delivery processes. This enables you to enhance productivity, improve collaboration between teams, and ensure consistent, high-quality software delivery. An internal developer portal is a great first step to both measure DORA metrics and be able to create the actions plans to improve them.

{{cta}}

Book a demo right now to check out Port's developer portal yourself

Book a demo
{{jenkins}}

It's a Trap - Jenkins as Self service UI

Read more
{{gitops}}

How do GitOps affect developer experience?

Read more
{{ebook}}

It's a Trap - Jenkins as Self service UI. Click her to download the eBook

Download eBook
{{cyberark}}

Learning from CyberArk - building an internal developer platform in-house

Read more
{{dropdown}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start

Contact sales for a technical product walkthrough

Let’s start

Open a free Port account. No credit card required

Let’s start

Watch Port live coding videos - setting up an internal developer portal & platform

Let’s start

Let us walk you through the platform and catalog the assets of your choice.

I’m ready, let’s start