Skip to main content
Error Budgets to Roadmap: Turning Reliability Into Prioritization

Error Budgets to Roadmap: Turning Reliability Into Prioritization

KU
· Founder & Chief Editor
• 7 min read•Updated •41 views

Reliability arguments used to be shouting matches between SRE and product. An error budget turned them into arithmetic. Here's the SLO math, the burn-rate alerts, and the policy that made the number drive the roadmap.

Key takeaways

  • An error budget is 100% minus your SLO.
  • A 99.9% SLO over 30 days allows 43.2 minutes of full downtime or the equivalent in failed requests.
  • Alert on burn rate, how fast you spend that allowance, and attach a signed policy that freezes feature work when the budget runs out, so the number drives the roadmap.

An error budget is 100% minus your SLO: a 99.9% target over 30 days allows 43.2 minutes of full downtime, or the same share of failed requests. Spend it on shipping while it lasts. Alert on burn rate, not raw error rate, and sign a policy in advance that freezes feature work when the budget is gone.

Verified against

Definitions, burn-rate thresholds, and policy guidance checked against the Google SRE Workbook chapters "Implementing SLOs", "Alerting on SLOs", and "Example Error Budget Policy". Checked October 2026.

Every quarter SRE and product had the same fight about hardening versus features, and the loudest person won. The error budget ended it, because a shared number either had room in it or didn't.

SLI, SLO, error budget: three words people fuse

An SLI (service level indicator) measures the service as users experience it. The SRE Workbook recommends expressing it as a ratio: good events divided by total events. "Fraction of HTTP requests that returned a non-5xx status in under 300ms" is an SLI, and you can compute it from data you already have.

An SLO (service level objective) is the target you hold that SLI to over a window: "99.9% of requests are good over a rolling 30 days." The Workbook suggests a four-week rolling window as a general-purpose default.

The error budget falls out by subtraction: 100% minus the SLO. At 99.9%, 0.1% of events may fail. That allowance is not failure; it is what you spend on deploys, migrations, config changes, and the occasional bad Tuesday.

Good SLIs sit where the user meets the system. Measure availability and latency at the load balancer or gateway if you can, because requests that never reached the app still count to the user. Express latency as a threshold ("95% of requests under 300ms"), never an average, because averages hide the tail where the pain lives.

From target to budget

Do the arithmetic once and it stops feeling abstract. A 30-day window has 43,200 minutes.

SLOError budgetFull downtime per 30 days
99%1%432 minutes (7.2 hours)
99.9%0.1%43.2 minutes
99.95%0.05%21.6 minutes
99.99%0.01%4.32 minutes

The same math works on request counts. The Workbook's example: a 99.9% SLO on 3 million requests over four weeks gives a budget of 3,000 errors, so one outage that fails 1,500 requests burns half of it. Each extra nine cuts the allowance by ten, and at 99.99% no human can be in the recovery loop. Choose the target users actually need, not the most impressive one.

code
budget_total     = (1 - 0.999) * total_requests
budget_spent     = failed_requests
budget_remaining = budget_total - budget_spent

Burn rate is the signal, not the raw number

Remaining budget alone misleads: 40% left sounds healthy until you notice you burned 60% in the first three days. Burn rate is how fast the service consumes budget relative to the SLO. A burn rate of 1 spends exactly the budget over the window. A burn rate of 14.4 sustained for one hour consumes 2% of a 30-day budget, and would empty it in about two days.

PromQL
# 1-hour burn rate: current error ratio divided by the budget ratio
(
  sum(rate(http_requests_total{code=~"5..",service="payments"}[1h]))
  /
  sum(rate(http_requests_total{service="payments"}[1h]))
) / 0.001

The Workbook's recommended multiwindow setup for a 99.9% SLO pairs each long window with a short one about 1/12 its length, so an alert fires only if the burn is real and still happening:

  • Page: burn rate 14.4 over 1 hour and 5 minutes (2% of budget consumed).
  • Page: burn rate 6 over 6 hours and 30 minutes (5% of budget).
  • Ticket: burn rate 1 over 3 days and 6 hours (10% of budget).

The longer version, including why this beats static thresholds, is in burn-rate alerting and the SLO discipline that prevents alert fatigue.

The policy that turns the number into a decision

A budget with no policy attached is just another dashboard. We wrote down, and got leadership to sign, what happens at each threshold, so the number binds before an incident instead of getting argued about after.

slo/payments-error-budget-policy.yaml
error_budget_policy:
  service: payments
  slo: 99.9
  window_days: 30
  thresholds:
    - remaining_gt: 50
      action: "Ship normally. Feature work proceeds."
    - remaining_between: [10, 50]
      action: "New features require a reliability review before merge."
    - remaining_lt: 10
      action: "Feature freeze. Reliability work until budget recovers."
    - exhausted: true
      action: "Freeze plus incident review. Only fixes and security patches deploy."

Google's example policy has the same shape: when the budget is exceeded over the trailing four weeks, all changes halt except P0 and security fixes until the service is back within SLO, and any single incident that consumes more than 20% of the budget in four weeks gets a postmortem with at least one P0 action item. It also says plainly that the freeze is not punishment.

The first time we hit our freeze, product pushed back, but the policy was signed. The team spent the week on the retry storm eating the budget, and features resumed once it recovered.

Making it visible where decisions get made

The budget only works if it shows up in planning, not just in Grafana. We pipe remaining budget into the sprint planning doc, so when a PM opens the board on Monday, the number sits next to the feature list. "Should we ship the risky migration this sprint?" stops being a personality contest and becomes "we have budget left, yes, and we'll watch burn rate during rollout." To turn a target into minutes per day, month, or year, our uptime and SLA calculator does the arithmetic.

Mistakes we keep watching people make

  • Too many SLOs. Forty SLOs, one per endpoint and dependency, and nobody can say whether the service is healthy. Start with two or three that map to user journeys.
  • SLOs nobody enforces. The budget runs out, everyone shrugs, shipping continues. If you won't freeze, you have a metric, not an error budget.
  • Alerting on causes instead of symptoms. Paging on CPU, disk, or a restarted pod pages on things users may never feel. Page on failed or slow requests; investigate causes after.
  • An SLI users don't feel. We once had a data-freshness bug hurt users for a week without touching our success-rate SLO. Garbage SLI in, false confidence out.

Questions people ask

How do you calculate an error budget?

Subtract the SLO from 100%. A 99.9% SLO leaves a 0.1% error budget. Multiply by the window to get time: 0.1% of the 43,200 minutes in 30 days is 43.2 minutes of full downtime. Multiply by request volume to get events: 3 million requests at 99.9% allows 3,000 failed requests in the window.

What is a good burn rate alert threshold?

For a 99.9% SLO, the Google SRE Workbook recommends paging at a burn rate of 14.4 over one hour (2% of a 30-day budget) and at 6 over six hours (5%), and opening a ticket at 1 over three days (10%). Pair each long window with a short one, about 1/12 its length, so alerts stop once the burn ends.

What happens when the error budget runs out?

Whatever your signed policy says, which should be a freeze on non-essential changes. Google's example policy halts all changes except P0 and security fixes until the service is back within its SLO, and moves the team onto the reliability work behind the burn. Without a policy agreed in advance, the budget is only a dashboard.

The call we'd make

Start with one critical service, one or two SLIs users actually feel, and a 99.9% objective you can defend. Replace static threshold alerts with multiwindow burn-rate alerts. Then write the policy, get a real signature on the freeze rule, and honor it the first time the budget runs out. That first honored freeze turns an error budget from a slide into a habit; expand to other services only after it has happened once.

Sources

Explore topics:DevOps
React
Share this post
Cite this article
Plain text

Kiril Urbonas (2026). Error Budgets to Roadmap: Turning Reliability Into Prioritization. DevOpsNess. Updated 2026-11-15. https://www.devopsness.com/blog/error-budgets-to-roadmap-prioritization

Markdown

[Error Budgets to Roadmap: Turning Reliability Into Prioritization](https://www.devopsness.com/blog/error-budgets-to-roadmap-prioritization) (Kiril Urbonas, DevOpsNess, updated 2026-11-15)

KU

Kiril Urbonas

Founder & Chief Editor

605 articles
View all articles by Kiril Urbonas

You might have missed

Evergreen posts worth revisiting.