Reference

Engineering metrics glossary: what each one measures, and what it doesn't

Engineering metrics glossary cover: four cards for delivery, flow, planning and review metrics

The short version.

  • Every engineering metric answers one question. The glossary's job is to keep you from answering the wrong one.
  • Four families cover almost everything: delivery (DORA), flow (cycle time, WIP, backlog age), planning (say-do ratio), review (pickup time, review quality).
  • Each metric is only honest if computed from the tool that actually witnesses its defining event — deploys come from the deploy system, never from a ticket board.
  • Metrics that rank individual engineers measure the wrong unit and are trivially gamed. Measure the system of work.

"Engineering metrics" gets searched millions of times a year and most of what it returns is a vendor dashboard screenshot. This page is the opposite: the definitions, what each metric genuinely tells you, what it quietly hides, and which tool's data it needs — so you can build a small set that answers real questions.

The glossary at a glance

MetricWhat it measuresWhat it doesn'tData it needs
Deployment frequencyHow often changes reach productionWhether those changes were any goodDeployment records
Lead time for changesCommit (or PR) to running in productionBacklog and planning time before the commitGit + deployments
Change failure rateShare of deploys causing a failure needing a fix or rollbackSeverity of the failureDeployments + incidents
Time to restore serviceHow long recovery takes after a bad deployHow the incident was actually handledIncidents
Cycle timeWork started → work finishedTime waiting before work startedTracker transitions
Lead time (flow)Created → delivered, waiting includedHow much effort was inside the elapsed timeTracker transitions
Work in progressItems open and being worked right nowWhether any item is close to doneTracker
Backlog ageHow long unstarted items have waitedWhether they should ever be startedTracker
Say-do ratioShare of sprint commitments actually deliveredEffort or value of the workTracker (sprint history)
Review pickup timeHow long a PR waits before first reviewReview qualityGit provider
Review qualityGenuine approvals, real comments, not instant mergesWhether the code was correctGit provider
Review participationSpread of reviewing across the teamReviewer skillGit provider

Delivery metrics: the DORA four

The four DORA metrics — deployment frequency, lead time for changes, change failure rate, time to restore service — measure the delivery system end to end. Their defining event is reaching production, which only your deployment system witnesses. A tracker board has no deployment data by default; a Git provider holds commits and pull requests but, without a connected deployment record, cannot tell you when anything ran in production. Dashboards that paper over this invent a proxy (a merge is "a deploy") and quietly redefine the metric.

Proxies are not disqualifying if they are labelled — a lead time measured from PR open instead of first commit is still useful, as long as the label says so. We go deeper on this per tool: Azure DevOps, Jira, GitHub, GitLab — each guide covers exactly what that tool can and cannot supply.

Flow metrics: where work waits

Cycle time, work in progress and backlog age come from the tracker, because the tracker records every status transition with a timestamp. The relationship that makes them worth tracking is close to mechanical: hold throughput steady and cycle time rises with WIP — more items in flight means each waits longer for attention. Rising WIP with flat throughput is the earliest visible sign a team is drowning, weeks before anything shows in delivery metrics.

The gap between lead time and cycle time is queue time, and queue time is usually the fixable part: work waiting for refinement, waiting for review, waiting for an environment. The WIP widget and backlog age widget in Deckgauge exist precisely because these two numbers are cheap to compute and almost never watched.

Diagram: three data sources and the metrics each can honestly compute — the tracker sees waits, Git sees code and reviews, the deployment system sees production

Planning metrics: can the dates be trusted

The say-do ratio is the flagship: what percentage of what a team committed to at sprint start actually shipped by sprint end. A sustained 80–90% is healthy — sustained 100% means sandbagged commitments, not perfect delivery. It is a forecasting metric: it tells stakeholders whether the team's word can be scheduled around, which no delivery or flow metric does.

Planning metrics fail when attached to individuals. The moment a say-do number lands in someone's performance review, the rational move is to commit to less — the metric improves while the organisation ships less. Same family, same failure mode as individual velocity rankings.

Review metrics: the queue nobody owns

Review pickup time (PR open to first review) and review quality — genuine peer approvals, written comments, the share of merges that happened suspiciously fast — measure the only queue in engineering that appears on no one's job description. Review delay is pure lead-time addition with no offsetting benefit, and rubber-stamped approvals quietly delete the safety review exists to provide. The Review Quality Index reads these from your Git provider's own records.

Metrics to avoid

For the full argument, see DORA metrics without gaming them and measuring engineers without surveillance.

Where the data lives

One rule prevents most bad metrics: compute each metric from the tool that witnesses its defining event. The tracker sees waits and status transitions. The Git provider sees commits, pull requests and reviews. The deployment system alone sees production. That is the entire architectural premise of Deckgauge — it connects Jira or Azure Dev Boards, GitHub or GitLab, and Azure DevOps Pipelines/Releases, and computes each metric from the source that can actually see it, read-only, with proxy fallbacks labelled as proxies. If a dashboard cannot tell you which source a number came from, it is guessing.

Frequently asked

What are engineering metrics?
Quantitative measures of how software gets built: how fast changes reach production, how much work is in flight, how long reviews take, whether plans survive contact with the sprint. They come from data your tools already generate — the tracker, the Git provider, the deployment system — and they describe the system of work, not the worth of individual engineers.
How many engineering metrics should a team track?
Fewer than most dashboards show. One or two per question you actually act on: are we shipping smoothly (lead time, deploy frequency), are we stable (change failure rate), is work flowing or piling up (WIP, cycle time, backlog age), can our dates be trusted (say-do ratio). A metric nobody has changed a decision because of is decoration, and decoration is what gets measurement programmes cancelled.
What is the difference between cycle time and lead time?
Cycle time is work started to work finished — how long an item was actually being worked. Lead time is request created to delivered, including all the waiting. Lead time is always longer, and the gap between the two is queue time, which is usually where the fixable problem lives. DORA lead time for changes is a third thing entirely: first commit to running in production.
Which engineering metrics should you NOT track?
Output counted per individual: lines of code, commit counts, ticket closes, individual velocity rankings. They measure the wrong unit (people instead of the system of work), they are trivially gamed, and in much of Europe ranking engineers by them runs into works-council and GDPR constraints. Track the flow of work, not the output of named humans.
Where does the data for engineering metrics come from?
Three places, and each sees a different slice. The work tracker (Jira, Azure DevOps Boards) records every status transition — it knows where work waits. The Git provider (GitHub, GitLab) holds commits, pull requests and reviews — it knows what code happened. The deployment system (Azure DevOps Pipelines/Releases, GitLab CI) is the only thing that witnesses production. Most bad dashboards come from computing a metric from a tool that cannot see its defining event.

If you're building a measurement programme, the natural next reads are how to measure engineering productivity and what belongs on a DORA dashboard.