esc
  • WorkflowsPages
  • Case studiesPages
  • Machine Learning FoundationsLearn
  • AI EngineeringLearn
  • AI Guardrails & Red TeamingLearn
  • UI/UXLearn
  • Design SystemsLearn
  • Production System DesignLearn
  • Book a callContact
  • Download ResumeContact
Let’s talk

I’ll build the agent for it.

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.

10 min readFree

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.

Key words

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=uptimeuptime+downtimeA = \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.

Atotal=A1×A2×⋯×AnA_{\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.

Apair=1−(1−A1)(1−A2)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. 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. 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. 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. 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. 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

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?

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?

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

How is this lesson?

Last updated on 18 November 2026

Learn with me

Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.