Knowing your deployment frequency helps understand the rate at which you're delivering value to customers. With the best teams deploying on a daily basis, this is a key North Star Metric to help keep your team on track and delivering.
One of the biggest challenges engineering teams encounter is tracking Deployments in a scalable, standardized method. This article will help you answer how to track deployments in a scalable and standardized method throughout your organization.
Initial Questions to Ask
What action do you consider a 'deployment'?
Do all teams adhere to this approach? Which teams don't?
How consistent are your deployment processes across services?
Most teams will have some hybrid approach to deployments. Some services using a legacy system while others use a nice continuous deployment pipeline. While a standardised system is always preferable, here are some criteria to consider when selecting your choice of measurement.
Criteria to Consider
What actions are immediately available to track deployments?
What actions do we need to implement to track them more accurately?
We always suggest taking a step-by-step approach to tracking deployments. Try to identify the most common pattern for deployments and use that as a starting point. Once you have that in place you can begin to standardize and track more of your deployment processes (tips on how to do this below)
Calculating Deployment Frequency
There are a few methods you can calculate deployments:
Git Tags (Recommended)
PR Merged to 'X' Branch
PR with 'X' Label
PR contains 'X' Text
These options are meant to be flexible enough to handle your needs and help you standardise your data into Github as your source of truth. You can also adjust your Deployment Frequency Tracking on a repository-by-repository basis to give you complete control over your hybrid system.
Best Approach: Git Tags
At Haystack, we recommend using Git Tags as the standardized method of tracking your deployments. Git tags are a default attribute of git and have a few benefits over other methods:
Git tags live together with your code. Finally, a source of truth.
Easy to standardize across teams, projects, repositories.
No data lock-in. Haystack doesn't own the data, you do!
Easily integrated with CI tools like Jenkins, Github Actions, Circle CI, etc.
Complete control. You control when, how, and what system tags your releases.
As long as the whole organization is using Git, it can be standardized across all teams regardless of the tools they use.
Can it support different environments?
Git tags can be customized like
v1.2.3-staging. You can then customize your deployment tracking to only count the tags you care about! In this case, the
Pro Tip: Flexibility is great, but makes it harder to standardize across teams. Even if different teams use different conventions, Haystack can support customized rules for each team allowing to track deployments accurately.
How much does it cost to implement the process?
Regardless of the organization's scale, the cost is minimal and generally considered best practice. You should tag your releases for easier deployment management, rollbacks, and more.
Automated Tagging: Takes a few lines of code in your CI process.
What about mobile teams? Won't that be hard to track?
Mobile teams can sometimes be blocked by external factors such as App Store reviews/releases. In this case, your deployment frequency might be bi-weekly. In this case, you have two options:
Tag Releases after App Store Release
Tag Releases when merged into production
While mobile teams are blocked in their release cadence, iteration speed is still hugely important. From that respect, using merged into production as an alternative to App Store releases may give you a better indication of development velocity.
Haystack has worked with 100s of organizations from a few engineers to 1000s of engineers scale. We have seen git tags method working for all of their needs regardless of the size of the company.
We would recommend using git tags as a way to measure your deployments.
Check the following blogs: