GitHub experienced two recent incidents that disrupted your workflow, and we genuinely apologize for the impact. Reliability is our top priority, and these events have spurred a series of transformative changes. In this article, we break down the eight most important things you need to know about what went wrong, how we’re fixing it, and the long-term strategy to ensure GitHub stays fast and dependable. From handling exponential growth to rethinking our entire architecture, each point explains a critical piece of the puzzle. Jump to the first item to learn about the incidents themselves.

1. Recent Incidents and Our Commitment

In the wake of two separate availability incidents, we want to be transparent about the causes and our response. Both incidents fell short of the reliability you expect, and we are sorry for the disruption. Each event highlighted specific weaknesses in our infrastructure—one related to database scaling under load, another to cascading failures from a service dependency. We have since patched those individual issues, but more importantly, they validated our need for broader architectural changes. Our commitment is not just to fix symptoms but to redesign for resilience, ensuring that similar problems become rare exceptions.

2. Exponential Growth in Software Development

The primary driver of GitHub’s recent challenges is an unprecedented surge in activity. Since late December 2025, agentic development workflows—where automated agents create code, open pull requests, and run CI/CD pipelines—have exploded. Repository creation rates, pull request volumes, API calls, and automation jobs are all climbing at a pace that demands 30 times our previous capacity by early 2026. This isn’t just a linear increase; the complexity of interactions means every new user and tool adds multiplicative load to git storage, merge checks, Actions runners, notifications, and background jobs. Our original 10× capacity plan became obsolete within months.

3. How System Coupling Amplifies Problems

A single pull request on GitHub touches dozens of subsystems: git storage, mergeability checks, branch protection, Actions, search, notifications, permissions, webhooks, APIs, caches, and databases. At high scale, minor inefficiencies compound. A slow cache fetch becomes a database query; a database slowdown causes queues to deepen; retries amplify traffic; and one sluggish dependency can degrade multiple features at once. This hidden coupling means that a stress point in one area—like webhooks—can ripple across the entire platform. Understanding these chains is essential to building a system that degrades gracefully rather than failing catastrophically.

4. A New Priority Framework: Availability First

Our engineering priorities have been reordered: availability now comes before capacity, and capacity before new features. This shift means we aggressively reduce unnecessary work, optimize caching strategies, isolate critical services, and eliminate single points of failure. We’re also moving performance-sensitive logic into dedicated systems that can handle the load independently. For example, we’ve begun redesigning authentication and authorization flows to cut database queries by orders of magnitude. This framework ensures that when one subsystem is under pressure, the rest of GitHub continues to function—perhaps slower, but without a full outage.

5. Short-Term Solutions: Addressing Bottlenecks

In the near term, we tackled the most urgent bottlenecks. We moved webhooks to a new backend to offload MySQL pressure, redesigned the user session cache to reduce database reads, and streamlined authentication flows. We also leveraged our migration to Microsoft Azure to rapidly provision more compute resources—essentially buying time for deeper fixes. These changes resolved immediate issues, but they also revealed additional dependencies requiring rework. Each quick win informed our understanding of where the system breaks under load and helped prioritize the next wave of improvements.

6. Isolating Critical Services to Minimize Blast Radius

A core strategy is isolating services like git and GitHub Actions from less critical workloads. By carefully analyzing dependency graphs and traffic tiers, we identified where failures could cascade. We then restructured the architecture to limit blast radius: if the Actions service has a hiccup, it no longer affects git operations. This isolation involved extracting shared caches, decoupling database shards, and introducing circuit breakers. The result is a more modular infrastructure where a problem in one area stays contained, protecting the overall experience for the majority of users.

7. Performance Paths: Moving to Go from Ruby

Performance-sensitive and scale-critical code paths are being migrated from our Ruby monolith to Go. This isn’t a wholesale rewrite—it’s a targeted extraction of high-traffic paths (like merge calculation, file diffs, and API endpoint handlers) into services that benefit from Go’s concurrency and memory efficiency. Early results show significant reductions in latency and resource consumption, allowing us to handle more requests with the same hardware. This migration is ongoing, with each module carefully tested for correctness before being cut over.

8. The Multi-Cloud Path Forward

We’re accelerating our move away from smaller custom data centers toward a multi-cloud architecture built on Azure and beyond. This provides geographic redundancy, ensures failover capacity, and allows us to absorb traffic spikes without manual intervention. The plan includes designing for span-of-control, where no single cloud region or provider becomes a bottleneck. While the transition is complex—involving data consistency, latency, and cost trade-offs—it is a cornerstone of our long-term reliability vision. We expect to share more details as we reach major milestones.

These eight points capture the essence of GitHub’s current reliability journey. We’ve made significant progress, especially in shoring up short-term bottlenecks and setting a new strategic direction. However, the landscape of software development is changing fast, and we must continue adapting. Our teams are working around the clock to implement these changes, and we are grateful for your patience and feedback. For the latest updates, keep an eye on our status page and product changelogs. We’re committed to keeping GitHub the reliable, trusted platform you depend on.