← back to the index

how we calculate the death index

The thesis

As AI adoption accelerates across every product category, does overall service reliability degrade? The Death Index tracks this by treating internet service reliability like a market index — a single composite score representing ecosystem health.

We don't care if one particular service is down right now. We care about the trend. Is the internet getting worse?

Data source

We pull incident data from publicly available Atlassian Statuspage APIs. Hundreds of major companies use Statuspage to run their public status pages, and each one exposes a consistent JSON API at /api/v2/incidents.json.

We currently track 50 providers across 6 categories: cloud infrastructure, AI, developer tools, productivity, communications, and fintech.

Only real service degradation is counted. Incidents with impact: "none" (informational posts, rollout notices) or impact: "maintenance" (scheduled work filed as an incident) are filtered out, as is any impact level we don't recognise. An incident starts when the provider says the problem began (started_at), which is sometimes earlier than when it was posted.

How much history we have

The Statuspage API only returns each provider's ~50 most recent incidents, with no way to page further back. So we don't have years of history: we have what we've collected since we started checking daily, plus whatever was still in each feed at the time. For a busy provider that's a few weeks; for a quiet one it can be much longer.

A provider's data counts as complete from the oldest incident we've seen in its feed, as long as each check overlaps the previous one. If we miss enough checks that incidents could have scrolled off the feed in between, its complete record restarts from that point.

A provider covers a day when its data is complete for that day's whole 7-day window. We only publish the index for days where at least 80% of providers are covered, and uncovered providers are left out of that day rather than counted as perfect. That's why the chart starts when it does.

Per-provider scoring: the severity envelope

Each provider gets a daily reliability score from 0 to 100, computed as a 7-day rolling average.

The problem with naive scoring: Not all providers report incidents the same way. Some (like Twilio) log every individual carrier route issue as a separate incident — so "SMS delays to 5 carriers" becomes 5 overlapping minor incidents. Others roll the same situation into one. If we simply sum deductions per incident, granular reporters get unfairly penalized.

Our solution: the severity envelope. Instead of counting incidents, we ask: at any given moment during the day, what was the worst thing happening?

For each day, we build a timeline and find the maximum severity active at each moment:

  • 5 overlapping minor incidents = same score as 1 minor incident covering the same period
  • A minor + a major happening simultaneously = scored as major for the overlap
  • Two non-overlapping incidents both count fully — they're separate periods of degradation

We then deduct from 100 based on how many hours fell into each severity tier:

Max severity at that momentPoints deducted per hour
Minor — degraded performance5
Major — partial outage15
Critical — full outage30

Severity floors: a day can only fall so far for the worst severity it saw, so a minor issue left in "monitoring" all day isn't scored like a full outage:

Worst severity that dayLowest possible day score
Minor70
Major40
Critical0

The provider's score is the average of the 7 daily scores ending on that date. This means a bad day drags the score down for a week, then naturally rolls off.

Daily scoring: a day is scored once it's over (UTC), so today isn't on the index yet. Each run rescores the last 8 days, so incidents resolved or reclassified after the fact still land on the right days; older days stay fixed. Scores keep full precision throughout and are only rounded for display.

Duration caps: Some providers leave incidents open on their status page for weeks — not because there's an active outage, but because it's a known issue being tracked. A "minor" GPU booting issue open for 118 days is not the same as 118 days of downtime. To prevent stale entries from permanently tanking a score, we cap the scoring impact of any single incident:

SeverityMax scoring duration
Critical3 days — real critical outages get resolved fast
Major5 days
Minor7 days — minor issues can linger longer

The raw incident data is still stored with real dates — the cap only applies during score computation.

Example: A provider has 3 overlapping minor SMS delivery incidents from 10am–2pm (4 hours), plus 1 major API outage from 1pm–2pm (1 hour). The envelope is: 3 hours minor + 1 hour major. Score: 100 − (3×5 + 1×15) = 70. Without the envelope model, this would score 100 − (4×5 + 4×5 + 4×5 + 1×15) = 25 — a massive over-penalty.

Category scores

Providers are grouped into categories. Each category's score is the simple average of its provider scores — every provider within a category has equal weight.

Current categories:

  • Cloud Infrastructure
  • AI Services
  • Developer Tools
  • Productivity
  • Communications
  • Fintech

The Death Index (global score)

Global reliability is the average of all category scores, with equal weight per category. This prevents any one category with lots of providers (e.g., developer tools) from dominating the index.

The Death Index is that number flipped, so higher is worse:

Death Index = 100 − global reliability

0 means every service had a clean week; 100 means everything was down. Category numbers on the site are flipped the same way.

A provider is only included for a given date if it covers that date (see how much history we have). This avoids inflating the score with providers we have no real data for.

Normal

The shaded "normal" range on the index and category charts is the middle half of all past values (25th to 75th percentile). A reading above it is worse than usual.

The clock

The clock is a picture of the same number, after the Bulletin of the Atomic Scientists' Doomsday Clock: at 0 the hand points to six o'clock, and it sweeps up to midnight as the index approaches 100.

Right now

The index is scored once a day, after each day ends. The "having issues right now" list is separate: every few minutes we read each provider's current status (the same status page, its status.json summary) and list any that report a minor, major or critical problem. Maintenance doesn't count.

Data

The numbers are free to use. /api/today.json has the latest index and what's broken now, and /api/day/YYYY-MM-DD.json has any scored day with its incidents. /llms.txt describes the site for AI assistants.

The AI Era line

We mark January 1, 2026 as the symbolic start of mainstream AI adoption across product categories. The red line only appears on a chart when there's covered data on both sides of it, since a before/after comparison needs a "before".

The index's covered data starts after that date, so for now the line doesn't appear on the index chart. The CVE chart uses a separate source (the NVD) that goes back further.

Limitations

  • We only track providers that use Atlassian Statuspage. Major services like AWS, Google Cloud, Slack, and Stripe use custom status pages we can't yet parse.
  • Status pages are self-reported. Companies decide what to disclose and how to classify severity. We take them at their word.
  • History only exists from when we started collecting. Status page feeds show recent incidents only, so we can't reconstruct earlier years, and there's no pre-AI baseline to compare against yet.
  • The index weights all categories equally. You might argue cloud infrastructure outages are more impactful than a productivity tool going down — we don't make that judgment call.

Open source

This project is open source. If you want to dig into the code, add providers, or improve the scoring methodology, contributions are welcome.