Regen is live.Start free trial
All posts
Error Budgets for Small Teams: One SLO, One Written Policy
SREerror budgetsSLOson-call management

Error Budgets for Small Teams: One SLO, One Written Policy

One SLO on the main request path plus a written error budget policy turns the recurring "should we slow down?" argument into a rule.

YS

Yathartha Shekhar

Co-founder & CEO

November 17, 2026

11 min read

Key takeaways

  • Error budgets are not a big-company practice. A team of 5 to 30 engineers needs one SLO on its main user-facing path, measured roughly, and a written policy for what happens when the budget is spent.
  • The budget is simple arithmetic: 100% minus your SLO, over a fixed window. A 99.9% target over 30 days allows about 43 minutes of full downtime, or 1 failed request in every 1,000.
  • The policy is the part that does the work. It has to say who decides, what changes when the budget runs out, and what does not count, and the people who ship features have to agree to it before it is needed.
  • Most small-team failures come from doing too much: several SLOs nobody watches, a target copied from a big tech company, or a policy written by one person and never agreed to.

The argument error budgets are meant to end

Every small team has some version of the same meeting. A couple of incidents land close together, someone says "we should slow down and fix reliability," someone else points at the roadmap, and the outcome depends on who argues hardest or who had the worse week on call. A month later the same conversation happens again with different incidents.

Google's SRE book frames error budgets as the fix for exactly this. In its chapter on embracing risk, the development and reliability sides agree on a budget up front, and the monitoring system, not the loudest person in the room, says whether there is any left. While there is budget, releases continue. When it is gone, releases slow or stop until the service recovers.

That idea usually gets filed under "things Google does," next to multi-region failover and a dedicated SRE org. It doesn't have to be. The machinery that makes it look expensive (many SLOs, per-team dashboards, burn-rate alerting across every service) is optional. The part that settles the argument is small: one number the team agreed on, and one written rule about what happens when you miss it.

Pick the one SLO

A small team should start with one SLO, on the request path users actually feel. For most products that is the main API or the main web request: the thing that, if it fails, a customer notices within seconds.

Pick one of two kinds:

  • Availability: the share of requests that succeed. Google's SRE workbook, in implementing SLOs, defines it as good events over valid events, for example successful HTTP requests divided by total HTTP requests.
  • Latency: the share of requests that finish under a threshold you choose, for example requests that complete in under 500 ms divided by all requests.

If you have to choose, availability is usually the easier first one, because almost every load balancer and web server already logs status codes. Latency is the better pick if your users complain about slowness far more than errors.

The workbook's advice is to start with a small number of SLI types for your most critical functionality, and to measure as close to the user as you reasonably can. Server logs miss requests that never reached your backend, so a load balancer's logs are a better source than your application's. "Measured roughly" is fine. The workbook says it directly: the most important goal is to get something in place and measured, not to get it perfect the first time.

Decide what counts as a failure and write it down. A 5xx is a failure. A 4xx usually is not, because a user sending a bad request is not your service being down. Health checks and synthetic load tests usually should not count either way. Those three decisions cover most of what "valid events" means in practice.

Choose a target that is not 100%

The SRE book is blunt: 100% is probably never the right reliability target. Users reach your service through networks and devices you don't control, and the book's example is that a user on a 99% reliable smartphone cannot tell the difference between 99.99% and 99.999% service reliability. Past that point every extra nine costs engineering time you could have spent on features, and users don't notice it.

For a first target, the workbook suggests starting from your current performance. Look at the last month or two of your chosen SLI and set the target slightly below what you actually achieved, so the budget is real but not already spent on day one. Then revisit it after a few months. The common choices for a small team's main path are 99%, 99.5%, or 99.9%, and the right one is whichever your current system can meet and your users would accept, not the one with the most nines.

Turn it into a budget in five minutes

The error budget is 100% minus the SLO. Pick a window and do the arithmetic once. The SRE workbook recommends a four-week rolling window as a good general-purpose choice. If your team thinks in calendar months, a 30-day window works the same way.

SLOError budgetFull downtime allowed in 30 daysFailed requests allowed per 1 million
99%1%7.2 hours10,000
99.5%0.5%3.6 hours5,000
99.9%0.1%43.2 minutes1,000

The downtime column is the easiest way to explain the budget to the rest of the company, but for a request-based SLO the request column is the one you track. A partial outage that fails 10% of requests for an hour uses the same budget as a full outage of six minutes.

If your traffic is low, the request math gets jumpy: a few failed requests during a quiet night can look like a large share. The workbook's options for low-traffic services include generating synthetic traffic or grouping small services into one larger one for monitoring. For a small team, a simpler first step is to use a longer window, so one bad night does not dominate the number.

Write the error budget policy

The SLO tells you whether you are within budget. The policy tells everyone what happens next, and without it the SLO just becomes one more chart in the same argument. Google publishes an example error budget policy that is a good starting template. A small team's version can fit on one page and needs to answer four questions.

