# A 99.9% SLA leaves you 86 seconds of downtime a day

> Multiply that across a database, a third-party API and a two-minute failover, and the easy promise starts to crack.

Original: https://fdetimes.net/en/guides/sla-99-9-downtime-budget-failover/

The meeting is nearly over when the customer's procurement lead asks: "Can you commit to 99.9%?" Everyone turns to you, because you built the system. You can nod straight away, since the number sounds fairly safe, or you can ask for ten minutes to do the maths.

For an FDE, this is the moment technical skill turns into a contractual commitment. Nod wrongly and your team pays with on-call nights and a customer who has lost trust. Get the numbers right and you know exactly what the architecture needs, or which wording in the contract has to change.

This article walks through those ten minutes: converting percentages into minutes, multiplying availability across the dependency chain, then deciding where failover and replication belong.

## 99.9% is really 43 minutes a month

AWS defines availability as the share of time a workload is usable out of total time, over a period such as a month or a year. So the first job is to turn the percentage into units people understand.

According to the calculator at uptime.is, 99.9% corresponds to about 43 minutes 50 seconds of downtime a month and 8 hours 45 minutes 57 seconds a year. Broken down further, that is about 10 minutes 5 seconds a week and just 1 minute 26 seconds a day.

The daily figure is the one worth remembering. A single deploy that restarts a service for two minutes uses up a whole day's budget. Google SRE calls this the error budget: an objective measure of how much unreliability a service is allowed. A budget has to be planned and spent deliberately.

It also helps to know where 99.9% sits on the scale. AWS places this level at internal tools such as knowledge management or project tracking, while e-commerce and point-of-sale systems are placed at 99.95%.

If a customer building a payment system asks only for 99.9%, that is a signal to check what they actually expect.

## How does a dependency chain erode the commitment?

Imagine you are deploying an internal document-search tool for a customer. The minimal setup is one app server and one database, each on a single machine, each at 99.9%. Every request has to pass through both, so these are two hard dependencies in series.

Serial availability is the product of its components. The System Design Primer works it out: two 99.9% components in series give only 99.8%. Carry the calculation on and the downtime budget doubles, to about 1 hour 27 minutes a month. You have added nothing and already broken the commitment.

The longer the chain, the worse it gets. AWS gives the example of three 99.99% components in series dropping to 99.97%. In practice your chain also includes DNS, a load balancer, the customer's authentication service and perhaps a third-party API. Every link belongs in the multiplication.

The fix is independent redundancy. According to AWS, two independent components running in parallel, each at 99.9%, give an effective availability of 99.9999%, because the system fails only when both fail together.

| Option | Estimated availability | Downtime per month (estimate) |
|---|---|---|
| 1 app + 1 database | 99.8% | about 1 hr 27 min |
| 1 app + 2 databases in parallel | about 99.8999% | about 43 min 53 s |
| 2 apps + 2 databases in parallel | about 99.9998% | a few seconds |

The middle row is the main lesson. Doubling the database is not enough, because a single app server at 99.9% still drags the whole system just below the commitment. Your weakest single component sets your number.

**Key point:** An SLA commitment holds only once you have multiplied the availability of everything it depends on.

Don't take the last row on trust. The calculation assumes the two copies fail independently and that switchover is instant. Two databases in the same rack with the same patch level are not independent. And whether switchover is instant depends on how you do failover.

## What do failover and replication buy, and what do they cost?

The System Design Primer describes failover and replication as two complementary patterns for high availability. Failover decides who serves traffic when a node dies. Replication decides whether the replacement node has the latest data.

In an active-passive setup, two machines exchange heartbeats. When the heartbeat stops, the passive machine takes over the active machine's IP address and carries on serving. Downtime during the switch depends on whether the passive machine is a hot standby, already running, or a cold standby that has to start from scratch.

This is where the daily budget becomes concrete. A cold standby that takes a few minutes to come up burns more than a day's budget on every incident. Before writing "has failover" in an architecture document, measure how long it actually takes.

