Skip to content
Flow metrics & forecasting

DORA Metrics for Small Teams: What to Track First

By Sebastiaan Jansen · · 17 min read

DORA metrics are four delivery measures: how often you deploy, how long a change takes to reach production, how often a change fails, and how long it takes to restore service. People searching for dora metrics usually want those four, not a maturity grade. A small team should track deployment frequency and lead time for changes first. Both come from git and a deploy log, and together they show whether finished work is getting out the door.

The other two only become useful once the team shares a definition of "failure" and has enough incidents to read. A team of five with two production incidents in a quarter won't learn anything from a recovery-time chart. They can learn that most changes sit for nine days before anyone ships them.

What DORA metrics are

The DORA research program studies how software teams deliver. When people say DORA metrics, they usually mean these four:

  • Deployment frequency: how often changes reach production.
  • Lead time for changes: how long a commit takes to reach production.
  • Change failure rate: the share of production changes that cause a failure you then have to fix.
  • Failed deployment recovery time: how long it takes to restore service. Older write-ups call this mean time to restore.

Frequency and lead time describe speed. Failure rate and recovery time describe stability. A team can be fast and fragile, or slow and careful, so any one of these numbers will mislead you if you read it alone.

The four cover committed code on its way to a user. They say nothing about whether the ticket was worth doing, so keep them next to product outcomes.

What counts as a deployment

Write the definition down in one sentence and stick to it. A deployment is a change that reaches the production environment users hit. A merge to main that auto-deploys counts. A merge that waits for Thursday doesn't count until Thursday. A staging-only migration doesn't count. A flag turned on for 5% of users counts if that's how you ship; a flag only staff can see doesn't.

If you own several services, count deploys per service. A team total of 40 can hide a billing service that hasn't shipped in six weeks.

Write the sentence before you build a dashboard. For example: "A production deploy is a successful run of the production pipeline for this service, including a rollback that changes what users run." That line settles three arguments. Failed pipeline runs don't count, a rollback does, and a config change shipped through the same pipeline counts the same as an application change. If config ships through a different tool, say so, or the chart will miss changes that move production.

A canary that stays at 5% for two days is one deployment, counted when the flag or the pipeline first exposes users. It doesn't become a new deployment every time the percentage ticks up. Expanding from 5% to 50% to 100% is still the same change unless a new commit goes out with it. Counting each ramp as its own deploy inflates frequency and makes lead time look shorter than the wait users actually had.

What counts as lead time for changes

Lead time for changes starts when the change is committed and ends when that commit is running in production. It isn't the wait from "a customer asked" to "the customer has it." That longer span answers a different question, and the difference is close to the one between cycle time vs lead time.

Start the clock at the first commit on the branch, or at the commit that lands on the release branch. Stop it at the production deploy that contains that commit. If you ever move either point, label the chart.

Pick one start and keep it. Starting at the first commit on the branch includes coding time after the branch opens. That's real wait if nobody else can review yet, and noise if the author parks a stub commit on Monday and writes the change on Thursday. Commit-to-trunk ignores that coding time and measures review plus release. Either is defensible, but mixing them across services makes the comparison meaningless. Put the sentence on the chart.

Cherry-picks and squashes break naive scripts. A cherry-pick gets a new hash, so matching on hashes never finds the original branch commit in production. Attribute lead time to the original commit time, or a three-week branch looks like a two-hour change. Squash merges have the same problem, because the squash timestamp is the merge. Store the pull request's first commit time next to the deploy.

Which of the DORA metrics to track first

Track deployment frequency and lead time for changes for two or three months. Add change failure rate once "failure" has a definition and someone can mark a failed change without calling a meeting. Add recovery time when you have enough incidents that a median means more than one bad afternoon.

Why the first pair is enough to start

Both numbers already live in git, CI, and the deploy tool. Read them on the same day each week.

A monthly batch shows up as low deployment frequency and long lead time for changes. Smaller pull requests and a more frequent release train show up in those same two numbers within a month. If the median change waits four days for review and then sits on a biweekly train, recovery time isn't what you should be working on.

What to leave alone for now

Skip composite grades, team-versus-team boards, and targets copied from a conference talk. Compare the team with its own recent history. A B2B app on a weekly train is a different system from a consumer app that deploys on every commit.

Skip failure rates in any week where you can count the deploys on one hand. Two failures out of four deploys is noise. Wait until the volume is high enough that one bad Friday can't rewrite the quarter.

