The website answers its health checks and the infrastructure dashboard says 99.9% uptime. A customer still cannot save a booking, and another receives an outdated report. Those experiences are not captured by a monitor that only loads the homepage. Reliability should be measured around the actions that users need to complete, including whether results arrive on time and are correct. Otherwise a green status page can coexist with a broken product.

All three experiences can coexist with a reassuring availability number. Monitoring may be checking whether a server responds, while customers need entire sequences of actions to work correctly.

A useful reliability program begins with what people are trying to accomplish. Uptime is one signal in that program, not a complete account of service quality.

Availability needs a denominator

An availability percentage is a ratio. But what belongs in the numerator and denominator? A monitor might count minutes when a homepage answers an HTTP request. A product team might count valid user requests that complete successfully. A finance manager might care whether scheduled statements are correct before a reporting deadline.

Those are different measurements, and each can give a different result for the same incident.

The Google SRE availability table illustrates conventional availability targets. Under a simple time-based calculation, 99.9% availability permits about 43.2 minutes of unavailability in a 30-day period. That number is useful for planning, but it makes assumptions about how downtime is measured.

If a service fails for ten minutes at the busiest hour, it could affect thousands of requests. A different failure occurring when almost nobody uses the product might have a smaller user impact. Time-based uptime treats the two periods similarly.

Google's discussion explains why measuring the proportion of failed operations can be more meaningful for services where only some requests fail. A realistic service level indicator should match the experience the business wants to protect.

Identify the customer journey first

Imagine a small rental-management product. A customer opens the calendar, selects a property, creates a reservation and assigns a cleaner. A monitoring check that retrieves the homepage does not establish that this workflow succeeds.

Map the steps and the systems involved. The calendar may depend on a database, the reservation save may publish a message, and the cleaner assignment may rely on a background worker. One broken component can make the customer's task fail while the website remains reachable.

Select a small number of journeys that represent the product's core value. For a payments service, that might be authorizing a payment. For an editorial website, it might be opening an article. For a payroll platform, generating an accurate payroll run matters more than loading the login screen.

The Google SRE Workbook chapter on implementing SLOs recommends selecting service level indicators that reflect user experience and making pragmatic decisions about coverage. Trying to measure everything at once can produce a complicated dashboard nobody acts on.

A sensible first journey is one that fails visibly, affects customers and can be measured consistently.

Distinguish speed, correctness and freshness

A successful request can still be useless. A report that takes 40 seconds might be technically delivered but effectively unusable. A financial summary that loads instantly with incorrect totals is worse. A schedule that shows yesterday's changes may create double bookings.

Availability measures whether an operation succeeds under a defined criterion. Latency measures whether it finishes quickly enough. Data freshness measures whether results reflect changes within an acceptable period. Correctness requires validation against the intended business rules.

Not every product needs separate metrics for each dimension, and reliable correctness measurement can be difficult. But naming the distinction forces the team to recognize why a green dashboard might be misleading.

Choose thresholds from actual user needs. If a customer uses a report once a month, its acceptable delay may differ from a live payment confirmation. A statement about an industry's "normal" latency is less valuable than evidence from the particular workflow.

An indicator should be measurable and understandable. A percentage built from undocumented exclusions cannot support good decisions.

What 99.9% means in practice

Suppose an API receives 100,000 valid booking-save requests during four weeks. The product commits to a service level objective of 99.9% successful saves. Under that request-based definition, 100 failures fit within the period's allowable failure count.

That does not mean the team should deliberately cause 100 failures. It means that the chosen objective acknowledges some error is possible and provides a common way to compare reliability with competing development priorities.

This allowable amount is called an error budget. Google's SRE error-budget policy demonstrates how a team might use the budget to decide when to slow feature releases and devote more attention to reliability.

The choice of 99.9% is not automatically appropriate. A system that handles safety-critical activity may need different requirements. A small internal tool may justify a less demanding objective. Setting an implausibly strict target can produce expensive work without a corresponding benefit; setting one too loose can normalize unacceptable failures.

The objective needs agreement between the people who build the service and those accountable for customer outcomes.

A dashboard can be green for the wrong audience

Consider a platform with ten large customers and ten thousand small users. If almost all successful requests come from the smaller users, aggregate availability may remain excellent while one large customer's integration fails completely.

A different distortion can arise across regions, devices or subscription plans. An API used primarily by mobile clients may fail for those clients while desktop web checks succeed. Background jobs may silently accumulate a backlog while online requests continue to return success.

Review the experience of meaningful segments, but avoid exposing private customer data in monitoring. Segment by journey, application version or region where appropriate, and investigate whether aggregate results conceal a serious local failure.

Averages can also hide long tail latency. A median response time of 200 milliseconds says little about the slowest requests. Users whose actions fall into the worst-performing fraction may experience a product that feels broken.

A service level indicator should help discover that disparity rather than erase it.

Alert on impact, not every fluctuation

A team that receives hundreds of alerts a night may learn to ignore the system. A team that receives none may discover problems first through customer complaints.

Good alerting focuses on events that require a timely response. A serious error-budget burn across a critical journey may justify paging an operator. A nonurgent drift in resource usage might belong in a daily review rather than a midnight notification.

The Google error-budget policy describes using reliability outcomes to guide operational priorities. Its exact thresholds are examples of one organization's policy, not universal requirements.

For a small company, start with a practical escalation rule. Define what condition constitutes customer harm, who gets alerted and how that person verifies the event. A symptom-oriented alert, such as failed reservation saves, can be more useful than a generic CPU warning that may or may not correspond to user impact.

Review alerts after incidents. If they fire during harmless conditions, improve them. If customers report problems before monitoring does, identify the missing signal.

Reliability requires a response plan

Measurement only matters when it informs decisions. The next question after an alert is what the team can safely do.

A rollback may fix a faulty release. A queue backlog may require investigation into worker capacity or malformed messages. A database issue may call for reducing load or switching to a prepared recovery route. None of these actions should be improvised blindly during an outage.

Document known failure modes and boundaries. Which operations are safe to retry? What must not be repeated? Who may change production configuration? When should the team stop accepting new work to prevent inconsistent records?

After a significant incident, hold a review focused on the sequence of events and the systems that allowed the problem to escalate. Blame is a poor substitute for technical understanding. The useful output is a set of corrective actions someone will actually complete.

A team that can explain its most common failures and its response choices is usually in a better position than one that has only accumulated monitoring graphs.

A small-team implementation plan

Choose the single action a paying customer values most. Write its start and successful end conditions, then instrument failures and elapsed time. Confirm that logs and monitoring do not expose private content unnecessarily.

Collect a baseline before announcing a target. Review which failures genuinely affected customers, which were invalid requests and which came from test traffic. Select an objective that balances the consequences of failure with the cost of maintaining the system.

Make the metric visible alongside releases and customer reports. When it breaches the agreed threshold, investigate rather than changing the chart definition to make the warning disappear. Revisit the objective when the product or user expectations change.

The plan does not require an enormous monitoring platform. Clear definitions and one dependable signal are a better start than dozens of dashboards whose relationship to customer value nobody can explain.

A server can answer every health check while the business process it supports is failing. Reliability begins when the team measures whether customers can complete the work they came to do.

SOURCES & FURTHER READING

References and background

Our explainers link to source documents so readers can explore the evidence and interpret it in context. Websites and policies may change after publication.

  1. Google SRE, *Availability Table*sre.google
  2. Google SRE Workbook, *Error Budget Policy*sre.google
  3. Google SRE Workbook, *Implementing SLOs*sre.google
Spot a factual issue? Request a correction ↗Read our editorial standards ↗