SLOs, SLIs, and Error Budgets: A Practical Reliability Planning Template for Engineering Teams
SREobservabilitySLOSLIerror budgetsKubernetesplatform engineeringincident management

SLOs, SLIs, and Error Budgets: A Practical Reliability Planning Template for Engineering Teams

NNetworked DevOps Editorial Team
2026-11-14
8 min read

A practical SLO and SLI guide with error-budget formulas, burn-rate examples, review templates, and Kubernetes reliability workflows.

Use this practical SLO and SLI planning guide to choose meaningful service indicators, set defensible objectives, calculate error-budget burn, and turn reliability data into clearer Kubernetes, cloud, and platform engineering decisions.

Overview

Service level indicators (SLIs), service level objectives (SLOs), and error budgets connect technical performance with decisions that engineering teams must make. An SLI measures an aspect of user-visible service behavior. An SLO defines the level of that behavior the team intends to provide over a stated time window. The error budget is the amount of unreliability permitted by the objective.

For example, an availability SLO of 99.9% over a 30-day window allows 0.1% of valid requests to be unsuccessful during that window. The objective is not a promise that every request will succeed. It is a planning boundary for releases, capacity work, incident response, and platform investment.

The most useful SLOs measure outcomes at a service boundary rather than internal activity. CPU utilization, pod restarts, queue depth, and memory pressure can be valuable diagnostic signals, but they are usually supporting metrics. A customer-facing SLI might measure whether an API request completed successfully within an acceptable latency threshold. In Kubernetes and cloud environments, this distinction helps teams avoid declaring a workload healthy merely because its pods are running.

Start with a small set of objectives that a team can explain, measure, and act on. A long list of metrics creates reporting work without necessarily improving reliability.

Reference table: match the SLI to the service

Service typeAvailability indicatorLatency indicatorFreshness or correctness indicatorThroughput indicator
Public APISuccessful valid requests divided by all valid requestsPercentage of requests under a defined thresholdSchema, status, or response validation failuresRequests served per time interval
Web applicationSuccessful page or transaction loadsLoad or interaction latency at a defined percentileCompleted user journeys or failed browser checksSessions or transactions completed
Data pipelineScheduled runs completed successfullyTime from input arrival to processing completionRecords processed within an age limit and validation rulesRecords or batches processed per interval
Message or queue serviceMessages accepted and delivered without lossTime from enqueue to consumptionUndelivered, duplicated, or malformed messagesMessages processed per second or minute
Internal platform serviceSuccessful provisioning or deployment operationsTime to complete a platform operationResources matching the requested configurationOperations completed per interval

How to estimate

Define the measurement before choosing the target. For a request-based availability SLI, use:

Availability SLI = good events ÷ valid events × 100

Exclude traffic that should not count, such as deliberately rejected requests caused by invalid authentication or malformed input, but document the rule. If exclusions are too broad, the SLI can look healthy while users still experience failures.

For a latency SLI, define a threshold and count requests that meet it:

Latency SLI = requests at or below threshold ÷ valid requests × 100

State the aggregation method explicitly. A percentile-based indicator generally describes user experience more usefully than an average alone because a small group of very slow requests can disappear inside an average. The right percentile and threshold depend on the service, request type, and user expectation; use historical measurements and product requirements rather than copying a target from another system.

Error-budget calculation

For an SLO expressed as a percentage, calculate the budget as:

Error budget = 1 − SLO target

If the target is 99.9%, the budget is 0.1% of valid events. In a window containing 2,000,000 valid requests, the illustrative budget is:

2,000,000 × 0.001 = 2,000 unsuccessful requests

For time-based availability, the same logic applies to the selected window. A 99.9% objective over a 30-day calendar window permits 0.1% of that window to be unavailable, subject to the measurement method and exclusions your team defines.

Burn rate

Burn rate describes how quickly the service is consuming its budget compared with the rate that would use the entire budget exactly at the end of the SLO window.

Burn rate = observed bad-event ratio ÷ allowed bad-event ratio

For a 99.9% SLO, the allowed bad-event ratio is 0.001. If 0.005 of requests are unsuccessful during a selected interval, the burn rate is 0.005 ÷ 0.001 = 5. At that rate, the budget is being consumed five times faster than planned. A burn-rate alert should combine the burn rate with a meaningful window and enough traffic to avoid reacting to a tiny sample.

In Prometheus, a request-based ratio can be represented with a pattern such as:

sum(rate(http_requests_total{job="api",status=~"5.."}[5m]))
/
sum(rate(http_requests_total{job="api"}[5m]))

Use the metric names, labels, status definitions, and recording rules that match your instrumentation. OpenTelemetry-based telemetry can provide the request, latency, and trace context needed to build these measurements, but collection does not automatically define what counts as good or bad.

Inputs and assumptions

