I don't really care about percentages, either. But for some industries, the difference between "two 9s" and "five 9s" can be millions of dollars, so that's why they're published that way to the customer.

Also, is anyone else getting the bitter taste of AI writing from this page?

Nah. Jim is just a decent writer (and historically has been fairly suspicious of AI)

What's the point here? That everyone should use the n-nines notation? Sure. However, companies have no inte

Skip to the last 2 paragraphs

Right. And there's nothing wrong with having regular scheduled downtime. That's obviously not appropriate for most massive scale global cloud services, but it's great for services that know their usage patterns well.

No since kernel live patching is not universal it promotes bad security practices to maximize the uptime of a single server.

You can compute them for the average. In other words, the total customer impact is the number of business-hours of downtime across all customers divided by the total number of business hours of all customers.

This is important because it's quite possible that the downtime is biased toward the times they have the most active users.

You are free to come up with a metric which weighs by the time of day (good luck with timezones though). When doing statistics having a broad overly simplistic metric which paints a broad picture is a good starting point (actually). This is usually the mean, and here it is uptime. When you see an outlier or something that doesn’t match expectations, then you go for the more complex metrics, graphs, timeseries, confidence intervals, etc. etc.

Then again if you’re a business relying on GitHub enterprise you have an SLA and you can and WILL charge GitHub for failing their SLA. Usually there’s a real measurable dollar value tied to that SLA per dollar and it’s not cheap. What surprises me in particular is that the global API and the GitHub EE API are the same which is a big no no. This is even more surprising given the fact that paying GitHub customers are clearly the minority both in numbers and code velocity. My assumption would be that GitHub is keeping EE up and the rest of free or pro users just have to suck it up. If that’s not even the case then it’s only a matter of very short time until GitHub will see businesses leave to more reliable competitors

Favorable spin? The article's point is that "12 hours a month" makes the cost very obvious, and I agree with the article.

We shouldn't be trying to spin downtime as "just a few hours a month." Those hours cost real dollars.

They're also completely irrelevant, you as a customer of a service that is down can lose the same amount of money in a 5 minutes outage or 30 days outage, if you were only relying on this service for one operation that took 1 second and had to happen during the time where the outage happened.

Depending on the service in question, no amount of downtime is acceptable, however unrealistic this is.

Yeah, this is always fun. Logarithmic graphs of downtime, people.

The 12 hours out of 30 days seems like sugarcoating the issue.

Keep the percentages, and regardless of that - GitHub fix your uptime

I'm also not sure that all downtime is really properly measured now as more and more services are connected and intertwined.

Some measure quite detailled but some just don't summarize the downtime from all providers up and below their own platforms.

`-log10(1 - uptime)`

I worked in realtime trading. No. Not at all outrageous. Quite reasonable actually. If that’s what we agreed and I need you to be reliable I will charge you back for being unreliable. I’m happy to pay top and extra dollar for the SLA but that means it needs to be acted on.

It's a contract, you're free to negotiate?

Well, someone on the business side of the house is free to negotiate. Whether engineering learns about the contract before sales has inked a 6-nines availability guarantee varies wildly by the company

The job of the uptime numbers are to look good (and sometimes to meet contractual obligations), more context doesn't make them sound better. Not being understood in layman's terms is a feature.

These companies are happy that you don't know the difference between 99%, 99.9%, and 99.99% and that you think they all sound pretty good.

As more and more things we might consider "platform" move to the cloud, I think it also matters what the service provider means by saying it's up. Just because the servers are alive and responding doesn't mean the platform is really functional.

One vendor in particular we deal with has a powerful feature which we use to a large extent. Unfortunately, that particular feature is all too often not working. The servers are up and the rest of the platform is working, but we need that feature, so if it's down, it doesn't help much that the rest of the platform is up.

These numbers are useful proxies for how likely you are to have your work disrupted outside of your own control.

If you do something 100 times a day against a four-nines service, you can reasonably expect that everything will succeed.

If you do something 10,000 times a day against a two-nines service, you can expect to hit a substantial number of errors during that day, or even have long periods where your work cannot happen at all.

