Your Uptime Target Is a Product Decision. Engineering Probably Made It.


a rack of electronic equipment in a dark room

The reliability target on your product is one of the most expensive numbers your team will ever commit to, and in most companies a product manager had nothing to do with choosing it.

Somebody wrote “99.99%” into a design doc, or an SLA template, or a sales contract, and it stuck. From that moment it quietly decided how often your team can ship, how much of every sprint goes to hardening instead of features, and how many people get paged at 3 a.m. That is a product decision. It gets made as an engineering default because nobody on the product side asked to make it.

The tool that turns that number into something a product manager can actually manage is the error budget. It is not new. Google’s site reliability engineering teams published the idea a decade ago. What’s surprising is how many product teams still treat it as an operations concept that lives on someone else’s dashboard.

What a nine actually buys

Start with the arithmetic, because the numbers are smaller than people expect. In an average month of about 30.4 days, here is how much downtime each common target allows:

Availability target Allowed downtime per month
99% about 7 hours 18 minutes
99.9% about 44 minutes
99.95% about 22 minutes
99.99% about 4 minutes 23 seconds
99.999% about 26 seconds

Look at the jump from three nines to four. At 99.9%, a bad deploy that takes twenty minutes to detect and roll back is survivable inside the month. At 99.99%, the same deploy blows through the entire month’s allowance before the rollback finishes. Four nines is not “a bit more reliable.” It is a different operating model: automated canaries, instant rollback, redundancy across regions, and on-call engineers who can respond inside minutes, all day, every day.

The Google SRE book’s chapter on embracing risk makes the cost curve explicit: “an incremental improvement in reliability may cost 100x more than the previous increment.” It also makes the point every product manager should carry into these conversations: “100% is probably never the right reliability target,” partly because users can’t perceive the difference past a certain point. The book’s example is blunt. A user on a 99% reliable smartphone “cannot tell the difference between 99.99% and 99.999% service reliability!” Their phone, their Wi-Fi and their mobile carrier fail more often than your service does.

So the question is never “how reliable can we be?” It’s “how reliable do our users need us to be, and what are we willing to stop doing to get there?” That second half is a roadmap question.

The error budget is the part product should care about

An error budget is the inverse of the target. The example error budget policy in Google’s SRE workbook defines it in one line: “An error budget is 1 minus the SLO of the service.” Set a 99.9% objective and you have a 0.1% budget, roughly 44 minutes a month, to spend.

The word “spend” is the whole idea. The budget is not a failure allowance you hope to leave untouched. It is capacity for risk. Every release carries some chance of breaking something. Every experiment, migration and infrastructure change does too. If the service is running far above its target month after month, the budget is going unused, which means the team is moving more cautiously than the business needs. That unused margin could have been faster releases, a bolder experiment, or a migration finally done in daylight instead of a 2 a.m. window.

When the budget runs low, the logic flips. The SRE book describes the original arrangement plainly: “Product Management defines an SLO,” and if violations are frequent enough to use up the budget, “releases are temporarily halted.” Nobody argues about whether the release is worth the risk this time. The budget already answered.

This is why I think of the error budget as one of the better prioritization tools a product manager has, not an engineering metric. Most reliability arguments are two groups talking past each other: product wants to ship, operations wants stability, and whoever escalates louder wins. The budget replaces that argument with a shared number that both sides agreed to in advance. Product gets permission to move fast while the budget is healthy. Operations gets a guaranteed brake when it isn’t.

Who should set the target, and how

Notice the sentence in Google’s own description: product management defines the objective. In practice, the teams I’ve seen get this right treat the target as a negotiation with three inputs.

What users actually experience. Measure availability the way a customer feels it, not the way a server reports it. “The API returned a 200” is a server’s view. “The customer completed checkout in under three seconds” is the user’s view. Pick the two or three journeys that matter most (sign in, the core action, payment) and set targets on those. A dashboard full of CPU graphs tells you nothing about whether people could do their job today.

What the contract already promises. Check what sales has signed before you pick a number. AWS’s compute SLA commits to 99.99% monthly uptime at the region level, with service credits of 10%, 30% or 100% as availability drops through each tier. That is the shape most B2B contracts copy. If your enterprise customers have a 99.9% SLA with credits, your internal objective needs to sit comfortably above it, so that you burn your own budget long before you start writing refund checks.

What the dependencies make possible. You cannot be more reliable than the things you are built on, unless you pay heavily to route around them. On October 20, 2025, a latent race condition in the DNS automation for Amazon DynamoDB left the regional endpoint in us-east-1 with an empty DNS record. According to AWS’s own post-event summary, DNS failures began at 11:48 p.m. Pacific on October 19, the DNS records were restored by 2:25 a.m., and knock-on effects through EC2 and Network Load Balancer kept the event going until 2:20 p.m. That’s roughly fourteen and a half hours. Any product running in that single region with a 99.99% monthly target used about 200 months of budget in one day. Promising four nines on a single-region architecture is a promise the architecture can’t keep.

Put those three inputs side by side and the right number usually becomes obvious. It is almost always lower than the number someone wrote down by default, and it is almost always different for different parts of the product.

A five-nines habit in a three-nines product

I spent a long stretch of my career in IT operations at a large telecom, and carrier culture runs on five nines. The voice network had to be there when someone dialed an emergency number, and that standard was earned. The problem was that the standard leaked. The same change controls built for core network gear got applied to an internal ordering portal and a customer self-serve web tool, neither of which anyone would miss for twenty minutes on a Tuesday afternoon.

