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?
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.
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.
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:
We then deduct from 100 based on how many hours fell into each severity tier:
| Max severity at that moment | Points deducted per hour |
|---|---|
| Minor — degraded performance | 5 |
| Major — partial outage | 15 |
| Critical — full outage | 30 |
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 day | Lowest possible day score |
|---|---|
| Minor | 70 |
| Major | 40 |
| Critical | 0 |
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:
| Severity | Max scoring duration |
|---|---|
| Critical | 3 days — real critical outages get resolved fast |
| Major | 5 days |
| Minor | 7 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.
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:
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.
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 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.
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.
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.
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.
This project is open source. If you want to dig into the code, add providers, or improve the scoring methodology, contributions are welcome.