SLA vs SLO vs SLI: Differences With Real Examples
SLA vs SLO vs SLI explained with real examples for APIs, checkout flows and data pipelines, plus how to turn SLOs into on call alerts that matter.

SLA vs SLO vs SLI is one of the most confused distinctions in reliability work, and the confusion is expensive. An SLI is the measurement: the percentage of requests that succeeded, or the share that finished under 300 milliseconds. An SLO is the internal target you set for that measurement, such as 99.9 percent of requests succeeding over 28 days. An SLA is the external promise you make to customers, with money or service credits attached if you miss it. Measurement, target, contract. Get the order right and on call gets calmer. Get it wrong and you end up paging people for numbers nobody promised anyone.
This guide walks through each term with concrete examples for an API, a checkout flow and a nightly data pipeline, shows how the three numbers relate to each other, and explains how to turn an SLO into alerts that wake people up only when it matters. If you want the downtime arithmetic for any target as you read, keep the SLA uptime calculator open in another tab.
SLA vs SLO vs SLI: the short definitions
The clearest framing comes from the Google SRE book chapter on service level objectives, which most of the industry vocabulary descends from. Here is the condensed version.
SLI: service level indicator
An SLI is a carefully defined quantitative measure of some aspect of the service your users experience. The most useful SLIs are ratios: good events divided by valid events. "Successful HTTP responses divided by all HTTP responses, excluding health checks" is an SLI. "CPU usage" is not, because no user has ever noticed your CPU. An SLI is just a number over time. It has no opinion about whether that number is good.
SLO: service level objective
An SLO is the target value or range for an SLI, measured over a window. "99.9 percent of checkout requests succeed, measured over a rolling 28 day window" is an SLO. It is an internal engineering commitment. Nobody outside the company is owed anything when you miss it, but it should change what your team does next: slow down releases, prioritize reliability work, or revisit the target itself.
SLA: service level agreement
An SLA is a contract with customers that states what happens if a service level is not met. Usually that means service credits, sometimes refunds or termination rights. Cloud providers publish SLAs for most of their products, and enterprise SaaS contracts frequently include one. The defining feature of an SLA is the consequence. If missing the number costs nothing, it is not really an SLA, it is a marketing claim.
How the three fit together
- SLI answers "what are we measuring?" It is owned by engineering and lives in your monitoring system.
- SLO answers "how good does that measurement need to be?" It is owned by engineering and product together and drives prioritization.
- SLA answers "what do we owe customers if it is worse?" It is owned by legal, sales and leadership, and engineering should have a veto on the numbers.
- The SLA should always be looser than the SLO, which gives you a buffer to notice and fix problems before they cost money.
SLI examples: choosing what to measure
Most failed SLO programs fail here, at the SLI. Teams pick whatever their dashboards already show, which is usually server metrics, and then wonder why the SLO stays green while customers complain. A good SLI has three properties: it reflects user experience, it can be computed reliably from data you already collect, and the team can actually move it.
Example 1: a public REST API
For a request driven service, two SLIs cover most of what users feel.
- Availability SLI: the proportion of valid requests that returned a non 5xx status. Exclude requests that are the client's fault (4xx), and decide explicitly whether 429 rate limit responses count as failures. If customers hit your limits because your limits are wrong, they probably should.
- Latency SLI: the proportion of valid requests that completed in under a threshold, say 400 milliseconds. Note the shape: it is still a good events over valid events ratio, not an average. Averages hide the slow tail where the real pain lives.
Where you measure matters. Measuring at the application server misses failures in the load balancer, DNS and network. Measuring at the load balancer is a common compromise. Synthetic probes from outside your infrastructure, such as an uptime monitor hitting a real endpoint every minute, catch the failures your own logs never see because the request never arrived.
Example 2: an ecommerce checkout flow
A checkout is a sequence of calls: cart, pricing, payment authorization, order creation. Measuring each service separately gives you four SLIs that can all look healthy while the flow as a whole fails, because each one only has to fail occasionally for the combined journey to break often.
A better SLI here is a journey level ratio: completed checkouts divided by checkouts that reached the payment step, excluding declines that the payment provider returned for legitimate reasons such as insufficient funds. That last exclusion matters. Card declines are not your outage, and counting them makes the SLI noisy enough that people stop trusting it.
Example 3: a nightly data pipeline
Pipelines do not serve requests, so availability ratios are awkward. Use freshness and correctness instead.
- Freshness SLI: the proportion of time during business hours that the reporting tables contain data no older than 26 hours.
- Completeness SLI: the proportion of daily runs in which the row count landed within an expected range of the source system.
Freshness SLIs are a good fit for teams whose "outage" is really a silent failure: the job did not crash, it just did not run, and nobody noticed until the finance team opened a stale dashboard on Monday morning.
SLO examples: setting targets people can defend
An SLO turns an SLI into a decision rule. Picking the number is less about ambition and more about honesty: what does the business actually need, and what can the system actually deliver?
Start from what users tolerate, not from nines
Teams often start with "we want four nines" because it sounds serious. Then they discover that 99.99 percent over 30 days allows about 4 minutes and 19 seconds of failure, which is less time than it takes most on call engineers to open a laptop, read the alert and join a call. A target your response process cannot physically defend is not a target. It is a guaranteed miss.
A more grounded approach: look at the last 90 days of the SLI, find the level the service actually achieved during a period when users were not complaining, and set the SLO slightly below it. Then tighten it deliberately if the business needs more.
Worked SLO examples
- Public API availability: 99.9 percent of valid requests succeed over a rolling 28 days. That allows roughly 40 minutes of total failure in the window.
- Public API latency: 99 percent of valid requests complete in under 400 milliseconds over 28 days.
- Checkout: 99.5 percent of checkout attempts that reach payment complete successfully over 28 days.
- Data pipeline freshness: reporting data is under 26 hours old for 99 percent of business hours over a calendar quarter.
Notice that the targets differ. A single company wide number such as "everything is 99.9" is a sign nobody thought about the individual services.
The error budget is the useful part
The gap between 100 percent and the SLO is the error budget. At 99.9 percent over 28 days, you may fail about 40 minutes' worth of requests before the objective is breached. That budget is what makes an SLO actionable. When plenty remains, the team ships freely. When it is nearly spent, risky deploys wait and reliability work moves up the queue. Dependencies spend this budget too, which surprises many teams; we covered that arithmetic in detail in your error budget is spent by your dependencies.
SLA examples: what goes in the contract
An SLA translates an availability promise into legal and commercial terms. Engineers often never see the SLA their company signed, which is a mistake, because the definitions in the contract decide whether an incident costs money.
Anatomy of a typical SaaS SLA
- Commitment: for example, 99.5 percent monthly uptime for the production service.
- Definition of downtime: often "the service is unavailable to all users for more than five consecutive minutes," which is very different from your SLI's per request view.
- Exclusions: scheduled maintenance with notice, customer caused issues, failures of third party networks, force majeure.
- Remedy: tiered service credits, such as 10 percent of the monthly fee below the commitment and a larger share below a lower threshold.
- Claim process: the customer usually has to request credits within a window, with evidence.
Why the SLA should be looser than the SLO
Suppose your internal SLO for the API is 99.9 percent and your SLA promises 99.5 percent. The difference between those numbers is your safety margin. When the SLO is breached, the team has a reliability problem to fix. When the SLA is breached, the company has a financial and trust problem. You want many SLO breaches to be caught and corrected long before any of them becomes an SLA breach.
If sales has promised customers 99.99 percent while engineering targets 99.9 percent, the relationship is inverted, and every bad month will be a contract dispute. Run the numbers for both targets side by side in the uptime calculator before anyone signs: the gap between "about 43 minutes a month" and "about 4 minutes a month" tends to end that conversation quickly.
Measurement mismatches that cause disputes
The SLI and the SLA rarely measure the same thing. Your SLI counts failed requests; the SLA might count minutes of total unavailability. A partial outage that fails 30 percent of requests for two hours can burn a large part of your error budget without registering as SLA downtime at all, and the reverse can also happen when a short full outage crosses a contractual threshold. Write down how each SLA term maps to an SLI you already measure, so that when a customer files a claim, you are not reconstructing the answer from logs during the argument.
Turning SLOs into on call alerts
This is where SLA vs SLO vs SLI stops being vocabulary and starts affecting sleep. The SLO tells you what good looks like. The alerting strategy decides when a human gets paged.
Page on burn rate, not on every error
Burn rate is how fast you are consuming the error budget relative to the rate that would exactly exhaust it by the end of the window. A burn rate of 1 means you will land precisely on the SLO. A burn rate of 14.4 sustained for an hour consumes about 2 percent of a 30 day budget, which is a reasonable threshold for paging someone immediately. The Google SRE workbook chapter on alerting on SLOs lays out the multiwindow, multi burn rate approach most teams copy.
A common starting configuration looks like this:
- Page: burn rate above 14.4 over the last hour, confirmed over the last 5 minutes.
- Page: burn rate above 6 over the last 6 hours, confirmed over the last 30 minutes.
- Ticket, no page: burn rate above 1 over the last 3 days.
The short confirmation window stops the alert from staying open long after the problem is fixed. The ticket tier catches slow leaks that will exhaust the budget eventually but do not justify waking anyone at 3am.
Keep cause based alerts, but demote them
SLO alerts tell you users are hurting. They do not tell you why. Disk filling up, certificate expiry and queue depth are still worth watching, because they often predict SLO burn before it starts. The difference is routing: those cause based signals should go to a channel or ticket queue during working hours unless they are about to cause user impact. Reserve the phone call for symptoms.
Low traffic services need a different approach
If a service handles 50 requests an hour, two failed requests is a 4 percent error rate and a scary burn rate, even though only two users noticed. For low volume services, combine SLO alerts with synthetic probes that generate steady traffic, or alert on an absolute count of failures instead of a ratio. Otherwise the SLO alert will be either too noisy to trust or too slow to matter.
Common SLA, SLO and SLI mistakes
Most teams that try SLOs and abandon them hit one of the same handful of problems.
Measuring the server instead of the user
CPU, memory and pod restarts are useful for debugging but useless as SLIs. A service can be at 95 percent CPU and serving every request perfectly, or at 10 percent CPU and returning errors for every request because a dependency is down.
Too many SLOs
Twenty SLOs per service means nobody knows which ones matter. Start with one or two per user journey, usually availability and latency, and add more only when an incident proves you missed something important.
SLOs nobody acts on
An SLO with no consequence for breaching it is a dashboard decoration. Agree in advance what happens when the error budget runs out: a release freeze, a reliability sprint, or an explicit decision by a named owner to accept the risk. Write that policy down before you need it.
Copying the SLA into the SLO
If your SLO equals your SLA, every SLO breach is also a financial event, and you lose the buffer that lets the team fix problems quietly. Keep the internal target tighter.
Ignoring dependencies
Your SLO cannot be higher than the combined reliability of the things it depends on, unless you have built real redundancy around them. If your service needs three providers that are each 99.95 percent available, your ceiling is lower than any of them individually, roughly 99.85 percent if they fail independently.
Putting SLOs to work in your incident process
The three terms matter most during and after incidents, which is when teams are least likely to look them up. A few habits make them useful when it counts.
During the incident
- State the SLI impact in the incident channel early: "checkout success rate is at 82 percent, normal is above 99.5." This anchors severity in data rather than whoever sounds most worried.
- Note whether the incident affects anything covered by an SLA. If it does, the customer communication path changes, and support or account managers should know within minutes.
- Update your public status page based on user impact, not on internal component health. Customers judge you against the SLA they signed, not your dashboards.
After the incident
- Record how much error budget the incident consumed. Over a quarter, this tells you whether incidents or slow degradation are the real cost.
- Check whether the SLO alert fired first, or whether a customer report did. If customers find outages before your SLIs do, the SLI is measuring the wrong thing or in the wrong place.
- Revisit the target if it was breached by an incident users barely noticed, or never breached during one they loudly did.
Where a Slack native workflow helps
Most of the work around SLOs is coordination: the burn rate alert has to reach whoever is on call, the incident has to be declared somewhere visible, and the status page has to be updated while the fix is in progress. Pagerly keeps that loop inside Slack. Uptime monitoring watches your own sites and endpoints, paging can reach the on call engineer by Slack, email, SMS, phone call or the mobile app, and incident channels and public status pages are handled from the same place. None of that replaces choosing good SLIs, but it removes the friction between "the error budget is burning" and "the right person is working on it."
A quick SLA vs SLO vs SLI checklist
If you are setting these up for the first time, or cleaning up an older set, work through this list in order.
- List your two or three most important user journeys before choosing any metric.
- For each journey, define one availability SLI and, where relevant, one latency SLI as good events over valid events.
- Decide where each SLI is measured, and add an external probe for anything customer facing.
- Set SLOs from observed historical performance, not from round numbers.
- Convert every target to minutes of allowed failure per window and check your response process can defend it.
- Write an error budget policy that says what happens when the budget runs out.
- Alert on burn rate with at least two windows, and route slow burns to tickets instead of pages.
- Read the SLA your company actually signed, and confirm it is looser than your SLO.
- Map each SLA term to the SLI that measures it.
- Review all three quarterly, using incident data as evidence.
Conclusion
The difference between SLA vs SLO vs SLI comes down to who each number is for. The SLI is for engineers: an honest measure of what users experience. The SLO is for the team: a target that decides when to ship and when to fix. The SLA is for customers: a promise with a price attached. When the three are set in that order, with the SLA safely looser than the SLO and alerts tied to error budget burn, on call becomes more predictable. Pages mean real user pain, quiet weeks mean genuine health, and contract disputes become rare. Start with one journey, one SLI and one honest target, and build from there.
