Instant Navigation: How GitHub Issues Transformed Performance with Client-Side Caching

When developers work through a backlog—opening issues, jumping between threads, returning to lists—every millisecond of delay feels like a roadblock. Latency isn't just a number; it's a context switch that breaks flow. GitHub Issues wasn't slow in isolation, but too many navigations required redundant data fetching, repeatedly disrupting productivity. To address this, the team set out to rethink how issue pages load end-to-end, shifting from server-rendered waits to an almost-instant client-driven experience.

The Real Cost of Latency in Developer Tools

In today's fast-paced development environment, users compare GitHub not just against similar tools but against the snappiest web apps they use daily. For developer tools, latency directly impacts product quality. Triaging issues, reviewing feature requests, or reporting bugs should feel effortless; any avoidable wait breaks concentration. With millions relying on Issues weekly, and as it becomes a planning layer for AI-assisted work, perceived performance is critical. The bottleneck wasn't feature depth but architecture—too many common navigation paths still paid full costs of server rendering, network fetches, and client boot.

Instant Navigation: How GitHub Issues Transformed Performance with Client-Side Caching — Source: github.blog

Rethinking the Loading Architecture

The solution wasn't marginal backend optimizations but a complete change in how data flows. The approach: shift work to the client, render instantly from locally available data, then revalidate in the background. Three key components make this possible.

Client-Side Caching with IndexedDB

A persistent caching layer backed by IndexedDB stores recently accessed issue data directly in the browser. When a user navigates to an issue they've seen before, the page renders immediately from cache, eliminating server round-trips. This reduces perceived latency to near zero for repeat views.

Preheating Strategy for Cache Hit Rates

To maximize cache relevance without spamming requests, the system employs a preheating strategy. It predicts likely navigation paths based on user behavior and prefetches data for related issues or lists while the user is still reading. This ensures that when they click, the data is already waiting.

Service Worker for Hard Navigations

Even with caching, hard navigations (like typing a URL directly or coming from an external link) would bypass the cache. A service worker intercepts these requests and can serve cached data even when the app reinitializes, making it feel instant regardless of how the user arrives.

Real-World Impact

The results across actual usage speak for themselves. Navigation times dropped significantly, with many paths now feeling instantaneous. The team measured improved cache hit rates and reduced server load. Developers reported fewer disruptions, allowing them to stay in the flow longer. The metric that mattered most—perceived latency—improved dramatically.

Tradeoffs and Ongoing Work

This approach isn't free. Client-side caching introduces complexity: managing cache invalidation, ensuring data freshness, handling storage limits. Preheating requires careful modeling to avoid wasted fetches. The service worker adds another layer to debug and maintain. Despite these costs, the benefits outweigh them for high-frequency navigation. The team continues to refine the system, aiming to make fast the default across every path into Issues.

Transferable Patterns for Other Apps

If you're building a data-heavy web app, these patterns are directly transferable. The same model—client-side cache, preheating, service worker—can reduce perceived latency without a full rewrite. The key is to identify high-cost navigation paths and apply the caching hierarchy appropriately.

GitHub Issues shows that moving from latency to instant isn't about faster servers; it's about smarter clients. By rethinking when and how data is fetched, arbitrary waits can become a thing of the past.