Engineering leadership

Engineering productivity metrics: the 12 worth tracking (and how to read them)

Engineering productivity metrics — four families: delivery, flow, planning and review, twelve metrics on cards

The short version.

  • Twelve metrics in four families cover engineering productivity honestly: delivery (DORA four), flow (cycle time, WIP, backlog age), planning (say-do ratio, velocity confidence), review (pickup time, review quality).
  • Each metric answers exactly one question and hides the others. Read families together, never a single score.
  • Every metric here fails the same way: attached to an individual, it gets gamed. The unit of productivity is the team's system of work.
  • What a "good" number is depends on the family — delivery has published bands, flow only has your own trend, and planning tops out below 100%.

Most pages listing engineering productivity metrics are a vendor's dashboard screenshot with fifteen numbers and no warnings attached. This is the opposite: every metric that earns a place below gets three notes — what it tells you, what it quietly hides, and what a good number actually looks like. The metrics that fail that test (lines of code, commit counts, utilisation) are listed at the end, with the reason they fail.

If you want the process around these numbers — how to stand up a measurement programme without a revolt — that is a separate piece: how to measure engineering productivity. This page is the catalog. For one-line definitions of related terms, the engineering metrics glossary is the companion reference.

The list at a glance

MetricFamilyTells youHidesSource of truth
Deployment frequencyDeliveryHow often production changesChange size, qualityDeploy system
Lead time for changesDeliveryCommit → productionPlanning time upstreamGit + deploys
Change failure rateDeliveryShare of deploys causing failureFailure severityDeploys + incidents
Time to restore serviceDeliveryRecovery speedHow recovery happenedIncidents
Cycle timeFlowStart → finish per itemQueue time before startTracker
Work in progressFlowItems in flightProximity to doneTracker
Backlog ageFlowHow long unstarted work waitsWhether it should be doneTracker
Say-do ratioPlanningCommitments actually deliveredEffort or valueTracker sprints
Velocity confidencePlanningHow stable the forecast base isEstimate honestyTracker sprints
Review pickup timeReviewPR wait before first reviewReview qualityGit provider
Review quality indexReviewGenuine review, not rubber stampsCode correctnessGit provider
Roadmap focusFocusShare of effort on the roadmapWhether the roadmap is rightTracker + roadmap
Diagram: four families of engineering productivity metrics and the data source each is computed from — delivery from the deployment system, flow and planning from the tracker, review from the Git provider

Delivery metrics: the DORA four

Deployment frequency, lead time for changes, change failure rate, time to restore service. These are outcome metrics: they measure what the delivery system produces, not how busy anyone was. The DORA research programme is the only source that publishes comparison bands (elite teams deploy on demand with lead times under a day — check the current DORA report for the exact thresholds), which makes this the one family where "good" has an external definition.

What the family hides: everything upstream of the commit. A team can deploy hourly and still spend 70% of its time on work nobody asked for. And the honesty condition is strict — deploys are witnessed only by the deployment system. We keep a per-tool accounting of what each tracker can actually supply: Azure DevOps, Jira, GitHub, GitLab.

Flow metrics: where work waits

Cycle time (work started → work finished), work in progress (items open and active now) and backlog age (how long unstarted items have waited) come from the tracker, because the tracker timestamps every status change. Their relationship is close to mechanical: hold throughput steady and cycle time rises with WIP. Rising WIP with flat throughput is the earliest visible sign a team is drowning — weeks before delivery metrics notice.

What a good number is: your own trend. Published cycle-time benchmarks are noise because review speed, release cadence and batch size vary by an order of magnitude across organisations. A healthy signal is a flat or falling trend with occasional outliers you can name. The WIP widget, flow and cycle-time trend and backlog age widget exist because these three are cheap to compute and almost never watched.

Planning metrics: can dates be trusted

Say-do ratio — the share of sprint commitments that shipped by sprint end — is the flagship. A sustained 80–90% is healthy; a sustained 100% means commitments are sandbagged, not delivery perfect. It is a forecasting metric: it tells stakeholders whether the team's word can be scheduled around. The deeper guide, including how to chart it honestly, is the say-do ratio post.

Velocity confidence reads the spread of recent sprints: if velocity swings ±60%, any date computed from its average is noise. The velocity confidence widget makes that explicit. What planning metrics hide: effort and value. A team at 100% say-do shipping trivial tickets is not more productive than one at 85% shipping the hard thing.

Review metrics: the queue nobody owns

Review pickup time (PR open → first review) and review quality (genuine approvals and written comments, not instant merges) measure the only queue in engineering that appears on no job description. Review delay is lead-time addition with no offsetting benefit; rubber-stamped approvals delete the safety that review exists to provide. Both are read straight from Git provider records — see the review pickup time and review quality index references.

Good numbers: pickup in hours, not days, with the spread narrowing over time. What they hide: whether the review caught anything — a fast, genuine review that misses a design flaw scores identically to one that catches it. Metrics cannot read code; that stays a human job.

Focus metrics: is effort going where the plan says

The families above measure how work moves; none of them checks which work. Roadmap focus — the share of engineering effort landing on roadmap items versus everything else that interrupted — is the antidote, and it is the number that most often surprises a VP. The roadmap focus widget and the investment allocation view exist for exactly this question. What it hides: whether the roadmap itself was right. Focus measures alignment, not strategy.

The metrics that did not make the list

The full argument for why these fail — and what to do when a stakeholder asks for them anyway — is in measuring engineers without surveillance and DORA metrics without gaming them.

Frequently asked

What are the best metrics for engineering productivity?
A defensible starting set is six numbers read together: deployment frequency, lead time for changes and change failure rate for delivery; cycle time and work in progress for flow; review pickup time for collaboration. No single metric survives being a target — each one can be improved by sacrificing something it does not see, which is why they are read in families.
How many engineering metrics should a team track?
Fewer than most dashboards suggest. Four to six metrics that someone actually reviews each week beat forty that nobody reads. Add a metric only when a real decision is waiting on it, and retire ones that have never changed a decision — a metric nobody acts on is shelf-ware that discredits the useful numbers next to it.
What is the difference between productivity metrics and delivery metrics?
Delivery metrics (the DORA four) measure outcomes: how often code reaches production and how safely. Productivity metrics are the broader set including flow (where work waits), planning (whether dates hold) and review (how collaboration runs). Delivery metrics tell you how the system performs; the others tell you where to look when it does not.
Can you measure individual developer productivity?
You can count an individual’s output, but the number measures the wrong unit. One person’s numbers over one sprint are dominated by which tickets they happened to pick up; ranking people on them invites gaming, and in much of Europe ranking employees this way is a works-council and GDPR problem. Measure the team’s system of work and use conversations for individuals.
Do DORA metrics measure productivity?
Partly. DORA measures the performance of the delivery system — how fast change reaches production and how often it breaks. A team can score well on DORA while building the wrong thing, so pair DORA with planning metrics like say-do ratio and a focus measure to see whether effort is going where the roadmap says it should.
What is a good cycle time for an engineering team?
There is no universal good number — code review speed, release cadence and batch size move it. What matters is your own trend after outliers are excluded. Treat a sudden change in the trend as a question to investigate, not a verdict; the DORA report clusters lead-time performance into elite/high/medium/low bands, but the honest comparison is your team against itself.

One rule keeps the whole list honest: compute each metric from the tool that witnesses its defining event — deploys from the deploy system, waits from the tracker, reviews from the Git provider. That is the architectural premise of Deckgauge: it connects Jira or Azure Boards, GitHub or GitLab, and Azure DevOps Pipelines/Releases, read-only, and labels every proxy as a proxy.