Overview
This page covers what to measure when improving developer productivity, and where measurement goes wrong. It explains two widely used frameworks: DORA’s Four Keys and DevEx (developer experience). It then examines the failure mode they share: metrics that improve on paper while actual productivity stays flat or declines. Understanding Developer Productivity defines developer productivity and organizes it into three levels. This page builds on that foundation: once you know why you measure, the next questions are what to measure and how to avoid its pitfalls.Four Keys (DORA metrics)
The Four Keys are four metrics of software delivery performance identified by DORA (DevOps Research and Assessment), a long-running research program on high-performing technology organizations. Two measure throughput and two measure stability.
A central finding of this research is that throughput and stability are not a
trade-off. High-performing teams deploy frequently and recover quickly while
keeping failure rates low, because the same practices — small changes, automated
testing, continuous integration and delivery — drive both.
Points to note when using the Four Keys
The Four Keys measure the delivery pipeline, not value. In the three levels of Understanding Developer Productivity, they correspond to level 1: they show how efficiently and reliably changes reach production, but not whether those changes were worth building. Pair them with level 2 and 3 perspectives rather than treating them as the whole picture. Note that lead time for changes starts at code commit. The upstream portion — from idea to the start of implementation — is outside its scope, so a short lead time does not mean ideas reach users quickly end to end. The definitions and performance levels are also not fixed. DORA refines metric definitions in its annual reports. The 2024 report added a fifth metric, deployment rework rate: the share of unplanned deployments caused by production incidents. The same report regrouped failed deployment recovery time from stability to throughput. As of 2026, the DORA metrics guide still presents this five-metric model: lead time for changes, deployment frequency, and failed deployment recovery time under throughput, and change failure rate and deployment rework rate under stability. Performance clusters such as “Elite” are likewise derived from each year’s survey data rather than fixed thresholds. Treat published benchmarks as reference points. When measuring, fix your own definitions and prioritize your team’s trend over cross-company comparison.DevEx (developer experience)
DevEx is the day-to-day experience engineers have while doing their work: how it feels to build, test, review, and ship changes in a given environment. Rather than counting output directly, the DevEx approach improves productivity by improving the conditions under which developers work. Research on DevEx organizes the factors that shape this experience into three dimensions.Feedback loops
The speed and quality of responses developers get from systems and people:
builds, tests, CI results, code review, and deployment.
Cognitive load
The amount of mental processing a task requires. Complex systems, unfamiliar
frameworks, and poor documentation all increase it.
Flow state
The state of full immersion and concentration in a task. Interruptions,
unplanned work, and unclear goals break it.
Feedback loops
Slow feedback forces developers to wait or switch tasks, which produces interruptions and delays and accumulates frustration. Fast feedback lets developers learn quickly and correct course while the context is still fresh. To improve feedback loops, work on both tools and processes: shorten build and test times, speed up handoffs between people such as code review and approvals, and streamline the interactions between teams that sit on the delivery path.Cognitive load
Cognitive load is the amount of mental processing required to complete a task. It rises when the codebase is complex, when documentation is missing or outdated, and when developers must learn new tools or domains mid-task. High cognitive load means more time and effort for the same outcome. To improve cognitive load, reduce what developers must hold in their heads: organize code and documentation, remove unnecessary obstacles in everyday procedures, and set up platform teams that provide self-service tooling.Flow state
Flow state is the condition of being fully immersed in a task with focus and energy. Developers who frequently reach flow produce more and report higher satisfaction and growth. The main obstacles are interruptions and delays, followed by lack of autonomy, unclear goals, and unstimulating work. To improve flow state, protect blocks of uninterrupted time: cluster meetings, limit unplanned work, batch support requests, and give developers autonomy over challenging, meaningful tasks.Measuring DevEx
DevEx is measured from two complementary angles. Perceptions capture how developers feel about their work and environment, typically through surveys. Workflows capture how work actually moves through systems and processes, typically through tooling data. Neither alone is sufficient: perceptions catch problems that system data misses, and system data grounds perceptions in facts.
On top of dimension-level metrics, overall indicators — perceived ease of
delivering software, employee engagement, and perceived productivity — serve as
north-star measures of the whole experience.
Goodhart’s law (when a metric becomes the target)
Goodhart’s law states that when a measure becomes a target, it ceases to be a good measure. Metrics are proxies: deployment frequency stands in for delivery capability, and lead time stands in for the smoothness of the development process. When the number itself is rewarded, people find ways to move the number that bypass the capability it was meant to reflect. This is why metrics should drive team improvement, not individual evaluation. Once a metric feeds into performance reviews, optimizing the number becomes rational behavior, and the metric stops reflecting reality. For example, suppose lead time for changes feeds into individual evaluation. Team members start picking up quick, small fixes first and avoiding bugs that need investigation or large refactorings. Lead time gets shorter, but the hard problems stay untouched and technical debt accumulates. Watching multiple metrics together also helps: gaming one metric usually shows up as degradation in another, such as a lower change failure rate paired with a falling deployment frequency.Measurement anti-patterns
The following patterns improve a metric without improving — and often while harming — actual productivity. They share a common root: targeting the number itself instead of the capability behind it.Raising deployment frequency by deploying more often
High deployment frequency is the result of capabilities such as CI/CD automation, small change sizes, and automated testing. Increasing the deploy count without those capabilities raises the change failure rate, increases time spent on incident response, and eats development time with deployment work. Build the underlying practices first, and let frequency rise as a consequence.Improving lead time on paper
Because lead time for changes starts at commit, committing only after all implementation is finished makes the number shorter without making development faster. Coarse commits also make history harder to read and rollbacks harder to perform, and the hidden early phase hides exactly the problems measurement was supposed to reveal. Commit in small steps and let the metric reflect reality. Splitting pull requests more finely than the work requires has the same structure. Mechanical changes that span many files belong in one pull request. Splitting them per file inflates the pull request count while adding split and review overhead. Treat pull request counts as a check on granularity, not a number to maximize. Likewise, moving tests into a separate pull request to keep size down leaves untested code on the main branch and makes forgetting the tests easy. Code and its tests belong in the same pull request.Cutting review time by skipping it
Skipping code review is the fastest way to shorten the review phase and the most expensive. Review catches bugs, raises quality, spreads knowledge, and reduces single-person dependencies. Instead of removing it, remove what makes it slow: smaller pull requests, automated detection of mechanical issues with linters and CI, and balanced reviewer load.Lowering the change failure rate by avoiding deploys
Deploying less often lowers the number of chances to fail. But each deployment now carries more changes, which raises the risk of unexpected interactions, widens the blast radius, and lengthens the time to isolate causes. Reduce the failure rate by making each change smaller and better tested, not by deploying less. Underreporting has the same effect from the other side. When the failure rate is computed from hotfix counts, handling genuine incidents through the normal flow keeps the number low while the failures still happen. The unrecorded failures never surface in retrospectives, so the team loses the chance to improve. Measure correctly first; make the number better second.Targeting survey scores
The same thing happens when DevEx perception metrics become targets. If satisfaction scores are set as goals or tied to the evaluation of teams or managers, respondents start answering more favorably than reality warrants. Scores rise while the problems developers face disappear from view. Use surveys to find where problems are. Rather than competing for high scores, dig into the causes behind low-scoring items and turn them into improvements.Surveying without acting on the results
If surveys keep coming but nothing changes as a result, developers conclude that answering is pointless. Participation drops, and the means of measuring perception stops working. Run surveys only as often as you can act on the results. Then tell respondents what you learned and what you changed.Related pages
Understanding Developer Productivity
The premise of this page: the definition of developer productivity, the three levels, and why measurement matters.
CI/CD
The automation that underpins deployment frequency and lead time, covered as concrete pipeline design.
Code Review
How to shorten review turnaround without skipping review, including tooling and self-review.
Task Breakdown
How to split work into appropriately sized changes — the capability behind small pull requests.