# Availability: How Much Time a System Is Up, and Why Parts Add Up

> Learn to measure uptime as a percentage, turn nines into minutes of allowed downtime, and see why a chain of parts is less available than any one part.

**In short:** Availability is the share of time a system is up, measured as a percentage, and a chain of parts is less available than any single part in it.

From "System design", a free course by Venkat R. Murty: https://designervenkat.online/learn/system-design/availability

## What You Will Learn

Availability is one of the first goals a design team writes down. It answers a simple question: when a user needs the system, is it there and working? In this lesson you will learn how to measure it, how to turn a target into minutes of allowed failure, and why a system built from several parts is usually less available than any single part. You will also see how a team picks a sensible target instead of asking for the highest number it can imagine.

Here, availability is a goal you measure and calculate. It is not a feature you add to a system. Later lessons cover the designs that raise it. This lesson gives you the arithmetic that those designs are judged by.

- **Availability:** The share of time a system is up and can answer requests correctly when users need it.
- **Uptime:** The time the system is working for its users.
- **Downtime:** The time the system is not working for its users.
- **Nines:** A short way to name an availability target. Three nines means 99.9%, four nines means 99.99%, and so on.
- **Series:** A chain of parts where every part must work for a request to succeed.
- **Parallel:** Redundant copies of a part, where one working copy is enough to keep the service going.
- **SLI (service level indicator):** A measurement of how a service behaves, such as the share of requests that succeed.
- **SLO (service level objective):** An internal target for an SLI, such as 99.9% of requests succeeding over 30 days.
- **SLA (service level agreement):** An outside promise to customers, usually with consequences if it is missed.
- **Error budget:** The amount of failure a target allows. It equals 100% minus the target.

## How Do You Measure Availability?

The basic idea is a ratio. Count the time the system works, count the time it does not, and divide the working time by the whole time. The formula is below.

$$
A = \frac{\text{uptime}}{\text{uptime} + \text{downtime}}
$$

In words: availability equals uptime divided by the sum of uptime and downtime. Multiply by 100 to get a percentage. A store that works for 364 days and fails for 1 day in a 365-day year scores 364 divided by 365, which is about 99.73%. Some teams measure the share of requests that succeed instead of the share of time. Both methods use the same idea: good work divided by all the work.

### What Do the Nines Mean?

Teams often name a target by counting nines. Each extra nine cuts the allowed downtime to one tenth of the previous amount. The cards below show the allowed downtime for a 365-day year and a 30-day month. Each value comes from multiplying the unavailable share by the number of minutes in the period.

- **99% (two nines):** About 3.65 days a year, or about 7.2 hours in a 30-day month.
- **99.9% (three nines):** About 8.76 hours a year, or about 43.2 minutes in a 30-day month.
- **99.99% (four nines):** About 52.6 minutes a year, or about 4.32 minutes in a 30-day month.
- **99.999% (five nines):** About 5.26 minutes a year, or about 26 seconds in a 30-day month.

### How Do You Turn a Target Into a Budget?

To find the downtime budget, take the unavailable share and multiply it by the length of the period. A year has 525,600 minutes, so 99.9% leaves 0.1% of that, which is 525.6 minutes. A 30-day month has 43,200 minutes, so the same target leaves 43.2 minutes. This number is the most time the system may be broken before the target is missed.

Planned work counts too if your measurement counts it. Decide what is measured before you start, so nobody argues about it after an outage.

> **Tip:** Choose the time window before you choose the number. 99.9% over a month and 99.9% over a year are two different promises, because the month is shorter and each bad minute weighs more.

## Why Do Parts Lower the Whole?

A user request often passes through several parts, such as a web server, a cache, a database and a payment provider. Each part has its own availability. The whole request is only as good as the parts it needs, in order. This is why a whole system is usually less available than each of its parts.

### Parts in Series

Parts are in series when every one of them must work for the request to succeed. In that case their availabilities multiply. The formula uses a product sign.

$$
A_{\text{total}} = A_1 \times A_2 \times \cdots \times A_n
$$

