Lesson 2.3• 5 min read

Availability in numbers

Calculating compound availability for series vs parallel paths and SLA downtime budgets.

What you will learn

Measure availability by time and by successful requests.
Combine tiers in series and instances in parallel.
Turn a number of nines into a downtime budget.

The mathematical laws of availability

Availability is usually quantified as the share of time a service is up:

\text{Availability} = \frac{\text{Uptime}}{\text{Uptime} + \text{Downtime}}

For a service spread across many machines and regions, "up" is rarely all-or-nothing, so Google's SRE practice measures request-based availability instead: the proportion of requests that succeed over a rolling window (for example, one day).

\text{Availability} = \frac{\text{Successful requests}}{\text{Total requests}}

The formulas below combine components. They assume components fail independently; shared power, network, software bugs or bad deploys break that assumption, so real redundancy gains are smaller than the arithmetic suggests.

1. Components in series (multiplicative degradation)

If a system requires $k$ distinct tiers in sequence to process a request (e.g. DNS $\to$ Load Balancer $\to$ App Server $\to$ Database), the total availability is the product of all tier availabilities:

A_{\text{series}} = \prod_{i=1}^k A_i = A_1 \times A_2 \times \dots \times A_k

Critical insight: Whenever every component is below $100\%$ , the compound availability of sequential components is lower than that of the least available component. If each of 4 tiers has $99.9\%$ availability:

A = (0.999)^4 = 0.996006 = 99.60\% \quad (\text{Downtime increases from } 8.7\text{ hrs to } 35\text{ hrs/yr}!)

2. Components in parallel (redundancy amplification)

When $n$ identical redundant instances run in parallel such that any one healthy instance satisfies demand, the tier fails only if all instances fail simultaneously:

A_{\text{parallel}} = 1 - \prod_{j=1}^n (1 - A_j) = 1 - (1 - A)^n

If a single instance has $A = 99.9\%$ ( $1 - A = 0.001$ ):

$2\text{ instances in parallel}: 1 - (0.001)^2 = 0.999999 = 99.9999\% \quad (\text{Six nines!})$
$3\text{ instances in parallel}: 1 - (0.001)^3 = 0.999999999 = 99.9999999\% \quad (\text{Nine nines!})$

The "Nines" downtime budget reference

99% ("Two nines"): 3.65 days / year • 7.30 hours / month • 14.40 minutes / day
99.9% ("Three nines"): 8.77 hours / year • 43.83 minutes / month • 1.44 minutes / day
99.99% ("Four nines"): 52.60 minutes / year • 4.38 minutes / month • 8.64 seconds / day
99.999% ("Five nines"): 5.26 minutes / year • 26.30 seconds / month • 0.86 seconds / day

For scale, Amazon EC2's service level agreement (last updated May 2022) commits to $99.99\%$ monthly uptime for a region and $99.5\%$ for a single instance: one machine is far less available than a well-spread fleet.

Availability in series and in parallel

Sequential tiers in series (k):

Parallel redundancy (n / tier):

Single instance baseline (A):

Single tier availability:

99.9999%

1 - (1 - 0.999)^2

Total system availability:

99.9997%

(Tier A)^3

Allowed downtime / year:

1.58 minutes

7.89 seconds / month

Figure 3: Multi-tier compound availability combining series tiers and parallel instances.

Key takeaways

Tiers in series multiply: four tiers at 99.9% give 99.6%, lower than any one of them.
Instances in parallel fail only together: $1 - (1 - A)^n$ , so two instances at 99.9% give six nines.
The arithmetic assumes independent failures; shared power, networks, bugs and deploys make real gains smaller.
Each extra nine cuts the downtime budget tenfold: 99.9% allows about 8.8 hours a year, 99.99% about 53 minutes.

Sources

Adapted from The System Design Primer by Donne Martin, licensed under CC BY 4.0. Changes were made.