DEV Community

Cover image for How to measure Deployment frequency?
Heloisa Moraes for Codacy

Posted on

How to measure Deployment frequency?

Deployment frequency is one of the most interesting metrics you should use to evaluate your team’s productivity and the overall efficiency of your Engineering performance.

There are four key Accelerate metrics that we will cover in detail:

In this article, we are focusing on Deployment frequency. So keep on reading to know what Deployment frequency is, how we measure it in Pulse, and how your team can start using it to achieve elite engineering performance.

What is Deployment frequency?

In a nutshell, Deployment frequency measures how often code is deployed to production. This metric is correlated with both the speed and the quality of your engineering team.

Reducing batch size is another central element of the Lean paradigm—indeed, it was one of the keys to the success of the Toyota production system. Reducing batch sizes reduces cycle times and variability in flow, accelerates feedback, reduces risk and overhead, improves efficiency, increases motivation and urgency, and reduces costs and schedule growth. However, in software, batch size is hard to measure and communicate across contexts as there is no visible inventory. Therefore, we settled on deployment frequency as a proxy for batch size, since it is easy to measure and typically has low variability.”

Accelerate: The science of lean software and DevOps: Building and scaling high performing technology organizations

What does Deployment frequency measure?

Deployment frequency is a good indicator of teams’ response time, cohesiveness, capabilities, and overall efficiency. It is one of the most interesting speed metrics for an organization to work on to ensure that software is delivered early and often.

This metric analyzes how much value gets delivered to end-users and customers and how quickly your team can provide that value (in the form of bug fixes, new functionality, or other code changes).

How to read Deployment frequency?

On the one hand, a Deployment frequency that is too low indicates that there may be broader issues, like inefficient processes, lack of people, or inadequate team structure. On the other hand, a high deployment frequency shows that your team can quickly provide value and react to feedback or changes.

Your teams’ goal should be to increase your deployment frequency because it means that you are incentivizing your team to deploy more regularly and with smaller changes. Smaller and regular release sizes are easier to understand, and it’s faster to test, deploy and fix issues. More frequent deployments also mean shorter and more effective feedback loops, allowing for faster product iterations.

Deployment frequency in Pulse

Products like Pulse make it easy for your team to know how your Deployment frequency looks like. Pulse connects seamlessly with your GitHub and Jira to give you Deployment frequency and other Engineering metrics out-of-the-box. Your team only needs to focus on making informed decisions to improve results.

How is Pulse measuring Deployment frequency?

Pulse measures Deployment frequency by calculating how often your organization completes a deployment to production or releases code to end-users:

number of deployments per day

Pulse can automatically detect your deployments by picking signals from GitHub, like your Pull Request flow, or by interpreting semantic version tags. If you have a more complex deployment workflow, you can also instrument it yourself and signal a deployment by pushing an event to Pulse’s API.

Deployment frequency inside Pulse
Deployment frequency in Pulse

Pulse takes care of all the details to ensure your metrics are accurate and reliable. For example, Pulse correctly tracks your deployments’ changes even if you squash or rebase the commits when merging a pull request; and it even associates all GitHub teams with the person that commits a certain change, enabling you to explore Deployment frequency and the other metrics per team.

What Deployment frequency should a team have?

The best practice performance level for this metric, published every year on the Accelerate State of DevOps 2021 report:

  • Elite: More than 50% of days have one or more deployments
  • High: More than 50% of months have at least one deployment
  • Medium: More than 50% of semesters have at least one deployment
  • Low: Less than 50% of semesters have at least one deployment

See what's your Deployment frequency

How to use Deployment frequency 

Over time, Deployment frequency should be getting higher, while your team increases the performance level until reaching best practice levels.

Having a high Deployment frequency allows your team to continually receive valuable and actionable feedback and quickly deliver high-quality software.

Causes of a low Deployment frequency

  • Very large changes to be introduced in the code;
  • Shortage of people or a change in the organizational structure (e.g., a senior engineer who left and was not replaced yet);
  • Inefficiencies in the development process (e.g., blocks, dependencies, not using the right tools);
  • Bottlenecks and unnecessary complex routes to production.

How to increase Deployment frequency

  • Implement CI/CD best practices: continuous integration and continuous delivery allow you to increase your software delivery speed.
  • Work on small and self-contained changes: working with smaller versions of changes makes it easier for developers to get feedback faster and resolve issues sooner.
  • Work on reducing your technical debt: an effort to reduce technical debt and remove bugs can help you increase subsequent deployments.
  • Use test automation: incorporating automated tests at every stage of the CI/CD pipeline can help you reduce delivery times since it helps catch issues earlier.
  • Automate code reviews: using automated code review tools like Codacy can help you improve your code quality and save your team valuable time.
  • Use release trains if you are working on larger monoliths: multiple changes are batched together, coordinating changes to be released at the same time.


Deployment frequency is a fundamental metric to analyze and improve the efficiency of your engineering team. In addition, it is a valuable metric to understand the capabilities of your team and how quickly they can provide value to your customers.

Together with Lead time for changes, Time to recover, and Change failure rate, this metric provides valuable insights for your team to achieve full engineering performance.

With Pulse, you can easily measure and analyze the Deployment frequency in your projects and make better decisions.

We also suggest you keep reading about selecting the best metrics with this article: How to determine your goals and metrics to adopt a data-informed culture. After all, there is no single set of metrics that works for all teams, and we’ve crafted a framework to help you find the right metrics for your organization.

Webinar: How to boost your Engineering Speed & Quality with the right Metrics.

Are you looking for ways to deploy faster and more efficiently without compromising code quality? 

Our team leads at Codacy and Pulse will show how you can make the most out of the engineering data already available to you, and empower you to measure all your engineering performance.

Webinar Pulse March 2022

Join us in our Webinar: How to boost your Engineering Speed & Quality with the right Metrics. See you there!

👉 When: March 24th 2022, 11 am CST
👉 Where:

Save me a seat

Top comments (0)