Leave the four-number scorecard for later, even if an executive asks for the dora metrics as one grade. A blended grade hides the one split that changes what you do next: commit-to-merge versus merge-to-production. On a single lead-time tile, a team with a six-hour review and a ten-day train looks the same as a team with a ten-day review and a six-hour train, even though they need opposite fixes.

How to measure deployment frequency

Count production deployments per week for each service. Report the median week over the last eight weeks, plus the longest gap between production deploys. A team can average four deploys a week and still leave one service untouched for 18 days, because every one of those deploys was the frontend.

Batch size sits behind the count. Ten deploys of one pull request each is a different system from ten deploys that each bundle unrelated fixes. If your tool shows pull requests per deploy, put that next to the frequency. If it doesn't, sample five deploys a month by hand.

Deployment frequency is throughput measured at the deploy boundary. Throughput vs cycle time covers the same pair on the ticket board. Frequency can rise while ticket throughput stays flat if you're shipping the same tickets in smaller slices, so read both before you treat a busier pipeline as more delivery.

A Friday count you can do by hand

You don't need a platform to start. For one service:

  1. Export the production deploy log for the last eight weeks. Keep timestamp, git SHA, result, and who or what triggered it.
  2. Drop failed runs that never changed what users run. Keep rollbacks that did.
  3. Bucket the rest by week, using the same week boundary every time. Monday 00:00 in the team's timezone is fine if you write it down.
  4. Count deploys for each week. Then take the median of those eight weekly counts, not the average of all deploys divided by eight. A release week with 15 deploys shouldn't erase seven quiet weeks.
  5. Sort the timestamps and record the longest gap. The gap is what catches a forgotten worker, a frozen mobile client, or a service nobody owns on Fridays.

Do this for each service before you add them together. The per-service gap is the number you act on.

If the log is messy, fix the log instead of estimating. A chat message that says "shipped billing" with no SHA can't be reconciled later. All you need is for the pipeline to write the SHA and the result to the same place every time. A shared spreadsheet with those two columns beats a dashboard that guesses.

Read the deploy list before you set a floor. If the code hasn't been touched, the gap is demand. If merges are waiting on an older production SHA, the gap is a queue. A monthly bundle, a missed migration window, and a checklist only one person knows are different queues, and an empty weekly deploy fixes none of them.

How to measure lead time for changes

For each commit that reached production, subtract the commit time from the deploy time. Report the median and a high percentile, not the average. One branch that sat for 40 days will hide a team that otherwise ships in two. Put the sample size next to the median.

When you can, split the duration into two waits:

  1. Commit to merge: coding, review, and rework on the branch.
  2. Merge to production: the release train, a freeze, a manual checklist, or a queue behind someone else's migration.

A long first wait points at review and batch size. A long second wait points at the release process. Smaller pull requests shorten the first. A more frequent train or a shorter checklist shortens the second.

This number overlaps with cycle time. Cycle time usually runs from when someone starts a ticket until the ticket is done, and "done" can come before production. Lead time for changes starts at the commit and ends in production. A ticket can clear the board in two days and then wait ten more for the train. Track both, and don't rename either one to make a slide line up.

One change, timed

The durations below aren't targets. They show which clock to read.

  • Monday 11:40: first commit on a branch that adds a tax line to the invoice PDF. The clock starts. Later commits that afternoon are part of the same change.
  • Wednesday 15:10: first review comment, about a day after the pull request opened. That queue shrinks when reviewers have a daily slot.
  • Thursday 09:40: the branch merges. Commit-to-merge is roughly three days.
  • Tuesday 14:00: the next train deploys. Merge-to-production is almost five days. Lead time for changes is about eight days.

Averaging "we review in a day" with "we ship weekly" hides this. A faster review comment saves hours. Shipping outside the Thursday migration window saves days.

Percentiles and the sample

Use the median for what usually happens and a high percentile for the slow changes. With fewer than about twenty production commits, that percentile is one or two changes, so name them. "The 95th percentile is 19 days" is less useful than "two of the last sixteen commits waited on the worker secret."

Don't drop those two to calm the median. If you show a filtered number, keep the unfiltered median beside it. A train that ships thirty commits adds thirty samples that all share one merge-to-production wait, so calling the morning merges fast without showing commit-to-merge is misleading. A single migration can own the whole tail, so say whether the percentile includes it.

A worked month for a six-person team

