Engineering Metrics

Top 10 tools to measure DORA metrics

October 13, 2024

Amit Zonenfeld
Amit Zonenfeld
Top 10 tools to measure DORA metrics
Example H2

Ready to start?

Introduction

Tracking performance is essential for DevOps teams to optimize both operational efficiency and system reliability. But how do you decide which metrics to focus on? 

The DevOps Research and Assessment (DORA) metrics, developed by Google, have emerged as the gold standard for measuring software delivery performance. DORA metrics help you monitor the productivity of your engineering teams and can detect bottlenecks in your development cycles. 

As DORA metrics have gained traction among engineering managers and developers, numerous tools have emerged to facilitate tracking, measurement, and enforcement of standards. We’ll discuss the top ten tools in this article.

What are DORA metrics?

DORA metrics provide insight into how efficiently your team delivers software by focusing on key aspects like deployment frequency and lead time. Tracking and improving DORA metrics allows teams to streamline their workflows, reduce delays, and enhance overall performance.

The four DORA metrics are:

  1. Deployment frequency – How often your team successfully deploys code to production
  2. Lead time for changes – The time it takes from code commit to running in production
  3. Mean time to recover (MTTR) – The average time to restore service after an incident or outage
  4. Change failure rate (CFR) – The percentage of deployments that lead to production failures

Improving these metrics across teams results in reducing downtime, delivering features faster, and creating a more resilient product.

Top 10 tools to measure DORA metrics

The tools selected for this list were chosen based on their proven ability to effectively support and enhance the four key DORA metrics. Each tool stands out for its ability to integrate with software development pipelines, providing accurate, real-time insights that are crucial for optimizing team performance. 

1. Port

Unlike many tools that are focused solely on visibility or productivity metrics, Port provides a holistic solution. As an internal developer portal, Port integrates with your entire tech stack (Git, CI/CD, incident management, etc.) and offers customizable dashboards to track key metrics, such as DORA, alongside engineering standards. 

Once you’ve begun measuring team performance, Port allows you to dive deeper and track additional metrics such as:

  • Pull request metrics
  • Feature effectiveness
  • Security and compliance
  • Cloud costs and other FinOps

In addition, you get more than visibility — you can turn these insights into actionable solutions within Port’s platform with automations, notifications, alerts, and scorecards. You can implement these solutions directly in your portal to impact the metrics you choose to measure according to your own benchmarks and goals.

2. Swarmia

Swarmia integrates with tools like GitHub and Jira to monitor DORA metrics in real-time. It provides insights into delivery speed and bottlenecks, offering teams a way to track their performance and identify areas for improvement in their development workflows.

Source: Swarmia

3. LinearB

LinearB provides insights into DORA metrics, such as deployment frequency and change failure rate. It integrates with GitHub, Jira, and Slack to help teams monitor performance and streamline their DevOps workflows, offering visibility into key areas of the software development process.

Source: LinearB

4. Jellyfish

Jellyfish provides detailed insights into software delivery performance, tracking key DORA metrics while focusing on workflow efficiency. It’s an ideal solution for engineering leaders looking to optimize team health and productivity.

Source: Jellyfish

5. Minware 

Minware offers data driven insights into DORA metrics by analyzing development and CI/CD activity. Its real-time analytics improve delivery speed and productivity, helping teams reduce cycle times.

Source: Minware

6. Code Climate

Code Climate Velocity emphasizes DORA metrics to improve software delivery performance. By tracking deployment frequency and change failure rates, it helps teams identify bottlenecks and improve overall efficiency.

Source: Code Climate

7. Haystack

Haystack focuses on providing engineering insights, including DORA metrics, to help teams detect bottlenecks and improve delivery speed. It integrates with GitHub and other tools, offering visibility into the health of your development pipelines with real-time metrics and alerts.

Source: HayStack

8. Faros

Faros is an engineering operations platform that helps teams track DORA metrics alongside other key engineering KPIs. It provides a window into engineering data, integrating with tools like GitHub, Jira, and CircleCI to give a full view of software delivery performance.

Source: Faros

9. Waydev

Waydev is an engineering intelligence platform that offers insights into your team’s DORA metrics. It integrates with tools like GitHub, GitLab, and Bitbucket, providing a data driven approach to improve deployment frequency, lead times, and overall engineering performance.

Source: Waydev

10. Uplevel

Uplevel is an engineering effectiveness platform that helps teams track DORA metrics such as deployment frequency and lead time for changes. By analyzing data from tools like GitHub, Jira, and Slack, Uplevel provides insights into team productivity and workflow efficiency.

Source: Uplevel

Conclusion

Measuring DORA metrics helps engineering teams foster a culture of high performance, high quality code, and best-in-class productivity. With a system that gathers DORA metrics, engineering metrics, and standards compliance data in one place, engineering managers and team leads can more easily and effectively launch improvement initiatives, establish best practices, and make developers happy.

If you’re interested in seeing what an internal developer portal can do for your team, we recommend checking out Port’s open demo, where you can see all of this in action.

Previous article

Next article

{{cta_1}}

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

Check live demo

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

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

Let’s start
{{cta_5}}

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

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

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

Let’s start
{{cta-demo-baner}}

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

{{port-for-backstage}}

Apply to join the Beta for Port's new Backstage plugin

Apply for beta
{{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
{{cta-demo}}
{{reading-box-backstage-vs-port}}

Further reading:

Read: What are the technical disadvantages of Backstage?

Compare: Backstage vs. Port

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

You may also be interested in

Building the perfect internal developer platform

Building the perfect internal developer platform

Read more
How to use JQ commands to speed developer workflows

How to use JQ commands to speed developer workflows

Read more
Debugging K8s with K8sGPT in your internal developer portal

Debugging K8s with K8sGPT in your internal developer portal

Read more

Starting with Port is simple, fast and free.

Let’s start