A reliable estimate depends on clear inputs. Record the following in the SLO specification:

  • Service boundary: Identify the API, workload, platform capability, or user journey being measured.
  • Valid-event definition: State which requests, jobs, messages, or provisioning operations are included.
  • Good-event definition: Define success, acceptable latency, freshness, and correctness conditions.
  • Time window: Choose a rolling or calendar window and keep it consistent for reporting and decisions.
  • Traffic source: Separate production user traffic from synthetic checks, tests, retries, and administrative calls where appropriate.
  • Sampling and aggregation: Document missing telemetry, sampling, percentile calculation, and low-volume behavior.
  • Ownership: Assign a team that can investigate violations and change the service or its supporting platform.

Cloud-managed services require particular care. Provider dashboards may expose availability or latency measures that use a different scope, region, sampling method, or exclusion policy from your application SLI. Treat provider metrics as useful evidence, not an automatic substitute for measuring the user-facing outcome. For Kubernetes workloads, combine ingress or API-gateway measurements with application telemetry when the gateway alone cannot distinguish a successful response from an incorrect one.

Keep the SLO definition close to the service documentation and dashboard. A concise runbook should explain the query, dashboard link, alert meaning, escalation path, and the release policy attached to the budget.

Worked examples

Example 1: API availability

Assume a service records 500,000 valid requests during a review window. Of these, 499,400 meet the success definition. The availability SLI is 499,400 ÷ 500,000 = 99.88%. Against a 99.9% objective, the service is below target. The budget for that volume would be 500 unsuccessful requests, while 600 occurred, so the illustrative overage is 100 unsuccessful requests.

The immediate response should not be to change the target. First classify the failures: deployment, dependency, capacity, configuration, or measurement error. If the issue came from a Kubernetes rollout, review the deployment strategy, readiness behavior, and rollback path. The related Kubernetes deployment strategies guide can help structure that review.

Example 2: release burn rate

Assume the same 99.9% objective and a short-window bad-event ratio of 0.004. The burn rate is 0.004 ÷ 0.001 = 4. A sustained result at four times the permitted rate is more important than a single isolated error, particularly if the affected traffic is material and the query is complete.

An operational policy might pause nonessential releases while the team confirms the signal, mitigates the incident, and identifies whether the release caused the errors. The exact threshold and action should be agreed in advance. One alert can notify the on-call engineer about immediate risk; a longer window can provide confidence that the budget is genuinely being consumed.

Example 3: platform provisioning

For an internal developer platform, measure successful environment or deployment operations rather than only controller health. A useful SLI could count operations that produce the requested resource configuration within an agreed completion time. If the platform reports success but produces a namespace with missing policies or incorrect limits, the operation may be available while still failing the correctness objective. Pair status metrics with validation checks and, where appropriate, a user-facing completion signal.

This is also where platform teams should connect reliability with resource planning. Changes to requests, limits, autoscaling, or cluster capacity can affect both latency and availability. Review the Kubernetes resource requests and limits guide when an SLO trend points to scheduling pressure or right-sizing problems.

When to recalculate

Revisit SLOs during quarterly planning, after a major architecture change, when traffic or workload shape changes, and after incidents that expose a measurement gap. Recalculate when a service moves regions, adopts a new cloud dependency, changes its Kubernetes ingress or deployment model, or introduces a new user journey. Also review the definition when telemetry, query logic, sampling, or alert thresholds change.

Quarterly SLO review template

  1. Scope: Confirm the service boundary, owner, dependencies, and user journeys.
  2. Data quality: Check missing series, label changes, exclusions, low-volume periods, and dashboard-to-query consistency.
  3. Performance: Compare SLI, SLO attainment, error-budget consumption, and burn-rate episodes with the previous period.
  4. Incidents: Map incidents and near misses to the measured failure modes. Record gaps where the SLO did not reflect user impact.
  5. Delivery: Review whether releases, migrations, or configuration changes consumed disproportionate budget.
  6. Decision: Keep, refine, add, or retire an SLO. Record the rationale and effective date.
  7. Policy: Update release, rollback, capacity, and incident actions based on observed budget behavior.

Make the workflow operational: alert on meaningful burn, link alerts to a runbook, pause risky delivery when the agreed policy requires it, and resume normal change only after the signal is understood. After an incident, change the policy or instrumentation when the evidence supports it—not simply the target. For broader incident follow-up, pair this process with an SLI and SLO review guide and record every assumption that future reviewers may need to recalculate the result.

Finally, treat SLOs as working agreements between product, engineering, and operations. They are most valuable when they make trade-offs visible: which reliability work is urgent, which releases need caution, and where platform improvements can reduce repeated operational effort.

Related Topics

#SRE#observability#SLO#SLI#error budgets#Kubernetes#platform engineering#incident management
N

Networked DevOps Editorial Team

Senior SEO Editor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.