In words: the total availability equals the first part times the second part, and so on for every part in the chain. Two parts at 99.9% give 0.999 times 0.999, which is 0.998001, or about 99.8%. Five parts at 99.9% give about 99.5%. That is roughly 44 hours of downtime a year, while one part alone allows under 9 hours.

> **Tip:** A chain is never better than its weakest link, and it is usually worse. Count every dependency on the request path, including the ones that seem small.

### Redundant Copies in Parallel

Parts are in parallel when one working copy is enough. Two copies of a service, with traffic sent to whichever is healthy, fail only when both are down at the same time. The formula works with the unavailable share of each copy.

$$
A_{\text{pair}} = 1 - (1 - A_1)(1 - A_2)
$$

In words: the pair's availability equals one minus the chance that both copies are down together. Two copies at 99.9% give 1 minus 0.001 times 0.001, which is 99.9999% on paper. That number rests on two assumptions. The copies must fail independently, and the switch to the healthy copy must be quick. If both copies read the same bad setting, they can fail together, so treat the result as a ceiling and not a promise.

> **Tip:** Each added dependency on the critical path lowers the ceiling for the whole system. Ask whether a feature truly needs a part on the request path before you add it.

## Worked Example: A Checkout Page

An online store has a checkout page. To finish an order, the page needs three parts: a web server at 99.9%, a payment provider at 99.95%, and a database at 99.9%. We will find the page's real uptime, then see what a second database copy changes.

1. **List the parts on the path:** The web server, the payment provider and the database must all work for a purchase to finish. So they are in series.
2. **Multiply the availabilities:** Multiply 99.9% by 99.95% by 99.9%. The result is about 99.75%, which is lower than the best of the three parts.
3. **Turn the result into downtime:** The unavailable share is about 0.25%. Over a 365-day year that is about 1,313 minutes, or roughly 22 hours. The database alone would allow about 8.76 hours, so the checkout page does worse than any single part.
4. **Add a second database copy:** Place two database copies in parallel. On paper the pair reaches 99.9999%. The page now multiplies 99.9% by 99.95% by that pair's 99.9999%.
5. **Read the new result:** The page rises to about 99.85%, and its downtime falls to about 789 minutes, or about 13 hours a year. The web server and payment provider now set the limit. Without changing them, no database can lift the page above 99.85%.

The same calculation in Python. It uses only the standard library, so you can run it as it is.

```python
# Availability of a checkout page, computed from its parts
web = 0.999
payment = 0.9995
database = 0.999

# Parts in series: every part must work, so the numbers multiply
page = web * payment * database
print(round(page * 100, 2))
print(round((1 - page) * 525600))

# Second database copy in parallel: the pair fails only if both fail
database_pair = 1 - (1 - database) * (1 - database)
page_with_replica = web * payment * database_pair
print(round(page_with_replica * 100, 2))
print(round((1 - page_with_replica) * 525600))
```

Output:

```text
99.75
1313
99.85
789
```

## How Do You Choose a Target?

Nobody should pick 100% just because it sounds best. The product owner and the business should set the target. The choice should follow user impact and cost.

A service level objective, or SLO, is an internal target for a measured signal. For availability, the signal is the share of time or requests that work. The outside promise to customers is the service level agreement, or SLA. The SLO should be stricter than the SLA, so the team has room to act before a customer is affected.

### Setting the Error Budget

The error budget is the failure that a target allows. It equals 100% minus the target. A 99.9% SLO leaves a 0.1% error budget, which is about 43 minutes in a 30-day month. Teams can spend that budget on risky releases. When it runs out, they slow down and fix reliability first.

### What Each Extra Nine Costs

- **Engineering effort:** Each step up divides the allowed downtime by ten, but the work to earn that step grows fast.
- **Human response time:** At five nines, a person who must wake up and read an alert is usually too slow. The system has to detect and recover failures on its own.
- **Change risk:** At high targets, one bad release can use up a whole year's budget. Careful change control becomes part of the availability work.

### Not Every Feature Needs the Same Target

