Using Engineering360 to measure DORA metrics

April 22, 2025

Ready to start?

Using Engineering360 to measure DORA metrics

We released Engineering 360 to provide engineering leaders with all the metrics they need to manage their teams and operations efficiently. Our vision was to leverage the data you already have in Port to give you a clear view of your team's performance. We wanted to help you easily answer critical questions like:

  • How are my teams doing?
  • Which team is struggling to resolve incidents?
  • How does this month's deployment frequency compare to last month's?
  • What can I do to improve incident resolution and MTTR?

{{cta-demo}}

But with so many metrics available, it's easy to get lost in the data. From pull request statistics and bug counts to planning forecasts and quality indicators—the depth and breadth can be overwhelming. This leads to a question: Where should you start?

Enter the DORA framework

Researchers at Google introduced the DORA (DevOps Research and Assessment) framework to evaluate the performance of engineering teams. It zeroes in on four key metrics:

Why these metrics? The goal was to measure not just the performance of an engineering organization, but the stability of its software. After all, what's the point of moving fast if the software you build isn't reliable? 

The DORA framework ensures you're balancing speed with stability, so you're not just accelerating—you're doing so responsibly.

Starting with DORA provides a solid foundation. If you're new to tracking engineering metrics, we highly recommend beginning here. These four metrics offer a clear, focused view of your team's performance, helping you identify areas that need attention.

But while DORA metrics offer a solid starting point, collecting and interpreting them isn't always straightforward.

The challenge of tracking DORA metrics

If you’ve tried to do more than measure deployment frequency or implement DORA across teams, you know that gathering and interpreting your software engineering intelligence data can be more complex than it initially appears. The data often needs to be pulled from various sources — Git providers, CI/CD pipelines, task managers, incident management tools — which might seem straightforward but can quickly become complicated.

Defining your metrics

The first hurdle is understanding how you want to measure each metric. Take deployment frequency as an example:

  • What counts as a deployment? Is it a merge to the main branch? A triggered pipeline that deploys code to production? Or simply a commit to the main branch? 
  • If you're assessing deployment frequency per team, do you count deployments of services that a specific team owns? Or do you consider every commit made by team members, regardless of the service?

These questions highlight how significantly definitions can vary based on your tech stack and organizational practices. Without clear definitions, the metrics you gather may not accurately reflect your team's performance.

What’s next?

After establishing a baseline with DORA, you can begin to explore additional metrics that provide more granular insights. For instance, if you're looking to further improve your deployment frequency, consider examining:

  • Time from first commit to pull request created
  • Time to review
  • Time to merge
  • Build duration
  • Build success rate
  • Time to deploy
  • Number of open pull requests
  • Number of merged pull requests
  • And so on…

Understanding the context is just as important as the metrics themselves. For example, you might observe a decrease in deployment frequency alongside an increase in the number of incidents. This pattern could indicate that teams are deploying less frequently due to stability issues.

Turning metrics into action

Once you've gathered your metrics and set your benchmarks—whether using the DORA benchmarks or your own—the next step is to put this information to practical use. Engineering360 is the only engineering intelligence solution that offers integrated surveys and metrics within your IDP, giving engineering leaders a comprehensive, real-time view of their engineering teams’ productivity and satisfaction — and the tool to improve it. 

Here’s how we recommend converting your metrics and insights into real action:

  • Benchmark and assess: Evaluating each team's performance against your chosen benchmarks is a great way to start gauging performance improvements. Industry benchmarks are another way to ensure your teams are performing well and staying competitive.
With Port scorecards, you can evaluate the team performance against your chosen benchmarks 
  • Set up alerts: Consider setting up alerts for team leads or managers when their teams fall below certain thresholds. 
  • Collaborate with your platform engineering team: Work closely with your platform engineering team to develop solutions to the challenges you've identified. For example:
    • Long lead times: If code reviews are taking too long, implement an automation that nudges reviewers after a specific period. See our post on working agreements for more information on how to implement these. 
    • High MTTR: If your mean time to recovery is higher than you'd like, centralizing all incident data in one place can streamline resolution efforts and reduce recovery times.

{{cta_1}}

Using Port to track DORA metrics and more

Engineering 360 is only as powerful as it is because it’s built on top of Port’s internal developer portal, which offers the following features:

  • Unopinionated data model: Unlike other tools, Port isn't opinionated about how you define your metrics. It lets you specify what constitutes a deployment, lead time, or incident based on your organization's unique terminology and practices. You gather data from the tools you already use and analyze it in ways that align with your specific needs.
  • Seamless integration: Because Port connects directly with your tech stack, diving deeper into your metrics is straightforward. You can easily add more information as your needs evolve. You can also use Port to combine these disparate data sources in dashboards, making visualizations more powerful and explanatory.
  • Comprehensive context: Having all your data connected means you get the full picture—not just isolated metrics, but the context that gives them meaning, and access to a feedback loop with developers via surveys.
  • From data to improvement: Port isn't just for tracking metrics; it's also a platform for implementing solutions. With features like surveys, self-service actions, scorecards, automations, and alerts, you can actively work to improve your metrics, not just monitor them
View your open PRs and nudge reviewers directly from your portal homepage

Ready to take the next step?

Follow our guide to start tracking DORA metrics now and see how you can start impacting your engineering performance.

Not yet using Port? Book a demo with us or visit our live demo for more.

{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

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

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

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

{{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 walkthrough of Port

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

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

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

Starting with Port is simple, fast and free.

Let’s start