HTTP/1.1 (1999)
| Feature | Limitation |
|---|---|
| Persistent connections | One TCP connection per request (fixed by keep-alive) |
| Pipeline | Allowed multiple requests but responses blocked each other (head-of-line blocking) |
| Headers | Verbose, uncompressed, sent with every request |
| Prioritization | None |
Head-of-line (HOL) blocking in HTTP/1.1: If one request takes long, all pipelined responses behind it wait.
HTTP/2 (2015)
| Feature | Benefit |
|---|---|
| Multiplexing | Multiple streams over one TCP connection |
| Header compression (HPACK) | Reduces header overhead significantly |
| Server push | Server can send resources before the client requests them |
| Binary framing | Replaced text with binary — faster parsing |
| Stream prioritization | Client can indicate resource importance |
HOL blocking in HTTP/2: Solved at the HTTP layer (streams are independent) but still exists at the TCP layer — TCP packet loss blocks all streams on that connection.
HTTP/3 (2022)
Replaces TCP with QUIC (built on UDP).
| Feature | Benefit |
|---|---|
| QUIC over UDP | No TCP head-of-line blocking — packet loss on one stream doesn’t block others |
| 0-RTT handshake | Fast connection establishment (0 or 1 round trips) |
| Built-in encryption | TLS 1.3 integrated (no separate handshake) |
| Connection migration | Survives IP address changes (e.g., WiFi to cellular) |
HTTP/1.1: ┌─────────┬─────────┬─────────┬─────────┐
│ Req 1 │ Req 2 │ Req 3 │ Req 4 │ (serial)
└─────────┴─────────┴─────────┴─────────┘
HTTP/2: │== Stream 1 ================│
│=== Stream 2 ===============│ One TCP
│==== Stream 3 ==============│ connection
│===== Stream 4 =============│
HTTP/3: │== S1 ==│ (QUIC stream 1 — no blocking)
│=== S2 ==│ (QUIC stream 2 — independent)
│==== S3 =│ (QUIC stream 3 — independent)
│==== S4 =│ (QUIC stream 4 — independent)| HTTP/1.1 | HTTP/2 | HTTP/3 | |
|---|---|---|---|
| Transport | TCP | TCP | QUIC (UDP) |
| Multiplexing | No (serial) | Yes (streams) | Yes (streams) |
| Header compression | No | HPACK | QPACK |
| HOL blocking | HTTP + TCP | TCP only | None |
| Handshakes | 2-3 RTT | 2-3 RTT | 0-1 RTT |
| Encryption | Optional (HTTPS) | Optional (HTTPS) | Mandatory (built-in) |
Q: What problem does HTTP/2 solve?
A: HTTP/2 solves HTTP/1.1’s head-of-line blocking with multiplexing — multiple requests and responses can interleave over one TCP connection. It also adds header compression and server push.
Q: What was the remaining problem with HTTP/2?
A: TCP-level HOL blocking. If a TCP packet is lost, all streams on that connection are blocked until retransmission. HTTP/3 solves this by using QUIC over UDP so that packet loss on one stream doesn’t affect others.
Q: What is QUIC?
A: A transport protocol developed by Google, now standardized as RFC 9000. It runs over UDP, integrates TLS 1.3, provides 0-RTT handshakes, and eliminates TCP HOL blocking through independent streams.
Q: Why does HTTP/3 use UDP instead of TCP?
A: QUIC is built on UDP but implements all TCP features (reliability, congestion control) at the application layer, plus multiplexing, encryption, and connection migration. UDP gives QUIC the freedom to innovate without modifying the OS kernel’s TCP stack.
Premium Content
Unlock The Evolution of HTTP and all premium lessons with a subscription.
From ₹199.99/year — See plans