The result was predictable once you saw it. Releases to those tools could only go out in overnight maintenance windows, which meant monthly batches, which meant every release was large, which meant every release was risky, which seemed to justify the heavy controls. We were spending reliability effort as if we were protecting 26 seconds a month on a system where nobody would notice 44 minutes. When we finally split the targets by service, the portal team moved to daytime releases within a quarter, the batches got smaller, and the change failure rate went down, not up. That is the same pattern behind separating deploy from release: smaller changes are easier to ship safely, and over-strict reliability targets push you toward bigger ones.

The lesson I took from it: an unrealistically high target doesn’t make a product more reliable. It makes the team slower and the releases bigger, and eventually it makes the target meaningless, because everyone learns it’s impossible and stops paying attention to it.

Averages hide the customers you lose

Fleet-wide availability can look excellent while a handful of customers have the worst month of their business year.

Atlassian’s post-incident review of its April 2022 outage is the clearest example on record. A maintenance script meant to delete a legacy app was run with site IDs instead of app IDs, and 883 sites belonging to 775 customers were deleted. Atlassian noted that over 99.6% of its customers and users carried on without disruption. For some of the 775, the outage lasted up to 14 days. Because the deletion also removed contact data, some affected admins couldn’t even file a support ticket through the normal form.

Measured across the whole customer base, that month barely dents an availability number. Measured from inside one of those 775 companies, the product was simply gone for two weeks. Both statements are true, and only one of them predicts churn.

This is the strongest argument for product involvement in how the objective is measured, not just what it is. A few questions worth asking before you sign off on any target:

  • Is it measured per customer or across the fleet? If your largest accounts sit on shared infrastructure that can fail together, a per-tenant view matters more than the global average.
  • Does it count partial failure? A feature that loads but silently drops saved changes is “up” by most monitoring and “down” by any customer’s definition.
  • Does the measurement window match how customers remember pain? A 30-day rolling window forgives a terrible week by the end of the month. Your customer’s renewal conversation will not.

Write the policy before you need it

An error budget only works if the consequences are agreed while everyone is calm. The worst time to negotiate a release freeze is the afternoon before a launch, with the budget already gone and a sales VP on the thread.

The Google workbook’s example policy is worth reading in full because it is short and specific. A few of its rules translate directly to most product teams:

  • When the budget is exhausted, changes stop. The policy’s wording is that the team “will halt all changes and releases other than P0 issues or security fixes” until the service is back within its objective.
  • One big incident triggers a postmortem. If a single incident consumes more than 20% of the four-week budget, the team must hold a postmortem with at least one top-priority action item on the root cause.
  • Recurring problems get roadmap space. If one class of outage uses more than 20% of the budget over a quarter, fixing it becomes a top-priority item in the quarterly plan. That’s reliability work earning a slot on the roadmap through evidence instead of lobbying.
  • Not every miss freezes features. If the overrun came from a company-wide network failure or another team’s service, feature work can continue. The freeze is for problems the team can actually fix.
  • Disputes have a named tiebreaker. Disagreements over the calculation or the response go to the CTO, so the argument has an end.

The policy also carries named approvers and a revisit date. That detail matters more than it looks. A policy with a product leader’s name on it is one the product leader has to honor when it’s inconvenient. A policy that lives only in the operations wiki will be overridden the first time a launch date is at risk.

When the budget runs out the week of a launch

Sooner or later this happens: the budget is spent, the policy says freeze, and the launch your executives announced is scheduled for Thursday.

This is the moment the whole arrangement is tested, and it’s where product managers either make error budgets real or quietly kill them. Two moves help.

First, separate the launch from the release. If the code is already deployed behind a flag, “launch” is a configuration change and a marketing moment, not a deploy. The freeze stops new risk entering production. Turning on a feature that has been sitting dark and tested for two weeks is a judgment call you can make explicitly, with the people the policy names, rather than an exception you sneak through. It also helps to have a clean flag inventory, which is a separate habit worth building; we covered what forgotten flags cost recently.

Second, if you do grant an exception, write it down and make it cost something. An exception that consumes nothing teaches everyone that the budget is negotiable. An exception that comes with a committed reliability item in the next sprint, owned by the team that asked for it, keeps the budget meaningful. It’s the same principle as treating technical debt as a product decision: the cost is real either way, and the only choice is whether someone decides on purpose.

The teams that run this well don’t talk much about reliability in planning meetings. They don’t need to. The number was set by the people accountable for the product, it reflects what users actually notice, and everybody knows what happens when it runs out. That is a better deal for product than the alternative, which is inheriting a target you never chose and finding out what it costs one frozen release at a time.

Ty Sutherland

Ty Sutherland is the editor of Product Management Resources. With a quarter-century of product expertise under his belt, Ty is a seasoned veteran in the world of product management. A dedicated student of lean principles, he is driven by the ambition to transform organizations into Exponential Organizations (ExO) with a massive transformative purpose. Ty's passion isn't just limited to theory; he's an avid experimenter, always eager to try out a myriad of products and services. While he has a soft spot for tools that enhance the lives of product managers, his curiosity knows no bounds. If you're ever looking for him online, there's a good chance he's scouring his favorite site, Product Hunt, for the next big thing. Join Ty as he navigates the ever-evolving product landscape, sharing insights, reviews, and invaluable lessons from his vast experience.

Recent Posts