Inside the Workflow Metrics of Elite Dev Teams
DORA metrics aren’t enough on their own. Here's how dev teams can make the leap to elite performance by focusing on pull request size and dev workflow while improving their cycle time.
Since its inception in 2016, the DevOps Research and Assessment (DORA) program has provided dev teams with some great metrics to guide them on their journey to performing at an elite level. But DORA metrics should only be one piece of the puzzle.
Make no mistake, tracking DORA metrics is important and useful – just not for everything that an engineering team strives to do, such as showing how developers directly impact the business bottom line.
However, used in tandem with Elite Engineering Benchmarks, dev teams can start to use DORA metrics to power themselves toward elite workflows. Based on a study of nearly 2,000 dev teams and 4.5 million branches, these benchmarks help guide us toward what the 10% of elite dev teams look like in practice.
Elite workflow metric #1 - Small but powerful pull requests
What’s clear is that elite dev workflows start and end with small pull-request (PR) sizes. In our experience, this is the best indicator of simpler merges, enhanced CI/CD, and faster cycle times.
PR size, rework rate, and deployment frequency all affect cycle times, but PR size continues to present the most significant opportunity for real organizational change.
Luckily, it’s also easiest to focus on reducing PR size. It’s concrete, measurable, and achievable.
Elite teams make less than 105 code changes per pull request (including additions and removals), making them easier to review and safer to merge.
Because small PRs get picked up and reviewed fast, they lower cycle time and positively impact other DORA metrics. There are fewer hand-offs and less idle time. Production blow-ups are smaller, and teams can recover more quickly.
Beyond efficiency and moving work through the development pipeline quickly, low PR pickup and review times also tell a good story about team chemistry. In addition, teams that have a smooth code review process tend to have better code quality.
To help streamline pull request merges, elite teams bring in automation to support PR routing and classification through free tools like gitStream. These dev tools allow teams to systematically decide what pull requests are either low, medium, or high risk and create unique rules for their organization’s specific needs. Hundreds of dev teams are already using these tools to deploy more frequently by programmably not treating all PRs the same.
Elite workflow metric #2 - Daily deployments
If PR size represents the guts of a project, deployment frequency is the heart. Teams should always strive to plan and work in small, manageable, and quickly releasable chunks. Good scoping and planning net out to smaller PR sizes, resulting in a team that is constantly merging and deploying. The more frequent the deployment, the better the organizational cadence and developer experience.
It’s important to note that elite deployment frequency is daily – and anything more than a week suggests the need for critical focus. Daily deployment of code indicates a stable, healthy, continuous delivery pipeline, which can happen quite naturally with lower PR sizes.
Smaller PR sizes correlate with higher test coverage and more thorough reviews (hallmarks of higher deployment frequency and code quality), reducing change failure rates (CFR). It’s also much easier to roll back and fix issues, helping to lower your mean time to restore (MTTR). Cycle times are lower, customers are happy, and so are developers.
Elite workflow metric #3 - Low rework rate
The concept of rework rate (or code churn) can sometimes be confusing. If a dev writes code, the code merges to the main “trunk,” or the release, and it’ll almost always be refactored in time. Elite dev teams maintain a rework rate of less than 8%.
People assume refactoring is bad, but refactoring 6-month-old or 12-month-old code is a good thing.
It’s important to distinguish between rework and refactoring. Refactoring is a process of making preexisting code more efficient. Rework is the bad kind – a repeating pattern in a poorly functioning process. Or the rework could be due to a quality problem; perhaps product or engineering aren’t aligned on objectives?
Unless the code has just been committed, strong refactoring is a healthy sign of a well-functioning team. Teams with lower PR sizes, rework rates, and higher deployment frequency also have more time to focus on refactoring.
How development workflow impacts other metrics
Understanding DORA metrics is important. They do matter, but they’re not enough on their own.
PR size, deployment frequency, and rework rates all affect development workflow, impacting overall productivity and efficiency. Average or even strong dev teams can grow stronger by zeroing in on these key metrics. When they do, other metrics like planning accuracy, CFR, and MTTR often fall in line.
A crucial dimension of the Elite Engineering Benchmarks study is that predictability stems from smaller PRs and shorter cycles. By looking at the key indicators, teams can foresee problems before they come up, and they have the time and space to plan for them. Instead of spending up to three cycles recovering, teams know exactly how long problem-solving will take – if those problems happen at all.
With proper focus and utilization, development workflow metrics can transform organizations. As useful as DORA metrics are, dev teams’ overarching goal should be using better indicators to power them into the elite-performing bracket with a supercharged development workflow.
Want to learn more? Read The Whole Report “What Metrics Make Engineering Teams Elite: A Free Look Inside The Top 10% Of Engineering Orgs”
LinearB analyzed over 2,000 dev teams to create a free, exclusive report tracking what engineering metrics make teams elite. The report goes into detail on:
How elite engineering teams measure their performance beyond DORA metrics.
What makes engineering teams elite in terms of the development lifecycle, developer workflow, and business alignment?
Explore how your team stacks up in terms of metrics like cycle time, deployment frequency, and planning accuracy.
Learn what tools elite software teams use to hit these industry-leading benchmarks.