What Was HTTP/2 Server Push, and Why Was It Deprecated?
Understand what HTTP/2 Server Push was, why browsers removed it, and how preload plus 103 Early Hints replaced it.
Expected Interview Answer
HTTP/2 Server Push let a server proactively send resources (like CSS or JS) to the client alongside an HTML response, before the browser even requested them, but it was deprecated and removed from Chrome and other major browsers because it frequently pushed resources the browser already had cached, wasting bandwidth, and its benefits were achievable more reliably with rel="preload" and cache-aware alternatives.
When a browser requested index.html, the server could also push app.css and app.js in the same connection without waiting for the browser to parse the HTML and issue separate requests, in theory eliminating a round trip. In practice, the server has no visibility into the client’s cache state, so it often pushed resources the browser already had cached from a previous visit, wasting bandwidth and, worse, sometimes evicting genuinely useful cached entries. Push also complicated the browser’s request prioritization and interacted poorly with HTTP/2 flow control, leading to inconsistent real-world gains despite the theoretical round-trip savings. Because of these problems, Chrome removed Server Push support around 2022, and the modern approach favors rel="preload" (an in-page hint the browser can match against its own cache before fetching) alongside early hints (HTTP 103) which let a server send preload hints before the final response is ready, achieving push’s intended benefit without blindly overriding the client’s cache.
- (Historical) It could deliver resources in the same round trip as the initial HTML
- (Historical) It aimed to eliminate the request-then-discover-then-fetch latency for critical assets
- Its removal simplified browser caching behavior and eliminated wasted, cache-blind pushes
- Its replacement (preload + 103 Early Hints) achieves similar goals while respecting client cache state
AI Mentor Explanation
HTTP/2 Server Push was like a stadium vendor shoving a free scorecard into every fan’s hand as they enter, even to season-ticket holders who already have one from last week and don’t need another. It felt efficient — no fan has to ask — but the vendor cannot see who already holds a card, so paper and staff time get wasted on people who never wanted it. The replacement is a sign at the gate saying "scorecards available here," which fans who need one grab themselves, without waste for those who already have theirs. That blind-push-to-everyone versus request-only-what-is-missing contrast is exactly why Server Push was deprecated in favor of preload.
Step-by-Step Explanation
Step 1
(Historical) Client requests HTML
The browser requested the main document over an HTTP/2 connection.
Step 2
(Historical) Server pushes associated assets
The server proactively sent linked CSS/JS frames without waiting for the browser to request them.
Step 3
Problem: cache blindness surfaced
The server could not see the client cache, often pushing resources the browser already had, wasting bandwidth.
Step 4
Modern replacement adopted
rel="preload" hints (matched against the client cache) and HTTP 103 Early Hints now deliver the intended benefit without blind pushes.
What Interviewer Expects
- Correctly explaining what Server Push was meant to solve (round-trip latency for critical assets)
- Understanding the core failure: server cache-blindness leading to wasted, duplicate pushes
- Knowledge that Chrome and other browsers removed support around 2022
- Awareness of the modern replacement: preload hints plus 103 Early Hints
Common Mistakes
- Describing Server Push as still a current best practice rather than a deprecated/removed feature
- Confusing Server Push with HTTP/2 multiplexing, which is a separate, still-active feature
- Not explaining WHY it was deprecated (cache-blindness), only that it was
- Forgetting to mention preload/Early Hints as the modern alternative achieving similar goals
Best Answer (HR Friendly)
“HTTP/2 Server Push let a server send extra files, like CSS or JavaScript, to the browser before it even asked for them, hoping to save time. The problem was the server could not tell if the browser already had those files cached from before, so it often sent duplicate data and wasted bandwidth. Because of that, browsers removed support for it, and today the same goal is achieved with preload hints that respect what the browser already has cached.”
Code Example
// Deprecated approach (no longer supported in modern browsers):
// server would push /app.css and /app.js alongside index.html
// without checking if the client already had them cached.
// Modern replacement: send an early hint before the full response is ready
app.get('/', (req, res) => {
res.writeEarlyHints({
link: ['</app.css>; rel=preload; as=style', '</app.js>; rel=preload; as=script'],
})
// ... do slower work (DB queries, etc.) ...
res.send(renderHtml()) // browser matches preload hints against its own cache
})Follow-up Questions
- How does HTTP 103 Early Hints differ from Server Push in respecting client cache?
- What still-active HTTP/2 feature is Server Push often confused with?
- How does HTTP/3 (QUIC) change the latency problem Server Push tried to solve?
- When did major browsers remove Server Push support and why?
MCQ Practice
1. Why was HTTP/2 Server Push ultimately deprecated in major browsers?
Server cache-blindness led to redundant pushes, undermining the real-world benefit despite the theoretical round-trip savings.
2. What is the modern replacement approach for the round-trip savings Server Push aimed for?
Preload hints let the browser check its own cache before fetching, and Early Hints deliver those hints before the full response is ready.
3. What HTTP/2 feature is Server Push sometimes confused with, which is still active today?
Multiplexing (parallel streams on one connection) is a separate, still-supported HTTP/2 feature distinct from the deprecated push mechanism.
Flash Cards
What did HTTP/2 Server Push do? — Let a server proactively send resources alongside the HTML response before the browser requested them.
Why was it deprecated? — The server could not see the client cache, so it often pushed already-cached resources, wasting bandwidth.
Modern replacement? — rel="preload" hints plus HTTP 103 Early Hints.
Is HTTP/2 multiplexing also deprecated? — No — multiplexing is a separate, still-active HTTP/2 feature, unlike Server Push.