A payment step may deserve a tight target, while a report that runs each night can accept a looser one. Match the target to what users lose when the feature fails. Then compare the cost of the higher target with the value of the downtime it prevents. A stricter target is not automatically a better one.

> **Tip:** Write each SLO as one sentence with three parts: the measure, the window and the target. For example: 99.9% of checkout requests succeed, measured over 30 days.

## Check Yourself

Try these two short scenarios. Use the ideas from this lesson to answer them.

**Quick check:** A login service promises 99.9% availability. It calls two other services in a chain, and each of those promises 99.9%. Can the team honestly promise users 99.9% for login?

A. Yes, because every part is 99.9%, so the chain is also 99.9%
B. No, the three parts in series multiply to about 99.7%, so 99.9% is too high
C. Yes, because two parts working together always reach 99.99%
D. No, the chain is about 99.0%, so the team must promise only 99%

**Answer:** B. The login service is one of three parts in series, so the three availabilities multiply: 0.999 times 0.999 times 0.999 is about 0.997. An honest promise has to be at or below that figure, not at the level of each part.

**Quick check:** A team runs two copies of a search service. Each copy is 99.9% available, and a failed copy is replaced at once. Both copies read the same configuration file. A bad setting is saved, and it breaks the file for every copy. What is the best estimate for the pair's availability?

A. 99.9999%, because two copies always beat one
B. About 99.9%, because one bad shared setting can take both copies down together
C. About 99.99%, because the copies share the load
D. About 99.0%, because two copies double the risk

**Answer:** B. The parallel formula assumes the copies fail independently. A shared setting breaks that assumption, so both copies can fail at the same time. The 99.9999% figure is only a ceiling, and a real estimate must account for the shared risk.

## Key Takeaways

- **Measure it the same way every time:** Availability is uptime divided by total time. Name the time window before you name the number.
- **Multiply the chain:** Parts in series multiply, so every dependency lowers the total. Parts in parallel can raise it, but only if their failures are truly separate.
- **Pick a target on purpose:** Tie the SLO to user impact and cost. Each extra nine costs far more than the one before it, so not every feature needs the same target.

## Sources

- [Wikipedia: Availability (series and parallel formulas)](https://en.wikipedia.org/wiki/Availability)
- [Wikipedia: High availability (downtime per year table)](https://en.wikipedia.org/wiki/High_availability)
- [Control Plane: What Is High Availability? How Many Nines You Need](https://controlplane.com/blog/post/what-is-high-availability-how-it-works-and-how-many-nines-you-actually-need)
- [Control Plane: SaaS Uptime SLAs and Engineering 99.99%](https://controlplane.com/blog/post/saas-uptime-sla-enterprise-99-99)
- [AlgoMaster: Availability (system design)](https://algomaster.io/learn/system-design/availability)
- [DesignGurus: Availability (Grokking System Design Fundamentals)](https://www.designgurus.io/course-play/grokking-system-design-fundamentals/doc/availability)
- [Google SRE Book: IT Service Management and Tenets of SRE](https://sre.google/sre-book/introduction/)
- [Google SRE Book: Service Level Objectives](https://sre.google/sre-book/service-level-objectives/)
- [Google SRE Book: Embracing Risk](https://sre.google/sre-book/embracing-risk/)
- [ClickHouse: SLOs, SLIs, and SLAs explained](https://clickhouse.com/resources/engineering/slo-sli-sla)
- [4calculators: System Availability Calculator (series, parallel, k-of-n)](https://4calculators.com/calculators/system-availability-series-parallel-calculator/)
- [TechSense: What Is an SRE Error Budget at 99.9% Uptime](https://techsensedev.com/insights/what-is-an-sre-error-budget-and-how-do-you-set-one-for-999-uptime)
- [Alex Ewerlöf: Composite SLO](https://blog.alexewerlof.com/p/composite-slo)
- [Availability, SLAs and the Nines (fp-system-design)](https://fp-system-design.pages.dev/foundations/availability-slas-and-nines/)