What happens when the budget is spent: Google's example halts all changes and releases other than P0 issues or security fixes until the service is back within its SLO. A small team might choose something softer, such as "the next sprint goes to reliability work" or "one engineer moves from features to reliability until the budget recovers." The softer version is fine as long as it is specific enough that nobody has to negotiate it on the day.

Who decides, and who settles disagreements: name one person or role who declares the budget spent and one who settles disputes about the numbers. In Google's example, disagreements escalate to the CTO. On a 15-person team that might be the engineering lead or a founder. What matters is that the name is in the document before the first dispute.

What doesn't count: Google's policy lets teams keep shipping features when an outage came from a company-wide networking problem or a service maintained by another team, and excludes budget spent by users outside the SLO's scope, such as load tests. A small team's equivalent is usually "our cloud provider's regional outage" and "our own load testing." Decide this in advance, because the argument about whether an incident "counts" is the same argument you were trying to end.

When a single incident needs a postmortem: Google's example requires a postmortem when one incident consumes more than 20% of the error budget over four weeks. That is a useful threshold for a small team too, because it ties the postmortem habit to user impact rather than to how stressful the incident felt.

Google's policy is also explicit about one non-goal: it is not intended to serve as a punishment for missing SLOs. Say the same in yours. A spent budget means the system needs attention, not that someone failed.

Finally, get it agreed. The workbook is clear that an SLO is only useful if all stakeholders agree to it: product, the developers shipping features, and whoever is on call. On a small team that is one meeting. Put the date and the names at the top of the document, along with a date to revisit it.

How the SLO interacts with on-call and paging

An SLO gives on-call a better question to page on. Instead of paging on every CPU spike or every individual error, you can page when the error budget is being spent fast enough to matter. The SRE workbook's chapter on alerting on SLOs puts it this way: the goal is to be notified for a significant event, one that consumes a large fraction of the error budget.

The workbook's suggested starting points are to page when 2% of the budget is consumed in one hour or 5% in six hours, and to open a ticket, not a page, when 10% is consumed over three days. You do not need its full multi-window setup on day one. Even one alert on fast budget burn, plus the alerts you already trust, is a reasonable start, and it gives you a principled reason to delete the noisy alerts that never threatened the budget. If your pager is already noisy, we wrote about why that problem tends to outlive tooling changes in why alert fatigue survives every tooling migration.

The budget also changes the post-incident conversation. "That incident used 30% of this month's budget" is a sentence product and engineering can both act on, which "that was a bad night" is not. And it connects back to the policy: the on-call engineer is not the one who decides to freeze releases at 3 a.m. They report the number, and the person named in the policy makes the call.

Common mistakes

Too many SLOs: a small team that defines SLOs for every service ends up with a dashboard nobody reads and no single number anyone defends. Start with one. Add a second only when there is a user-facing path the first one clearly misses.

Targets copied from big tech: a 99.99% target allows about 4 minutes of full downtime in 30 days. That is a target for a company with multi-region failover and a full-time reliability team. If your current system can't meet it, the budget is spent on day one and the policy is ignored by day ten.

A policy nobody agreed to: an SLO written by the on-call engineers alone becomes a complaint, not a rule. If product and the people shipping features did not sign off, the first spent budget restarts the old argument, now with a chart attached.

Never revisiting the target: the first target is a guess based on past performance. If you blow the budget every month without users complaining, the target may be too strict. If you never come close, it may be too loose to drive any decision. Review it on the date the policy says.

Measuring the wrong thing: an SLO on an internal component, such as database CPU or queue depth, does not tell you what users experienced. Keep the one SLO on the request path users actually hit.

FAQ

What is an error budget? The amount of unreliability your SLO allows over a window: 100% minus the SLO. A 99.9% availability SLO allows 0.1% of requests to fail, which is about 43 minutes of full downtime in 30 days.

How many SLOs should a small team start with? One, on the main user-facing request path. Add more only when a real user-facing path is not covered by it.

Should the SLO target be based on what we want or what we have? Start from what you have. Google's SRE workbook suggests current performance as the starting point, then iterate. A target your system already misses gives you a budget that is spent before the policy has a chance to work.

What happens when the error budget runs out? Whatever your written policy says. Google's example halts releases except P0 and security fixes until the service is back within its SLO. Smaller teams often choose to move one engineer or one sprint onto reliability work instead.

Do we need SLO tooling to do this? Not to start. A query over load balancer logs that gives you good requests over total requests for the window is enough to compute the budget. Burn-rate alerting is easier with tooling, but you can add it later.

Should we page on error budget burn? Paging on fast budget burn is a good replacement for paging on symptoms that never affect users. Google's SRE workbook suggests paging at 2% of the budget consumed in one hour or 5% in six hours as starting points.

One disclosure: we build FluidifyAI Regen, FluidifyAI's on-call and incident management platform. It doesn't calculate SLOs or error budgets. Where it fits is the step the policy asks for after a big budget hit: Regen drafts the incident summary and post-mortem with AI, with 25,000 AI credits a month included, so the postmortem your policy requires exists even when the team is busy fixing the next thing.