Failover has other costs too. It needs extra hardware, adds complexity, and can lose data if the active machine fails before new writes have been replicated to the passive one. For a customer recording orders or records, losing a few seconds of data can be worse than a few minutes of downtime, so ask them which they fear more.

At the far end is the Geode pattern described by Microsoft: active-active deployment across multiple geographic regions, using data replication to survive the loss of an entire region. For a 99.9% commitment on an internal tool, that is usually overkill.

One often-forgotten lever is recovery time. AWS notes that availability can be estimated from MTBF, the mean time between failures, and MTTR, the mean time to repair.

With an MTBF of 150 days and an MTTR of 1 hour, the estimate is 99.97%. Cutting MTTR with runbooks, good alerting and automated rollback is sometimes cheaper than buying more machines.

## Contract wording matters as much as architecture

For the same system, two ways of defining the SLA can produce very different results. The first thing to examine is planned maintenance. Some customers choose to exclude it from total time, but AWS is clear that this is not advisable, because users still want to use the service during those windows.

Practical advice: if the customer proposes the exclusion, you gain some breathing room. But don't design the system around it. If monthly maintenance needs an hour of downtime, you have an architecture problem, not a contract problem.

The second point is the unit of measurement. AWS suggests that for many services it is easier to count successful requests against total valid requests than to measure "usable time", typically over 1- or 5-minute windows. This better reflects user experience, but you must agree with the customer on what counts as a valid request and what counts as a failure.

## The five steps in those ten minutes

Back to the meeting. First, convert the number the customer asked for into minutes per day and per month, and say it aloud so the whole room understands. Next, draw the hard dependency chain on the whiteboard, including the customer's own pieces such as their login system.

Step three is to multiply serial availability to find the weak point, then propose redundancy exactly there. Step four: ask whether the customer fears downtime or data loss more, to choose between hot and cold standby and decide how to replicate. The final step is to fix the measurement definition in writing before agreeing the number.

## Common mistakes

The most common mistake is committing based on the availability of only the part you wrote, forgetting the dependencies. The second is duplicating a component and trusting the 99.9999% figure without checking whether the two copies are truly independent. The third is having failover on paper but never measuring the real switchover time.

If you are preparing to apply for FDE roles, look for phrases in job descriptions such as "own production deployments" or "customer-facing SLAs". On a CV, a line like "recalculated the SLA for a three-component system, added a hot standby for the database, measured failover under one minute" is far more convincing than "experienced in high availability".

This week's exercise: pick a system you run, draw its dependency chain, multiply out the overall number, then ask yourself whether you would dare sign 99.9% for it. If the answer is no, you know exactly which link to fix.

**Try this week:**

- Draw the hard dependency chain of a system you run, note the availability of each component and multiply out the overall figure.
- Measure the real failover time of your database or load balancer in staging, and compare it with the budget of 1 minute 26 seconds a day.
- Write a half-page SLA definition: time-based or request-based, how long the measurement window is, and whether planned maintenance is excluded.

## Sources

- [SLA & Uptime calculator: How much downtime corresponds to 99.9 % uptime](https://uptime.is/)

- [Availability - AWS Well-Architected Framework (Reliability Pillar)](https://docs.aws.amazon.com/wellarchitected/latest/reliability-pillar/availability.html)

- [system-design-primer (Fail-over section)](https://github.com/donnemartin/system-design-primer?tab=readme-ov-file#fail-over)

- [Active-Passive vs. Active-Active Failover (Serverion)](https://www.serverion.com/uncategorized/active-passive-vs-active-active-failover/)

- [Google SRE Book: Embracing Risk](https://sre.google/sre-book/embracing-risk/)

- [Architecture design patterns that support reliability - Microsoft Azure Well-Architected Framework](https://learn.microsoft.com/en-us/azure/architecture/framework/resiliency/reliability-patterns)
