Introduction
After two major incidents in early 2026, GitHub faced a critical need to improve system availability and handle unprecedented growth. This guide outlines the strategic steps taken to boost reliability from 10X to 30X capacity scaling, addressing exponential demand driven by agentic development workflows. By following these steps, your organization can learn from GitHub’s approach to identify bottlenecks, isolate critical services, and prioritize availability over new features. This step-by-step plan is based on real-world actions GitHub implemented, including migrating to Azure, rewriting performance-sensitive code, and planning for multi-cloud.
What You Need
- Usage Data: Historical and current metrics on repository creation, pull request activity, API calls, automation rates, and large-repository workloads.
- System Architecture Diagrams: Current dependency maps of your services (e.g., Git storage, mergeability checks, branch protection, Actions, search, notifications, permissions, webhooks, APIs, background jobs, caches, databases).
- Performance Monitoring Tools: Tools to track queue depths, cache hit ratios, database load, index lag, retry rates, and cross-service latency.
- Team Expertise: A distributed systems engineering team capable of reducing hidden coupling, controlling blast radius, and implementing graceful degradation.
- Cloud Infrastructure: Access to a public cloud provider (like Azure) for scaling compute and storage, plus a plan for multi-cloud (e.g., a secondary cloud for failover).
- Codebase Access: Permission to refactor monolithic Ruby services into more performant languages like Go for performance-sensitive paths.
Step-by-Step Guide
Step 1: Assess Current Capacity and Growth Trends
Begin by analyzing your system's capacity limit—GitHub started with a 10X increase plan but quickly realized 30X was needed. Gather data on growth since December 2025, focusing on metrics like repository creation, pull request activity, API usage, automation, and large-repository workloads. Use this to project future demand, especially from agentic workflows (AI-driven development). Identify which services are already under strain, such as Git storage or webhooks. This baseline will guide every subsequent decision.
Step 2: Map Dependencies and Identify Bottlenecks
Examine how a single pull request traverses your entire stack. GitHub’s analysis showed that one PR can touch Git storage, mergeability checks, branch protection, GitHub Actions, search, notifications, permissions, webhooks, APIs, background jobs, caches, and databases. Look for compounding inefficiencies: queues deepening, cache misses turning into database load, indexes falling behind, and retries amplifying traffic. Mark single points of failure and services where a single slow dependency affects multiple product experiences.
Step 3: Prioritize Availability Over New Features
Set a clear hierarchy: availability first, then capacity, then new features. This means temporarily pausing feature development to focus on reliability improvements. GitHub reduced unnecessary work, improved caching, isolated critical services, and removed single points of failure. Communicate this priority to your team and stakeholders to align resources. Create a roadmap that tackles bottlenecks in order of risk—address the highest-impact failures immediately.
Step 4: Implement Short-Term Fixes for Immediate Bottlenecks
Start with fast, high-impact changes. GitHub executed several short-term actions:
- Move webhooks to a different backend (out of MySQL) to reduce database load.
- Redesign user session cache to decrease cache misses.
- Redo authentication and authorization flows to cut database queries per request.
- Leverage Azure migration to stand up more compute capacity quickly.
These changes directly mitigated the most urgent pressures. Use your monitoring tools to verify that each fix reduces queue depths and latency. Continue iterating until core services stabilize.
Step 5: Isolate Critical Services and Minimize Blast Radius
Next, focus on isolating services that are essential for uptime, such as Git storage and GitHub Actions. Analyze dependencies and traffic tiers to understand what needs to be decoupled. GitHub performed careful dependency analysis and then physically or logically separated these services from non-critical workloads. For each service, design a blast radius: ensure that when one subsystem fails, it doesn’t cascade to others. For example, limit the impact of a webhook backend failure on git operations. Order these isolation measures by risk level and implement them one by one.
Step 6: Rewrite Performance-Sensitive Code in a More Scalable Language
Identify code paths that are performance-sensitive—those that handle high throughput or need low latency. GitHub accelerated migration of such code from the Ruby monolith into Go. Evaluate your own tech stack: if you have a monolithic service (e.g., built in Ruby or Python) that struggles with scale, rewrite critical modules in a language with better concurrency and performance, like Go, Rust, or Java. This step reduces CPU overhead and memory usage, especially for tasks like session management, search indexing, and API request handling.
Step 7: Migrate to Public Cloud and Plan for Multi-Cloud
Leverage a public cloud provider to gain elasticity and faster scaling. GitHub was already migrating from smaller custom data centers to Azure. This gave them the ability to quickly add compute resources. As a long-term reliability measure, start working toward a multi-cloud strategy. Even if you are already in one cloud, design a path to have a secondary cloud provider ready for failover. Multi-cloud reduces dependency on a single vendor and provides an additional layer of redundancy against regional outages.
Step 8: Continuously Monitor and Tune Graceful Degradation
Finally, build mechanisms for graceful degradation. When one subsystem is under pressure, the rest of the platform should remain available, albeit with reduced functionality. GitHub focused on making its system degrade gracefully. Implement circuit breakers, bulkheads, and fallbacks. Use monitoring to detect when a service is struggling and automatically route traffic away or reduce feature set. Regularly test failure scenarios to ensure your isolation and degradation work as intended.
Tips for Success
- Start small, iterate fast: Like GitHub’s move from 10X to 30X planning, reassess your capacity targets frequently as growth patterns change.
- Automate testing for hidden coupling: Use integration tests that simulate cross-service failures to find subtle dependencies.
- Invest in observability: Deep monitoring of each service’s dependencies (queues, caches, DB load) is essential to identify compounding issues before they become outages.
- Communicate openly with users: When incidents occur, provide transparent post-mortems like GitHub did—it builds trust and shows you’re actively working on reliability.
- Don’t neglect new features forever: Once availability and capacity are stable, gradually reintroduce feature work, but keep reliability as a core metric in your development cycle.
- Plan for multi-cloud early: Even if you don’t need it today, architecting for multi-cloud reduces future migration pain and provides insurance against cloud provider outages.
By following these steps, you can systematically improve system reliability in the face of exponential growth, just as GitHub did after their availability incidents. Remember, the goal is not perfection but continuous improvement—prioritize availability, isolate failures, and always be ready to scale.