People aren't frustrated with Github because Github has 98% uptime or whatever the specific number is. They're frustrated because it regularly interferes with their ability to work. The 98% number is just a concise way to say it.

There are regulatory definitions for some industries, like banking or telecommunication (in my country).

Separately from how you present the number, the very concept of "uptime" as a single number is a bit muddy in the context of a distributed system, where different components can be differently available for different users.

Also, 0.1% downtime in the form of a 45-minute outage per month is very different from 0.1% of requests failing in brief bursts. You often see downtime reported as "increased error rates" which is so vague as to be meaningless.

Google's "windowed user-uptime" attempts to deal with this a bit better, by exposing different views of the data instead of trying to condense uptime into a single number: https://www.usenix.org/system/files/nsdi20-paper-hauer.pdf

You can use -log10(1-p). On the "nines" it is exactly the number of nines you have:

    $ python3
    Python 3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import math
    >>> def nines(num):
    ...     return -math.log10(1-num)
    ... 
    >>> nines(.9)
    1.0
    >>> nines(.99)
    1.9999999999999996
    >>> nines(.999)
    2.9999999999999996

(Modulo floating point issues of course.)

Which then smoothly covers the entire space:

    >>> nines(.9321)
    1.1681302257194985
    >>> nines(.2)
    0.09691001300805639

But good luck getting that standardized.

So how about, and I’ll just throw this out there, instead of: > > GitHub Actions: 98.31% uptime. > > We say something like: > > GitHub Actions: 12 hours affected in the last 30 days (98.31% uptime).

The suggested format is equally unhelpful.

You can get 12 hours of downtime by being down once for 12 hours, or 144 times for 5 minutes. The user experience is VERY different in those two cases.

Ultimately the graphs are the most useful format.

Uptime % has the benefit that it's easy to understand.

Wider audience started to use status pages because the service unreliability became so much more noticeable than before and not the other way around. I never had to use a status page for bear blog or protonmail because i never had and issue with it or just i never noticed.

I am now _required_ to consult status page of github, circleci or MS services etc because i need to know why a build is not passing, why i cannot open a repo, why is my work stalling.

Percentages matter, it is just so much more obvious why they matter when it comes down to important pieces of the internet like github. And i highly doubt the number of 12 hours in the last month. MS has been downplaying the issues they have with GH performance for a while now and i don't think it is time to start to believe them yet. Maintaining these pieces of infrastructure is responsibility and a burden.

Overall i would be careful with "nonlinear significance of numbers near 100%" we are talking gh being well into the 90's this year and one number that infra people are also often being reminded about is that "1% is 3.5 days".

Things are tough for gh people and i feel for them but they are not a startup or a underdog of some sort to receive sympathy in that case.

I usually tell people you don't need as much reliability as you think.

Three nines reliability is great for most purposes. 8 hours downtime a year.

If your system produces money at a constant rate, it captures 99.9% of the available money. Even two nines or one nine might be pretty good on that basis, when the alternative is spending 2x or 10x as much - let's build another unreliable system with that money that captures some other independent market opportunity.

Poor reliability is a problem where you need to chain many systems together, or where the cost of a single failure is very large compared to a success. Or - as happens commonly because of load - if your periods of unreliability are correlated with periods of maximum opportunity, like an e-commerce site failing on Black Friday or a trading system failing when the market is most busy. But if you don't have one of those cases, evaluate whether investing in reliability is actually worth it to you.

GitHub is an example where two nines of reliability ought to be OK. The argument against it is that it's bad marketing to have an unreliable service, especially one aimed at software engineers. And if GitHub is largely a marketing play by Microsoft anyway (do they really make back its cost in enterprise subscriptions?) then marketing considerations need to drive its reliability.

One 12 hour outage is different to 12 1 hour outages at 3am which is different to 24 30 minute outages at 4:30pm when you're trying to commit something at the end of the day. Percentage and time are both flawed ways of looking at downtime.

Downtime really matters if it's at a time you need something to be up, and Github is big enough to have users for that to be all the time. That moves the conversation from 'It's down for a few hours a month' to 'Github is failing a significant number of it's users'.

My b