What to Track About Engineering Productivity Besides DORA
DORA's four metrics, deploy frequency, lead time, change failure rate, and recovery time, measure how software gets shipped, but they don't measure whether the work getting shipped is the right work, or whether the team producing it is sustainably paced. Teams that stop at DORA end up with a clean dashboard and a real blind spot.
Vendors Covered in this Article
Disclosure: We may earn a commission if you buy through some links on this page. It doesn't change what we recommend.
Why Deploy Frequency Alone Can Mislead You
A team can have a high deployment frequency, deploying on demand rather than in scheduled batches1, while shipping a stream of small, low-value changes that avoid anything risky enough to matter. Deploy frequency measures throughput of the pipeline, not the value of what's moving through it.
Pair it with a rough sense of what's actually shipping: are deploys clustering around real features and fixes, or around trivial changes that pad the count without moving the product forward. That's a qualitative check, not a number, and it's worth doing periodically rather than assuming a high cadence is automatically healthy. A cadence that looks strong on a dashboard can still coexist with a roadmap that's barely moving, which is exactly the gap the rest of these metrics are meant to catch.
Review Latency Tells You Where Work Actually Waits
The time a pull request sits waiting for a first review is often the largest, most invisible chunk of your lead time, and it's rarely where teams look when lead time creeps up. Code review capacity, not coding speed, is the actual bottleneck in a lot of engineering organizations.
Track time to first review separately from total time to merge. If the gap between them is small, review isn't your bottleneck. If most of the lead time sits in that first gap, the fix is review capacity and process, not asking engineers to write code faster.
Rework Rate: How Often Shipped Work Gets Redone
A feature that ships and then gets substantially rebuilt within a few weeks represents wasted throughput that a deploy-frequency metric counts as two successful deploys. Tracking how often recently shipped work gets significantly reworked, not just bug-fixed, surfaces a different kind of inefficiency than DORA's metrics catch.
This is harder to automate than DORA's metrics, since it usually requires someone tagging a change as rework rather than new work, but even a rough, manually maintained count over a quarter is more useful than not tracking it at all.
Developer Experience Surveys Catch What Dashboards Miss
A short, regular survey asking engineers where they lose time, waiting on CI, unclear requirements, flaky tests, surfaces friction that no pipeline metric captures directly, because the friction happens before code ever reaches the pipeline. Keep it short enough that people actually fill it out, four or five questions, run quarterly.
The value is in the trend, not any single response. A friction point that keeps showing up survey after survey is worth fixing even if no dashboard metric points at it.
Build a Small Set, Not a Scoreboard
Four or five metrics tracked consistently and discussed honestly beat a dashboard with twenty metrics nobody looks at closely. Once a metric becomes something individuals are evaluated on directly, people optimize for the metric instead of the outcome it was meant to represent, which is exactly how deploy frequency turns into a stream of trivial commits.
Use these metrics at the team level to spot where to invest, in review capacity, in test reliability, in reducing rework, not as an individual performance scorecard. That distinction is what keeps the numbers honest.
Reading These Metrics Together Instead of One at a Time
A high deployment frequency next to a rising rework rate usually means the team is shipping fast and correcting course after the fact, worth knowing before you conclude the pipeline is healthy on cadence alone. A long review latency next to a low deploy frequency points at review capacity as the constraint worth fixing first, rather than asking engineers to write code faster.
Look at the set together once a month rather than reacting to any single number in isolation. A single metric moving in a bad direction is often noise, a survey complaint, a cluster of related complaints, or a slow drift across two or three of these at once is the pattern worth actually investigating.
A small metric set alongside DORA could include:
- Review latency, the time a pull request waits for its first review, which often hides the largest share of lead time.
- Rework rate, meaning how often recently shipped work gets substantially rebuilt rather than simply bug-fixed.
- A short, regular developer experience survey asking where engineers lose time.
- The four DORA metrics kept as a baseline for pipeline health and regression spotting.
- A monthly team-level review of these numbers, without using them as individual performance scores.
What Good Looks Like
A sound engineering metrics practice pairs DORA's pipeline metrics with review latency, rework rate, and a short developer experience survey, and uses all of it at the team level to guide investment rather than as an individual scoreboard.
Building The Capability (5-Stage Skill Ladder)
How to Get Started
Disclosure: We may earn a commission if you buy through some links on this page. It doesn't change what we recommend.
Track review latency and rework informally in ClickUp by tagging pull requests and shipped work, before investing in a dedicated analytics tool.
Process Street works well for running the recurring developer experience survey and routing the results to whoever owns acting on them.
Frequently Asked Questions
Should we stop tracking DORA metrics in favor of these?
No, keep DORA. It's a well-established baseline for pipeline health and useful for spotting regressions. The point is to pair it with a small set of metrics that cover what it doesn't, not to replace it with something else that also has blind spots.
How do we avoid engineers gaming these metrics once they're tracked?
Keep metrics at the team level and use them to guide where to invest, not as individual performance scores. Gaming happens when a number determines someone's evaluation directly, so the fix is organizational, not a smarter metric.
How often should we actually review these numbers as a team?
Monthly is usually enough to catch a real trend without over-indexing on noisy week-to-week swings. Reserve a deeper quarterly look for the developer experience survey and for rework rate, both of which move more slowly and need more context to interpret.
Sources
Where we quote a benchmark, we show its source. Other figures in this guide are estimates or general guidance, so check them against your own numbers.
- Deployment frequency by DORA performance cluster (max days between deploys). DORA Accelerate State of DevOps 2024 (Google Cloud), cluster table via Octopus Deploy analysis, 2024.
Related Guides
Blue-Green, Canary or Rolling: Picking a Deployment Strategy
A decision guide for choosing between blue-green, canary and rolling deployments based on your traffic, database and rollback needs, not what's trendy.
Getting a New Engineer to Their First Production Deploy Faster
How to shrink the time between a new engineer's start date and their first production deploy, without cutting corners on access or review.
What 'Zero Trust' Actually Requires From Every Device on Your Network
What zero trust device verification actually requires in practice, beyond the buzzword, and where small teams should start first.
Beyond DORA: Building a Productivity Metric Set Your Engineers Won't Game
A build-versus-buy guide for engineering productivity metrics beyond the four DORA metrics, and how to pick metrics that resist gaming.
The Metrics That Matter Once You've Outgrown DORA
DORA's four keys tell you about delivery, not developer experience. Here's what to add, what to skip, and how to avoid building a dashboard nobody trusts.
Improving Developer Experience Without Buying Another Tool
A practical way to measure and fix developer experience problems, from local setup time to documentation findability, before reaching for new software.