Lorixen.
EN

SLOs and error budgets for a small web team

Short answer: A service level objective (SLO) is a target for how reliable a specific part of your website or app should be, measured the way customers experience it, for example "99.5% of checkout requests succeed within two seconds over 28 days". The gap between that target and 100% is your error budget: the amount of failure you have agreed to tolerate. While budget remains, the team keeps shipping; when it is spent, reliability work comes first. For a small team, two or three SLOs on the journeys that make money are enough.

Why "as reliable as possible" isn't a plan

Small teams constantly trade new features against fixing flaky things, and without a shared rule the loudest complaint wins. Some weeks everything stops for a minor glitch; other weeks real reliability problems are ignored because a launch is due.

Google's Site Reliability Engineering book addresses this directly. Its chapter on embracing risk argues that rather than simply maximising uptime, teams should balance the risk of unavailability against the goals of rapid innovation and efficient operations. It also makes a point that applies to any business: users cannot tell the difference between extremely high reliability levels when their own device and connection are less reliable. Its example is that a user on a 99% reliable smartphone cannot tell the difference between 99.99% and 99.999% service reliability.

Chasing perfection costs time you could spend improving the product. SLOs put a number on "reliable enough".

SLIs, SLOs and SLAs

The SRE book's chapter on service level objectives defines three related ideas:

  • SLI (service level indicator): a measurement, such as the share of requests that succeed or how quickly pages respond.
  • SLO (service level objective): the target value for that measurement over a time window.
  • SLA (service level agreement): a promise to customers, usually with consequences such as credits if it is missed.

You can have SLOs without any SLA. Most small businesses should start that way: internal targets that guide decisions, not contractual promises.

The same chapter notes that indicators are usually aggregated over a measurement window into a rate, average or percentile, and that the ideal indicator measures the service level of interest directly, though sometimes only a proxy is available. It gives client-side latency as often being the more user-relevant measure.

Choosing what to measure

Pick the journeys that matter to revenue and trust:

  • Availability of key actions: the percentage of checkout, booking or login requests that complete without a server error.
  • Latency: the percentage of those requests that finish within a threshold you choose, such as two seconds. Percentiles generally suit this better than averages, because an average can look healthy while a meaningful share of customers waits far too long.
  • Freshness for background work: for example, the percentage of orders synced to the warehouse within ten minutes.

Avoid indicators nobody would notice failing, such as CPU usage. If an SLI is green while customers are complaining, it is the wrong SLI.

Setting the target

Start from what you observe, not what sounds impressive. Look at the last few months of data, see what reliability you have actually delivered, and set the target slightly below that so it is achievable. Common windows are 28 or 30 days.

Remember that each extra "nine" costs a lot more effort. The SRE book notes that while 100% availability is impossible, near-100% is often achievable, and reliability is commonly expressed as a number of nines. For a small business site, targets like 99% or 99.5% for a key journey are often realistic and meaningful.

Error budgets: turning the target into decisions

The error budget is simply 100% minus the SLO. The SRE book's example: if a service's SLO is to successfully serve 99.999% of queries per quarter, its error budget is a failure rate of 0.001% for that quarter. It describes the policy that follows: as long as measured uptime is above the SLO, meaning budget remains, new releases can be pushed.

A small team can adopt a simple version:

  • Plenty of budget left: ship as normal, try riskier changes.
  • Budget running low: slow down risky releases, review recent incidents.
  • Budget spent: pause feature work for that area and fix the causes before shipping more.

Write this down and agree it in advance, including who decides and what counts as an exception, such as a security fix that must ship regardless. The value comes from removing the argument when it matters.

Making it work in practice

  • Measure from your logs or monitoring tool. Many monitoring services calculate SLOs and burn rates for you.
  • Alert on burn rate, meaning how fast the budget is being used, rather than every single error.
  • Review monthly. Look at how much budget was used and why, and adjust targets if they are too strict or too loose.
  • Keep it small. Two or three SLOs that people look at beat twenty nobody reads.

A worked example

Picture a hypothetical Phoenix dental group with an online booking app. The two developers kept switching between new features and urgent fixes, and the practice manager judged reliability by how many patients complained that week.

They set two SLOs over 28 days: 99.5% of booking submissions succeed, and 95% complete within two seconds. Their error budget policy says that if either budget is spent, new features pause until the causes are fixed. In the first month a payment-provider timeout used most of the success budget; they added retries and a timeout alert. Since then, decisions about "fix or build" take minutes, based on a number everyone sees.

FAQ

Do I need special software for SLOs?

No. You can start with your server logs and an existing monitoring dashboard, and many monitoring tools now include SLO and burn-rate features.

Should I publish SLOs to customers?

Not at first. Internal targets come first; promises to customers, if any, should be looser than your internal SLOs.

What if we miss an SLO?

It is information, not failure. Use the error budget policy you agreed and look at the causes.

If your team argues every week about whether to fix or build, tell us which parts of your app matter most.

Sources

WhatsAppBook a call