These figures are an illustration, not a benchmark. A team of six owns a web app deployed from main, plus a worker on the same pipeline that people tend to forget. One month looked like this:

Week Web deploys Worker deploys Median lead time (web) Web change failures
1 2 0 11 days 0
2 1 1 9 days 1
3 2 0 8 days 0
4 3 0 6 days 0

The web app deploys about twice a week. The worker shipped once. Median lead time on the web app fell from 11 days to 6: about 1.5 days to merge and about 4.5 days waiting for Tuesday. Review got faster, but releasing didn't. The worker's change took 19 days because a secret rotation never made it onto the board.

One failure in 8 web deploys is too small a denominator to manage against. Recovery took 70 minutes, once. That belongs in the retro, not on a trend line.

What the team does next, in order:

  1. Put the worker on the same weekly review as the web app, so a 19-day wait can't hide behind a busy frontend.
  2. Shorten merge-to-production, either with a second weekly release window or by shipping the web app straight from main once the checklist is down to the steps that still catch real failures.
  3. Keep marking failed deploys, but don't set a failure-rate target until there are a few dozen deploys.
  4. Leave recovery time as a note on the incident until there's enough data for a median.

A cumulative flow diagram for the same month would show a wide "in review" band followed by a wide "ready to release" band. The delivery measures tell you the code waited; the diagram tells you in which column.

The drop from 11 days to 6 is not a trend yet. Check the age of the commits inside each week's median before you call it an improvement. Keep the worker's 19 days off the web median, or that wait disappears again. Week 2's failure needs a sentence saying what broke and whether you rolled back, fixed forward, or flipped a flag. Six weeks later, nobody will remember the 70 minutes.

How to review without kidding yourself

Look once a week, for about 20 minutes. Cover this week, the last eight weeks, and any service with an unusually long gap. Read the median, one high percentile, and the longest wait.

Then answer four questions:

  • Did deployment frequency move because changes got smaller or freezes got shorter, or because one release was split into empty deploys?
  • Did lead time move in commit-to-merge, in merge-to-production, or in both?
  • Which single change owns the high percentile, and is it part of a pattern?
  • Are we about to improve a chart by changing what it counts?

Write the definition at the top of the page. If someone wants to exclude hotfixes, reverts, or "tiny" copy changes, decide it in the meeting and write down the date. Exclusions nobody records let a chart drift until it no longer measures anything.

Set a floor instead of borrowing someone else's grade. "No service goes more than five working days without a production deploy" is a floor a small team can hold. "Median lead time under two days" is fiction if the train is biweekly and nobody plans to change the train. Wait for eight weeks of your own numbers before you set any target.

Promising dates is a forecasting problem, and a range built from completed work beats a single lead-time figure. Monte Carlo forecasting is one way to build that range. It breaks down if you feed it four unusually good deploys and treat the output as a commitment. Falrow's insights put cycle time, cumulative flow, and those forecasts on your ticket history. A spreadsheet or a Jira export can do the same job, as long as start and finish times stay honest.

Running the twenty minutes

Put the deploy list on the screen and have one person read. For each service, say last week's count, the eight-week median, and the longest gap, and name the SHA at the head of any service that didn't deploy. If it's older than the newest merge, you have a queue. If it matches the newest merge, the service is just quiet.

Then read the lead-time median, one high percentile, the sample size, and the commit-to-merge versus merge-to-production split. Open the oldest change and say why it waited. If you can't, the pull request is missing the reason.

If there was a failure, read the sentence you wrote at the time and note whether a person, a monitor, or a customer noticed first. If a customer noticed first, you have a detection problem. If an alert caught it and it still took that long, you have a fix problem.

End with one action that names an owner and a day. "Shorten the checklist" is not an action. "Alex removes the staging-only screenshot step before Thursday's train" is. If last week's action didn't happen, finish that one before adding another. If the log is incomplete, cancel the meeting and fix the export, because a guessed number becomes next month's baseline.

Change failure and recovery, when you do add them

Add these once the first pair is boring to collect, meaning the Friday count no longer needs a debate about what a deploy is.

A failed change is a production change that you had to repair because users hit something wrong: a rollback, a forward fix shipped to correct it, or a flag turned off to stop the harm. A bug you already knew about and chose to ship is still a failure if you then had to repair it. A defect you catch in review, before production, is not, and neither is a log line nobody acts on. Write that paragraph down. The rate is the number of failed changes divided by the number of production changes in the same window, using the same deployment definition as the frequency count. If rollbacks count as deploys, decide whether the rollback is also the repair for the previous change or a separate failure. Settle it once, in the definition, or the rate will move whenever someone feels optimistic.

