Skip to main content
awsdown
criticalKinesisus-east-1

The 2020 Kinesis Outage: One Service That Broke Half of AWS

AWSDown Research · Incident analysisPublished January 14, 2026Updated January 14, 20268 min read
A network of connected data nodes

Timeline

  1. Trigger

    AWS adds capacity to the Kinesis Data Streams front-end fleet in us-east-1. Each server opens threads to every other server in the fleet, and the larger fleet pushes existing servers past the operating-system thread limit.

  2. Impact

    Front-end servers begin failing to build a complete shard-map. Kinesis error rates climb, and services that depend on Kinesis internally start to degrade across the region.

  3. Cascade

    CloudWatch metrics and alarms, Cognito authentication, and parts of the AWS console and Lambda begin returning errors because they publish to or read from Kinesis under the hood.

  4. Mitigation

    AWS lowers the thread count by reducing fleet size, then carefully adds servers back a few at a time so each can rebuild its shard-map without exhausting threads again.

  5. Resolved

    Kinesis error rates return to normal and dependent services drain their backlogs. AWS keeps a heightened watch as CloudWatch and Cognito fully recover.

Root cause

Kinesis Data Streams is built on a fleet of front-end servers, and each one keeps a thread open to every other server in the fleet so it can share and cache a map of which stream shards live where. That design is fine until the fleet gets large enough that the number of threads on a single server brushes up against the operating system's hard limit. On November 25, 2020, AWS added capacity to the us-east-1 front-end fleet. The extra servers pushed the existing ones past that thread ceiling, so they could no longer build a complete shard-map. Requests started failing, and because a front-end server needs a valid shard-map to route anything, the fleet degraded as a whole rather than shedding one broken node.

The insidious part was recovery. AWS could not simply restart everything: bringing servers back too quickly re-created the same thread pressure, because every new server immediately tried to open connections to every other server. The fix was to shrink the fleet, let the survivors rebuild a clean, complete shard-map, and then add servers back a handful at a time while watching the thread count on each one. That is why an outage triggered by a capacity addition took most of a business day to clear. It is worth sitting with that irony: the trigger was AWS trying to make Kinesis bigger and better, and the failure mode was baked into a design decision (all-to-all threading) that had worked fine for years right up until the fleet crossed an invisible line. Most serious outages look like this in hindsight. They are not a single dumb mistake but a healthy change meeting a long-dormant limit.

Business impact

Very few customers use Kinesis directly, yet nearly everyone in us-east-1 felt this event, because AWS runs its own control plane on Kinesis. CloudWatch publishes metric and log data through it, so dashboards went blank and alarms stopped firing at the exact moment operators needed them most. Cognito leaned on it for parts of authentication, so sign-in flows failed for apps that had nothing to do with streaming data. The AWS console, EventBridge, and portions of Lambda and Auto Scaling degraded for the same reason. Teams that had no idea they depended on Kinesis discovered that they did, all at once, mid-morning on the day before Thanksgiving.

The knock-on effects reached well beyond AWS proper. Because CloudWatch alarms feed Auto Scaling and countless third-party paging and observability tools, some customers could neither see their own systems clearly nor scale them in response to load. Popular consumer products that had no obvious tie to streaming, from smart-home apps to video services, reported errors during the window, simply because a link in their chain published telemetry or authenticated users through an affected AWS feature. The financial cost of a day like this is rarely the raw compute credits. It is the support tickets, the missed transactions, and the engineering hours spent chasing a problem that turned out to originate three vendors deep in a dependency you never chose. This is the same hidden-dependency theme as the 2021 us-east-1 outage and the 2025 DynamoDB DNS event: a single internal service sits under features that look unrelated, and the concentration of AWS control planes in us-east-1 makes that region the industry's most consequential single point of failure.

Prevention and lessons

  1. Blast-radius review routine capacity changes. The trigger here was a normal, approved scaling action, not a mistake. Treat additions to shared internal-style services (your own message buses, metadata stores, service discovery) with the same care as a deploy, and stage them.
  2. Do not let monitoring depend on the thing being monitored. CloudWatch failing during the outage blinded responders. Keep an out-of-band signal, whether a third-party monitor or a simple external heartbeat, so you can see an incident even when your primary telemetry is down. The DR checklist covers this.
  3. Design for slow, safe recovery. The long tail was deliberate re-scaling, not indecision. Systems that can only recover by carefully adding capacity back have a long RTO by nature, so measure and communicate it before you need it.
  4. Claim what you are owed. Eight regional hours is a clear SLA breach. Run the numbers on the SLA credit calculator and follow the credit playbook to file. Automated evidence collection for events like this is exactly what our sponsor Next Signal builds.

SLA credit eligibility

Yes - roughly eight hours of regional Kinesis degradation breached the 99.9% monthly target. Eight hours of impact is about 98.9% monthly uptime, well past the Kinesis 99.9% threshold and into the 10% service-credit tier. Dependent-service impact (CloudWatch, Cognito) can support separate claims where you measured sustained errors.

Work out what your bill was owed with the independent AWS SLA credit calculator, or automate breach detection with Next Signal (sponsor). For the full claim process, see the AWS credit-recovery playbook.

Questions about this outage

What caused the November 2020 AWS Kinesis outage?

AWS added capacity to the Kinesis front-end fleet in us-east-1. Each front-end server maintains threads to every other server, so the larger fleet pushed existing servers past the operating-system maximum thread count. Servers could no longer build a complete shard-map, and the fleet fell into a degraded state that took most of a business day to recover.

Why did a Kinesis outage break CloudWatch and Cognito?

AWS builds AWS on AWS. CloudWatch publishes metric data through Kinesis, and Cognito relies on it for parts of its workflow, so both degraded when Kinesis failed. This is the classic hidden-dependency pattern: a single internal service can be in the path of features that look completely unrelated on the surface.

How long did the 2020 Kinesis outage last?

Major impact ran roughly from 14:15 UTC to about 22:00 UTC on November 25, 2020, in us-east-1, so close to eight hours. Recovery was deliberately slow because AWS had to add servers back gradually to avoid re-tripping the thread limit.

Could the 2020 Kinesis outage happen again?

This exact failure is unlikely because AWS raised the thread limit and moved to reduce the number of threads each front-end server needs. But the underlying lesson stands: a scaling change to a shared internal service can cascade far beyond its own customers, so blast-radius review of routine capacity work matters.

Next time, hear it from us first

Instant alerts when AWS incidents are detected - services and regions included.

Get outage alerts

More post-mortems

ELB

The 2012 ELB Outage: The Deleted State That Ruined Christmas Eve

A developer running maintenance accidentally deleted Elastic Load Balancing state data in us-east-1. Without that state, load balancers could not be scaled or modified correctly, so a growing share of them degraded over Christmas Eve, most visibly taking Netflix offline for millions of viewers.

DynamoDB

The 2015 DynamoDB Outage: A Metadata Service Under Its Own Load

A brief network disruption made DynamoDB storage nodes re-request their partition assignments from a metadata service at the same moment that larger tables had made those requests slower and heavier. The metadata service could not keep up, storage nodes took themselves out of service, and DynamoDB errors in us-east-1 cascaded into EC2, SQS, and other services.

EBS

The Great AWS Outage of 2011: When EBS Re-Mirrored Itself to Death

A network change accidentally routed high-volume EBS traffic onto a low-capacity network in one us-east-1 Availability Zone. Volumes lost their mirrors and tried to re-mirror all at once, exhausting capacity and creating a re-mirroring storm that stuck EBS and EC2 for days.