Capacity Cascade: Inside GitHub’s 7-Hour Outage and the Retry Storm

A 7-Hour Capacity Cascade in the Central US Data Center

On August 17, 2026, a critical infrastructure component inside GitHub’s Central US data center refused to scale with a sudden surge in demand, triggering a platform-wide disruption spanning 7 hours and 47 minutes.

The cascading capacity pressure took down authentication, GitHub Actions, Copilot, APIs, pull requests, and issues simultaneously, stranding development and operations teams across multiple continents.

GitHub Blog’s postmortem is unambiguous about the root cause: neither this incident nor the August 6 Actions failure stemmed from a code or configuration defect. Both were capacity failures at their foundation.

The scale behind that pressure is staggering. In four months, monthly commits on the platform climbed from 1.4 billion to the 2.9 billion mark, compressing years of typical growth into a single quarter, according to GitHub Blog’s postmortem.

Recovery demanded a coordinated sequence instead of a simple failover. Traffic was rerouted, compromised infrastructure was quarantined, and service restoration proceeded in carefully managed phases — while a Copilot retry loop actually multiplied load during recovery and had to be neutralized before full traffic could return.

Inside the Failure Chain: Retry Storms, Shared Dependencies, and Linear Scaling

The August 17 incident followed the classic pattern of large-scale distributed system collapse. Demand hit a new record, a single component never scaled to match it, and the resulting pressure radiated outward through every service-to-service dependency.

Authentication failures became the earliest visible symptom, since nearly every GitHub surface requires identity verification before any request can proceed.

What made recovery unusually difficult was a behavioral loop inside the system itself. Errors across a subset of Copilot services triggered aggressive client-side retries, which layered additional traffic onto infrastructure that operations teams were actively trying to shed load from.

The retry amplification had to be corrected before traffic could be safely reintroduced, turning what might have been a routine rollback into a carefully sequenced multi-stage operation.

The deeper pattern connects both August incidents. In neither case was a code or configuration update involved; both exposed the same structural weakness — critical components were never scaled ahead of the demand curve they were expected to serve.

The platform has been adding capacity at an aggressive pace since April: more than 3 million new CPU cores, 120 petabytes of high-speed storage, and expanded network capacity across existing data centers.

But raw hardware is no longer the binding constraint. The migration to Azure has become the primary lever for elastic capacity, with the cloud now serving roughly 58 percent of GitHub’s total platform load and half of all Git operations — up from a 12 percent share in May.

The next architectural milestone tackles the monorepo scaling problem directly. The target is a read-capacity model that expands linearly with the number of concurrent readers, creating the foundation for effectively unlimited read operations on the largest repositories, with a gradual rollout starting at the very top of the size distribution.

Operational maturity has lagged the pace of change. GitHub is redirecting engineering resources toward availability work, elevating stronger testing, safer rollouts, deeper observability, and more effective alerting from afterthoughts to first-class infrastructure priorities.

The August incidents produced two immediate engineering changes. First, uniform retry limits, explicit retry budgets, and randomized timeouts are being applied across service-to-service interactions, a combination intended to prevent future retry storms and cascading load.

Second, deprioritized CPU and memory alerts are under review, with teams hunting for components that could silently buckle under a sudden demand spike.

The Azure Migration Math: 12% to 58% Load in Three Months, and the Remaining Reliability Gap

The incident data captured while the outage was live sharpens the postmortem. The Economic Times reported that GitHub began investigating at 1:40 p.m. UTC, with web experience and API traffic running at approximately 20 percent error rates.

Archive and raw repository content downloads fared far worse, hitting roughly 50 percent failure rates during the peak window.

SAML, OIDC, SCIM, and Team Sync authentication pathways were all affected, while Copilot entered a degraded state at 2:31 p.m. UTC and remained impaired well after core services started to recover.

LiveMint tracked the timeline in parallel, verifying that the platform still had no identified root cause by 4:16 p.m. UTC even as mitigation work continued.

Notably, Git Operations, Packages, Pages, and Codespaces were listed as operational while the outage was still being measured — a reminder that blast radius in distributed systems is rarely uniform.

What emerges is a story about scale outrunning visibility. Teams could not confirm the full blast radius until the cascade had already propagated across every dependency.

Developer community metrics make the reliability gap concrete. Unofficial trailing 90-day uptime calculations circulating in developer channels place GitHub at 93.91 percent, with multiple multi-hour outages recorded in the four weeks before August 17.

The same channels point to a GitHub COO statement that the platform processed 1 billion commits in 2025 and now runs at roughly 275 million per week — a trajectory that would surpass 14 billion in 2026 if growth remained purely linear.

LLM and agent-driven traffic is a central driver of this new load. Every Copilot completion, every autonomous agent workflow, and every automated pull request cycle adds a class of continuous, machine-generated demand that legacy capacity models were never designed to absorb.

The competitive tension is already visible. Developer forums are openly discussing self-hosted alternatives including Forgejo, GitLab, and Codeberg, particularly among teams that treat repository uptime as a critical path dependency.

This is the real strategic lesson for the performance engineering discipline. Capacity planning can no longer rely on forecasting human developer behavior; it must model exponential, autonomous, and often non-linear traffic patterns that spike without warning.

GitHub’s Azure migration is accelerating precisely because on-premise provisioning cannot keep pace with this growth curve. The jump from 12 percent to 58 percent of platform load in three months is aggressive by any standard, and it introduces its own operational risk even as it closes the capacity gap.

Isolating critical systems and removing shared dependencies is the architectural counterplay. The stated goal is not merely to survive the next spike, but to guarantee that a single failed component can never again take down authentication, Actions, APIs, and Copilot at the same time.

High Availability Is the New Bottleneck Budget

GitHub’s August 17 collapse makes one thing clear: capacity is no longer a back-office concern — it is the primary bottleneck budget for the agentic era of software development. For teams confronting the same capacity-planning gaps in their own production systems, WordPress Speed Engineering applies the identical bottleneck-first methodology, and you can start that conversation through the contact page.