Nearly all of GitHub's repositories—99.99999%—now exist in two locations simultaneously: GitHub's own data centers and Azure. The remainder are among the platform's busiest, and a single factor holds them back: a 25ms round trip.

Why the migration couldn't wait

The move was shaped by what GitHub calls the agentic shift: traffic growing rapidly, a hard ceiling on power capacity in its data centers and the surrounding region, and physical supply-chain constraints. At the start of the migration, remaining capacity plus all possible expansion gave enough time to migrate safely—but not enough to do it slowly.

GitHub had prototyped new approaches for scaling Git on cloud infrastructure, but changing the storage architecture and the hosting platform at the same time, under that growth, carried too much risk. Git operations are a Tier 0 service, and nearly everything in GitHub depends on repository data, so the sequence had to be: move the data first, then evolve the architecture.

The first repository copy landed in Azure's Central US region in August 2025. Most repositories now have two of their five replicas in Azure, and Azure serves about half of Git traffic; for most of that period, Azure absorbed growth while GitHub's own data centers held steady. Five replicas balance durability, availability, and scale, and Spokes uses preferential routing to send each request to a replica in its own region and availability zone. Traffic follows the data: as replicas move, the Azure-served share grows, until the last replica arrives and the old region stops receiving requests.

The quorum problem at the tail

A repository spread across regions has a lower write throughput ceiling. The Spokes quorum commits a write once a majority responds, but it waits for every healthy replica (up to a timeout) before moving on—so slow replicas delay writes rather than falling behind. The slowest healthy replica sets every write's latency, and since each write holds a repository-wide lock until commit, it also sets the throughput ceiling.

In internal testing with realistic traffic, writes to different references consistently saw 3–4x higher throughput at lower latency.

Once a replica sits in the target Azure region, roughly 1,000 miles from GitHub's data centers, each network round trip costs about 25ms, and a write needs several round trips. A repository near its ceiling can't absorb that on every serialized write.

The fix applies the "minimize coordination" principle directly: don't serialize what doesn't need to be. Git's consistency guarantee applies per reference—once an update is accepted, no client may see an older value, whether the update is a fast-forward, a force push, or a delete. Updates to different references, however, are typically independent. So GitHub is moving the quorum's scope from the whole repository to individual references.

Under a repository-wide lock, the quorum is effectively a single unordered queue with one write in flight, each taking as long as the slowest healthy replica; as write rates grow, so does the queue. With per-reference serialization, only writes contending on the same reference wait for each other. Most writes—agents and developers pushing to their own branches, for instance—touch different references and can be in flight concurrently, while still paying the cross-region latency. The ceiling rises roughly in proportion to the number of references written at once, which brings the last repositories into Azure.

Separating the read path

Most repositories are heavily read-skewed, at 100 to 1,000 reads per write. Reads and writes currently share replicas and resources, so neither can scale independently. Durable storage in Azure Blob Storage, updated with each incoming write, makes decoupling possible—for example, giving reads far more in-memory cache than today, separate from the memory compaction needs.

The bridge is making object storage a member of the quorum as a "virtual replica": compute that is GitHub's first fully ephemeral node, streaming writes to object storage, serving no reads, and acknowledging a write only once it is durable there. The added latency doesn't become a throughput bottleneck, because per-reference serialization keeps it off the critical path—and the virtual write replica coalesces transactions on disjoint references into a single set of network I/Os, so a busy repository pays one round trip across many concurrent writes. For now it also handles compaction, and read replicas inherit the compacted state.

On top of that, virtual read replicas can be created on demand: each warms its cache from Azure Blob Storage, takes read traffic without joining the quorum, and reconciles local state against object storage in the background. In internal testing, a distributed load-testing harness that routinely found ceilings in the current architecture hit its own limits first against virtual read replicas.

Two challenges remain for later steps:

  • Background reconciliation suits some read workloads but not all; serving every kind of read requires reconciling in-line, fetching only what changed since the replica last caught up.
  • Write throughput has improved incrementally under the per-reference model, but the quorum is still the bounding factor.

Beyond the commit protocol

Spokes has grown well beyond quorum coordination: it is also a routing and load-balancing layer, a unified API serving well over 100 billion operations per day, and a set of background systems called "sweepers" that handle repository placement, repair, and rebalancing. Most of that umbrella applies to the new architecture too—but the commit protocol that took GitHub to a billion repositories won't take it to the next billion.

Write throughput is the next limit. Every write still waits on replicas that each hold a full copy of the repository, yet very little of a write needs ordering: Git objects are immutable and content-named, so they need no agreement. What remains is small, and the hard part is ordering it without moving the bottleneck elsewhere—underneath a billion repositories being written to around the clock, with second-order effects like where durable reference state lives and how compaction and garbage collection scale.