HTTP/2 Server Push: Why a Promising Feature Failed


HTTP/2 server push looked perfect on paper. The server could anticipate what resources a client would need and send them before the client even requested them, eliminating round trips and speeding up page loads. In practice, it turned into one of the web’s most spectacular optimization misfires. Chrome removed support in 2022, and other browsers followed suit. Understanding why reveals fundamental tensions in optimizing distributed systems.

The Promise: Eliminate Round Trips

Traditional web loading works like this: the browser requests an HTML page, parses it, discovers it needs a stylesheet and three JavaScript files, then makes four more round trips to fetch them. Each round trip on a high-latency connection adds up. If the server could just send the CSS and JS along with the HTML response without waiting to be asked, pages would load faster.

HTTP/2 server push provided exactly this mechanism. When a client requested /index.html, the server could push /styles.css and /app.js in the same connection before the browser parsed the HTML and discovered it needed them. The resources would already be waiting in the browser’s pipeline when the parser called for them.

The feature worked. Servers could push resources. Browsers would receive them. But the optimization was fragile, and in most real-world scenarios, it made things worse instead of better.

The Cache Invalidation Problem

The fundamental issue: the server doesn’t know what the client already has cached. When a browser requests a page, it might have visited the site yesterday and cached the CSS and JavaScript. Pushing those resources again wastes bandwidth and delays delivery of the HTML the client actually needs.

HTTP/2 provides a RST_STREAM frame that lets clients reject a push, but this rejection happens after the server has already started sending the resource. The bytes are in flight. The bandwidth is consumed. On slower connections, pushing a 200KB JavaScript bundle the client already has cached can delay the HTML render by seconds.

The browser could send a list of cached resources with each request, but this introduces its own overhead and privacy concerns. Cache digests were proposed to summarize what the client has without enumerating every URL, but the complexity of implementing and coordinating this state proved impractical. Servers would need to track what they’ve pushed to each client, browsers would need to communicate cache state, and the coordination overhead often exceeded the benefit of avoiding a few round trips.

Overpushing and Resource Prioritization

Developers tend to overpush. When given the ability to proactively send resources, the temptation is to push everything the page might need. This floods the connection with bytes and interferes with HTTP/2’s prioritization mechanisms. The browser can’t prioritize resources it didn’t know it needed yet, and the pushed resources compete with the HTML response the browser is desperately waiting to parse.

HTTP/2 prioritization was already poorly implemented across servers and CDNs. Adding server push meant developers were manually imposing an ordering that often conflicted with what the browser would have chosen. A pushed font file might delay critical rendering CSS. A pushed analytics script might slow down the actual application code.

The browser’s preload scanner and resource hints ended up being a better solution. With <link rel="preload">, the HTML tells the browser what to fetch immediately, but the browser still controls the request and knows about its own cache state. The server doesn’t waste bandwidth on resources the client already has.

The Alternative: 103 Early Hints

HTTP 103 Early Hints emerged as the pragmatic middle ground. Instead of pushing resources, the server sends a preliminary response with Link headers telling the browser what it will need. The browser can then request those resources in parallel with the final response, still eliminating wasted round trips but leaving cache coordination to the client.

Early Hints preserves the benefit of letting the server guide resource discovery while avoiding the cache invalidation problem. The browser makes the requests, checks its cache first, and controls prioritization. The server doesn’t need to track client state.

This approach proved more robust in practice. CDNs can generate Early Hints responses at the edge without the origin server’s involvement. Browsers can apply their full request logic, including cache checks and credential handling. The coordination surface is smaller.

Lessons for Protocol Design

Server push failed because it required perfect information the server couldn’t have. Optimizations that depend on distributed state coordination tend to collapse under real-world conditions. The browser’s cache state is local knowledge that can’t be efficiently synchronized with every server.

Effective optimizations in distributed systems tend to be request-driven rather than push-driven. The client, which has complete information about its own state, should control when resources are fetched. The server can suggest or prioritize, but the final decision must stay with the client.

HTTP/2 server push remains a cautionary tale: a theoretically optimal feature rendered impractical by the reality that servers and clients maintain independent, unsynchronized state.