> ## Documentation Index
> Fetch the complete documentation index at: https://lib.findy.co.jp/llms.txt
> Use this file to discover all available pages before exploring further.

# How to Measure Developer Productivity

> Explains DORA's Four Keys metrics, the three dimensions of DevEx (developer experience), what happens when a metric becomes a target (Goodhart's law), and common measurement anti-patterns.

## 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](https://lib.findy.co.jp/productivity/why-measure.md) 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.

| Metric | What it measures | Category |
| - | - | - |
| Deployment frequency | How often changes are deployed to production | Throughput |
| Lead time for changes | Time from code commit to deployment in production | Throughput |
| Change failure rate | Share of deployments that cause a failure requiring immediate remediation | Stability |
| Failed deployment recovery time | Time to recover when a deployment fails | 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](https://lib.findy.co.jp/productivity/why-measure.md), 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](https://dora.dev/guides/dora-metrics/) 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.

> [card] Feedback loops
>
> The speed and quality of responses developers get from systems and people:
> builds, tests, CI results, code review, and deployment.

> [card] Cognitive load
>
> The amount of mental processing a task requires. Complex systems, unfamiliar
> frameworks, and poor documentation all increase it.

> [card] 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.

| Dimension | Perception examples | Workflow examples |
| - | - | - |
| Feedback loops | Satisfaction with test speed and output Satisfaction with time to deploy to production | Time to produce CI results Code review turnaround time Deployment lead time |
| Cognitive load | Perceived codebase complexity Ease of understanding documentation | Time to get answers to technical questions Manual steps required to deploy |
| Flow state | Perceived ability to focus without interruption Satisfaction with clarity of task goals | Number of blocks of uninterrupted time Frequency of unplanned tasks and requests |

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

> [card] [Understanding Developer Productivity](https://lib.findy.co.jp/productivity/why-measure.md)
>
> The premise of this page: the definition of developer productivity, the three levels, and why measurement matters.

> [card] [CI/CD](https://lib.findy.co.jp/development/ci-cd.md)
>
> The automation that underpins deployment frequency and lead time, covered as concrete pipeline design.

> [card] [Code Review](https://lib.findy.co.jp/development/code-review.md)
>
> How to shorten review turnaround without skipping review, including tooling and self-review.

> [card] [Task Breakdown](https://lib.findy.co.jp/development/task-breakdown.md)
>
> How to split work into appropriately sized changes — the capability behind small pull requests.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.