HTTP/1 → HTTP/2 → HTTP/3
Three generations of the web's request protocol, each killing the last one's bottleneck.
HTTP/1.1 sends one request at a time per connection and stalls on head-of-line blocking. HTTP/2 multiplexes many streams over a single TCP connection with binary framing and header compression. HTTP/3 moves onto QUIC over UDP, erasing TCP-level head-of-line blocking and adding faster, encrypted-by-default connection setup.
HTTP/1.1
A request occupies a connection until its response returns, so a browser must open six-or-so parallel TCP connections per host just to fetch a page's assets concurrently. Keep-alive reuses each socket to avoid re-handshaking, but a single slow response still blocks everything queued behind it on that connection — head-of-line blocking at the request level. Pipelining was meant to fix this but was never safely deployable, so requests stayed effectively serial.
HTTP/2
Many independent streams are multiplexed over a single TCP connection, and the protocol switches from plaintext to a binary framing layer that slices messages into interleaved frames. HPACK compresses the repetitive headers sent on every request down to a few bytes, and server push can send assets before the client even asks for them. This collapses six connections into one and removes request-level queuing.
HTTP/3
Transport moves off TCP entirely onto QUIC, a reliable protocol built on top of UDP in user space. Streams are now independent at the transport layer, so one lost packet only stalls its own stream instead of freezing every multiplexed stream behind it — TCP's transport-level head-of-line blocking is finally gone. QUIC also merges the transport and TLS handshakes into a single round trip.
The upgrade path
Across all three generations the HTTP semantics — methods, headers, status codes, URLs — stayed identical; only the wire encoding changed. Multiplexing removed request queuing, QUIC removed transport stalls, and 0-RTT resumption plus built-in TLS 1.3 cut connection setup from multiple round trips toward zero. Each version simply attacked whichever bottleneck the previous one exposed.
Why HTTP kept getting rewritten
HTTP is the protocol every web page, API call, and app request rides on, and its job — ask for a resource, get a response — has barely changed since 1991. What has changed is the shape of the web itself. A page in 1996 was one HTML file; a page today pulls in hundreds of assets: scripts, stylesheets, fonts, images, API responses. The protocol that was fine for one document became a bottleneck for hundreds of small requests, and each new version of HTTP is a direct answer to the performance ceiling the previous one hit.
The crucial thing to understand is that HTTP is split into two layers. There are the semantics — the methods (GET, POST), the headers, the status codes, the idea of a request and a response — and there is the wire format, how those semantics are actually encoded into bytes and moved across the network. HTTP/1.1, HTTP/2, and HTTP/3 share the same semantics almost exactly. Everything that changed between them is in the wire format and the transport underneath it. That is why you can upgrade a site from HTTP/1.1 to HTTP/3 without rewriting a single line of application code.
HTTP/1.1 and the head-of-line problem
HTTP/1.1 is a text protocol with one hard limitation: a connection handles one request at a time. You send a request, and that connection is busy until the full response comes back. Keep-alive lets you reuse the connection for the next request instead of paying for a fresh TCP (and TLS) handshake every time, which helps, but it does not let two requests overlap.
The consequence is head-of-line blocking at the request level: if the first response is slow — a big image, a database-backed page — every request queued behind it on that connection waits, even if they would have been instant. Browsers work around this by opening roughly six parallel connections per hostname, so six requests can be in flight at once. But six connections means six handshakes, six congestion-control state machines, and six times the server-side memory, and it still caps concurrency at six. HTTP/1.1's design fundamentally couldn't express "many requests, one connection, all at once."
HTTP/2: multiplexing over one connection
HTTP/2 keeps TCP but replaces the text protocol with a binary framing layer. Each message is chopped into small frames tagged with a stream ID, and frames from many streams are interleaved on a single connection. The receiver reassembles each stream from its frames. This is multiplexing: dozens of requests and responses share one connection concurrently, so the request-level head-of-line blocking of HTTP/1.1 disappears and the six-connection workaround is no longer needed.
Two more features ride along. HPACK header compression exploits the fact that most headers (cookies, user-agent, accept) repeat on nearly every request; it maintains a shared table of previously-sent headers so each subsequent request references them by index instead of re-sending kilobytes of text. Server push lets the server proactively send an asset it knows the client will need — say the CSS for a page — before the client parses the HTML and asks. Push proved hard to use well and has since fallen out of favor, but multiplexing and HPACK made HTTP/2 a decisive win.
HTTP/3: escaping TCP with QUIC
HTTP/2 solved head-of-line blocking in HTTP, but a subtler version survived one layer down. TCP delivers a single, strictly ordered byte stream, so if one packet is lost, TCP holds back every byte that arrived after it until the missing one is retransmitted. Because HTTP/2 puts all its streams inside that one TCP stream, a single lost packet stalls *every* multiplexed stream — transport-level head-of-line blocking. The application saw independent streams; the transport did not.
HTTP/3 fixes this by abandoning TCP for QUIC, a transport built on top of UDP and implemented in user space rather than the kernel. QUIC understands streams natively: a lost packet only blocks the specific stream it belonged to, and the others keep flowing. QUIC also folds the transport handshake and the TLS 1.3 handshake into one, cutting connection setup to a single round trip, and 0-RTT resumption lets a returning client send data in the very first packet. Because QUIC lives above UDP, it can also evolve without waiting for operating systems and middleboxes to update, and a connection can survive a network change (Wi-Fi to cellular) via a connection ID instead of breaking.
Trade-offs and what to actually use
None of these versions is free of cost. HTTP/2's single connection can suffer badly on lossy networks precisely because of TCP head-of-line blocking, sometimes performing worse than HTTP/1.1's parallel connections. HTTP/3 shifts congestion-control and encryption work into user space, which can raise CPU usage, and UDP is still blocked or throttled on some corporate and mobile networks, so clients must be ready to fall back to HTTP/2 over TCP.
In practice you rarely choose manually. Browsers and servers negotiate the highest version both support during the connection (via ALPN in the TLS handshake, and an Alt-Svc header advertising HTTP/3), transparently falling back when needed. The practical guidance: terminate HTTP/2 and HTTP/3 at your CDN or load balancer where the connection-heavy, latency-sensitive client traffic lands, keep TLS 1.3 enabled so you get the fast handshakes, and don't over-invest in server push. The headline lesson is architectural — the same request semantics have now been carried over three completely different transports, each removing the bottleneck the last one couldn't.
HTTP/1.1: one in-flight request per connection, head-of-line blocking, keep-alive reuses the socket to avoid re-handshaking.
HTTP/2: multiplexes many independent streams over one TCP connection, uses binary framing, compresses headers with HPACK, and can server-push.
HTTP/3: runs over QUIC (built on UDP), so a lost packet no longer stalls every stream — it eliminates TCP head-of-line blocking.
HTTP/3 sets up connections faster (0-RTT resumption) and bakes in TLS 1.3, so security and transport negotiate together.
Each generation kept HTTP semantics (methods, headers, status codes) and only changed how bytes move on the wire.
Quick quiz
What problem does HTTP/2 multiplexing solve over HTTP/1.1?
Why does HTTP/3 use QUIC over UDP?
How HTTPS works
The TLS handshake that turns a plain TCP connection into a private, verified channel.
TCP vs UDP
Reliable and ordered, or fast and best-effort — the transport trade-off.
What happens when you type google.com
The single most-asked interview question, animated end to end.
REST vs GraphQL
Two ways to shape an API — resources and endpoints, or one flexible query.