# Using Metrics to Achieve a Good Deployment Frequency | LinearB Blog

> In this post, we’ll cover what deployment frequency is. Once we see it’s importance, we’ll discuss how to improve it.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._

[Blog](https://linearb.io/blog)

/

Using Metrics to Achieve a Good Deployment Frequency

# Using Metrics to Achieve a Good Deployment Frequency

![Photo of Oscar Jite-Orimiono](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/logo-mark-lg?_a=BAVMn6ID0)

By [Oscar Jite-Orimiono](https://linearb.io/blog/deployment-frequency#oscar-jite-orimiono)

|

September 12, 2022

![deployment_frequency_1_ad85876eec](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/deployment_frequency_1_ad85876eec?_a=BAVMn6ID0)

Metrics, metrics, metrics—love them or hate them, in the world of software engineering, they’re here to stay.

To get an accurate measure of how much your system is improving, or not improving, you need to track [the right set of metrics](https://linearb.io/blog/dora-metrics/) that align with your business and development goals.

One important aspect of DevOps is the continuous delivery of value to end users. In this post, we’re looking at deployment frequency. This metric tracks how much value teams can deliver to the users. We also will cover how to measure it and learn why it’s important. Furthermore, we’ll look at corresponding metrics that can contribute to achieving a good deployment frequency.

## **Table of Contents**

* [What Is Deployment Frequency?](#what)
* [How to Measure Deployment Frequency](#measure)
* [Importance of Deployment Frequency](#importance)
* [How to Improve Deployment Frequency](#improve)
* [Corresponding Metrics](#metrics)
* [Start Tracking Deployment Frequency in Minutes](#tracking)

## **What Is Deployment Frequency?**

Deployment frequency is how often new code changes are deployed to production. It’s a measure of a team’s speed and agility. This metric tracks how quickly teams can release new features or fixes.

Elite and high-performing teams have the ability—and capacity—to make multiple deployments in a day, on-demand.

## **How to Measure Deployment Frequency**

Engineering teams measure deployment frequency by simply counting how many times they make deployments during a particular period. This metric is very easy to measure. Teams can choose to measure deployments per week or per day.

So, in a month, suppose your team deploys five times in the first week, seven times in the second, nine times in week three, and three times in the final week. In this case, the deployment frequency is six deployments per week.

![deployment frequency](https://assets.linearb.io/uploads/deploy-frequency.png)

It’s important to note that deployment frequency covers every type of code change made. It can either be a new feature or a quick fix.

### **What Is a Good Deployment Frequency?**

Deployment frequency is one of the[ DORA metrics](https://linearb.io/blog/dora-metrics/) chosen by Google’s research team after studying thousands of software engineering companies in a six-year program. According to the DORA team, high-performing teams make between one deployment per day and one per week. The elite performers, on the other hand, deploy on-demand multiple times in one day.

![Deployment frequency with engineering benchmarks from LinearB](https://assets.linearb.io/uploads/DeployFreq.png)

So, if your team is making deployments once in a month or once in six months, you’re in the low-performers section and must make the necessary improvements to push that number up.

## **Importance of Deployment Frequency**

As we’ve seen, deployment frequency is a DORA metric, and engineering teams that perform well across these metrics will see record-high levels of success.

Deployment frequency is usually the first metric teams measure. It’s also the easiest, as you’re only counting the number of times you make code changes and keeping track of that total over time. This metric helps measure your teams’ productivity and agility—that is, how quickly you can release new features or fix issues.

![Engineering benchmarks chart](https://assets.linearb.io/uploads/benchmarks-chart-1024x670.png)

Want to learn more about being an elite engineering team? [Check out this blog](https://linearb.io/blog/engineering-metrics-benchmarks-what-makes-elite-teams/) detailing our engineering benchmarks study and methodology.

## **How to Improve Deployment Frequency**

Engineering teams want to deploy as often as possible. This is the goal—quick, high-quality code. The faster you deploy, the more value you can deliver to the users.

Here are some best practices that can improve your deployment frequency:

* Build [automated CI/CD systems](https://linearb.io/blog/best-ci-cd-tools/) into your delivery pipeline to handle things like testing, deployment, and monitoring.
* Reduce the deployment size. Make small changes at a time—this reduces the risk of deploying bugs. This way, the developers understand the cause of any failure and can quickly roll back those changes. Also, the developers who write the code are in the best position to understand any subsequent failure and keep them together through to the deployment phase.
* Have all the processes in place, tools ready, and permissions needed in the development environment.
* Set goals such as how often you want to deploy in a week. Have an attainable target and work toward it. Consider your team’s capacity to deliver as well.

## **Corresponding Metrics**

We’ve seen that deployment frequency is how many times code changes are deployed to production. Now, simply counting the number of deployments, while good, will still lack some useful elements. There are several metrics that contribute to the improvement of the deployment frequency.

### **Cycle Time**

[Cycle time](https://linearb.io/blog/cycle-time-measuring-and-improving-team-process/) is how long it takes code to move from development to deployment. It starts from the first commit and ends at creating a pull request. This is also a DORA metric. It’s often measured with mean lead time for changes or change lead time. The change lead time spans the period from development to when the code is ready for deployment.

Deployment frequency is how often you make changes, and cycle time is how long it takes to deliver those changes to production. Cycle time is also a productivity or speed metric. It measures the agility of a team. Elite and high-performing teams have their cycle times fall between one day and one week. Low cycle times mean a higher deployment frequency.

![cycle time benchmarks](https://assets.linearb.io/uploads/cycle-time-benchmarks-1024x819.png)

Cycle time contains four phases that serve as submetrics: coding time, or the period where the changes are developed and a pull request is made; pickup time, or how long it takes to acknowledge the pull request; review time, or the place the code reviews are done and the code is made ready to merge into the main branch; and the last phase is deployment time, or when the code is released.

Does the pull request sit for a week before the review starts? Or does the review process take too long? LinearB will help you identify where you’re wasting time across these four phases of cycle time. Finding and eliminating the cause of these delays will increase your deployment frequency.

### **Code Coverage**

[Code coverage](https://linearb.io/blog/code-coverage-types/) is the percentage of code that’s covered by tests. It’s how many lines of code your CI/CD system covers during testing. Testing a high percentage of your code increases the likelihood of finding bugs and broken code. You want to deliver frequently, and you also don’t want to frequently deliver bugs.

There are four types of code coverage, and we’ll see them one after the other.

* Line coverage—this is a measure of the percentage of the total number of lines of code that the test executes.
* Statement coverage—this measures how many statements from the code the test covers.
* Function coverage—this covers how many functions in your code are tested.
* [Branch coverage](https://linearb.io/blog/what-is-branch-coverage/)—this shows if all branches in a codebase are covered in the test.

Code coverage increases a team’s confidence to deploy frequently, without delay, and helps them catch bugs early in the development process so releases don’t have to be postponed as much.

## **Start Tracking Deployment Frequency in Minutes**

Software engineers need to clearly assess their performance and see what areas in their software delivery process need improvement.

If you can measure it, you can track it over time, and this will show how well your team is progressing toward their goals.

The first metric engineering teams are likely to measure is the deployment frequency. The ability to make frequent deployments is key to delivering a steady flow of value to the users. But, in the quest for continuous delivery, code quality cannot be overlooked, so maintain good practices.

LinearB can help deliver all these metrics and more. We make use of a custom metrics dashboards to get visibility into your teams’ efficiency and compare their performance with known industry standards like the [DORA metrics](https://linearb.io/dora-metrics/). You can easily integrate LinearB into your existing management tools. [Get started with our free account for teams <8](https://linearb.io/get-started/) today, or schedule a [demo](https://linearb.io/get-started/) if you want to measure deployment frequency across multiple teams.

[![datadriven engineering starts with DORA metrics](https://assets.linearb.io/uploads/DORAMetrics-1024x497.png)](https://linearb.io/get-started/)

LinearB provides DORA metrics right out of the box so you can discover your DORA metrics in minutes. [Get started today!](https://linearb.io/get-started/)

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

## Your next read

[![Cover image for AI ROI comes from measuring engineering outcomes on day one](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_ROI_comes_from_measuring_engineering_software_security_2400x1256_2c5eae0862?_a=BAVMn6ID0)](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Eng. Metrics

[AI ROI comes from measuring engineering outcomes on day one](https://linearb.io/blog/kraken-nik-sudan-measure-ai-roi-engineering-outcomes)

Kraken Engineering Operations Lead Nik Sudan details how to establish day-one data infrastructure to accurately measure AI ROI. Discover why raw token adoption...

[![Cover image for AI is rebuilding software delivery from SDLC to ADLC](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_AI_rebuilding_software_delivery_2400x1256_3fd5887e75?_a=BAVMn6ID0)](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation)

Eng. Metrics

[AI is rebuilding software delivery from SDLC to ADLC](https://linearb.io/blog/sdlc-to-adlc-agentic-software-delivery-transformation)

Discover how engineering organizations are transitioning from the traditional SDLC to an Agentic Development Lifecycle (ADLC). Learn why rising token costs...

[![Cover image for 8 million pull requests reveal where engineering productivity breaks down](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_8_million_pull_requests_2400x1256_03724bfbb2?_a=BAVMn6ID0)](https://linearb.io/blog/8-million-prs-engineering-productivity)

Eng. Metrics

[8 million pull requests reveal where engineering productivity breaks down](https://linearb.io/blog/8-million-prs-engineering-productivity)

8.1M pull requests reveal the gap between AI adoption and engineering impact, and why code review is the bottleneck blocking real productivity gains.

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Using Metrics to Achieve a Good Deployment Frequency",
  "url": "https://linearb.io/blog/deployment-frequency",
  "author": {
    "@type": "Person",
    "name": "Oscar Jite-Orimiono"
  },
  "datePublished": "2022-09-12T08:00:00.000Z",
  "dateModified": "2022-09-12T08:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1720000000/deployment_frequency_1_ad85876eec.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "In this post, we’ll cover what deployment frequency is. Once we see it’s importance, we’ll discuss how to improve it.\n"
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)