Don't turn a handful of failures into a percentage on a slide. Keep a list: date, service, SHA, how you noticed, how you repaired, and minutes from "we know" to "users are restored." Recovery time is that last interval. Start it when the team knows service is wrong, not when the bug was introduced. Pick the end in advance. "We said it was over in Slack" and "the error rate returned to the previous hour" can differ by half a day, and mixing them turns the median into a record of how people logged things.

Two repairs for one bad deploy are one failed change on the rate, but they may be two intervals of user harm. Note both on the incident, and don't average them into the weekly delivery chart.

Teams often widen "failure" until every follow-up counts. A copy tweak the next day, shipped because someone disliked the wording, is not a failed change. If you include it, people stop shipping small follow-ups and batch the wording into the next scary release. The rate looks calmer because the deploys got bigger. Keep the definition tied to harm you had to undo.

Ways the numbers go wrong

Counting merges as deploys. If main isn't production, a lead time that ends at merge describes review, not delivery.

Averaging. A median of 18 hours across 40 changes is a different fact from the same median across 4. Report the sample size.

One repo, several products. Filter by the paths that belong to each product, or a quiet app will disappear inside a busy monorepo.

Dropping hotfixes and reverts. These are exactly the changes you're trying to see. Cutting them makes the failure rate look cleaner and hides the events you needed to find.

Ranking teams. A payments service and a marketing site shouldn't share a target. Compare each service with its own recent weeks.

Collecting all four on day one. The whole month goes to arguing about definitions, and no wait gets any shorter. Start with the two numbers you can pull on a Friday.

Backfilling a cleaner definition. You tighten "deployment" in March and redraw January with the new rule. January's frequency falls and someone asks what slowed down, when nothing did. Annotate the week the definition changed, and don't overlay the old and new series without labels.

Treating a flag flip as instant lead time. The commit that added the flag merged last month. If users get the change when the flag turns on, lead time runs to that flip. Ending the clock at the dark merge is the same error as ending it on a main that isn't production.

Splitting one release into empty deploys. Re-running the pipeline without a user-facing change raises deployment frequency and shortens nothing.

Importing a target from a talk. A goal of several deploys a day, copied from someone else's system, gets met by splitting batches or deploying on a calendar. Frequency rises while the merge-to-production wait stays where it was. Hold a floor based on the train you actually run.

What dora metrics will not decide

DORA metrics will not tell you whether the tax line on the invoice was the right tax line. They won't rank a careful monthly release against daily experiments in a different market. They won't replace a list of incidents when you've had three all year. Used as a leaderboard, they push people to game the definition you were too busy to write down.

Used as a weekly look at deployment frequency, lead time for changes, and the oldest SHA still waiting, they tell you where finished work sits. Keep the page short enough that the review still ends with a named owner. If the room starts debating the research program, read the deploy log instead. A second team can copy your definitions and your Friday steps, but they should set their own floors, because a shared target makes both teams' charts lie.

FAQ

What are the four DORA metrics?

The four are deployment frequency, lead time for changes, change failure rate, and failed deployment recovery time. The first two describe how quickly committed work reaches production. The other two describe how often those changes hurt users and how fast you restore service. Each one depends on a written definition, especially of what counts as a production deployment and what counts as a failure.

Which DORA metric should a small team track first?

Start with deployment frequency and lead time for changes. You can count both from git and the production deploy log. Add change failure rate once the team agrees on what a failed change is and the deploy count is large enough that one incident doesn't swing the rate. Add recovery time when failures are common enough that a median is more than a single story.

How is lead time for changes different from cycle time?

Lead time for changes runs from commit to production. Cycle time usually runs from when work starts on a ticket until that ticket is finished, and "finished" might mean merged, accepted, or deployed. A short cycle time with a long lead time means the board is clearing but releases aren't. Keep both definitions fixed, and don't read a chart of one as a chart of the other.

How many deployments do you need before the rates mean anything?

Deployment frequency is worth reading within a few weeks, because a long gap shows up right away. Lead time needs enough shipped commits for a median, often a couple of dozen changes on a small team. Change failure rate and recovery time need a much larger denominator. Until you have it, keep a short list of failures and what each one cost, and don't manage a percentage built from two incidents.

More on flow metrics & forecasting