HTTP/1.1 vs /2 vs /3 — The Decision Guide

The Master Comparison

Dimension	HTTP/1.1	HTTP/2	HTTP/3
Transport	TCP	TCP	QUIC / UDP
Encoding	Text	Binary frames	Binary frames
Multiplexing	❌ (1 req/conn)	✅ (streams)	✅ (streams)
App-layer HOL blocking	Yes (ordered)	No	No
Transport HOL blocking	Per-connection	Yes (shared TCP)	No (per-stream)
Header compression	None	HPACK	QPACK
Encryption	Optional (TLS)	Optional, ~always TLS	Mandatory (TLS 1.3)
Handshake cost	TCP (+TLS)	TCP + TLS	Fused, 1-RTT / 0-RTT
Connection migration	❌	❌	✅ (Connection IDs)
Server push	❌	✅ then deprecated	Effectively unused
Concurrency hack needed	Sharding / bundling	None	None

What Each Jump Actually Bought

flowchart LR A["HTTP/1.1
text · 1 req/conn"] -->|"binary framing
+ multiplexing"| B["HTTP/2
many streams / 1 TCP"] B -->|"ditch TCP
→ QUIC on UDP"| C["HTTP/3
independent streams"]

1.1 → 2: removed application-layer HOL blocking and killed the 6-connection / sharding workarounds. Big win on stable networks.
2 → 3: removed transport-layer HOL blocking, cut handshake round trips, and added connection migration. Big win on lossy / mobile networks.

Which Should You Run?

Short answer: offer HTTP/2 and HTTP/3 together behind your edge, with HTTP/1.1 as the universal fallback. You rarely choose one — clients negotiate the best they can reach.

Situation	Best fit	Why
Public web app / CDN edge	H3 + H2 fallback	Mobile users benefit most from QUIC; H2 covers blocked-UDP networks
Internal service-to-service	HTTP/2	Stable low-loss links; simpler ops; native gRPC transport
Simple API, low volume	HTTP/1.1	Trivially debuggable; multiplexing gains are marginal at low concurrency
Lossy / high-latency clients	HTTP/3	Independent streams + 0-RTT + migration win exactly here
Legacy / restrictive middleboxes	HTTP/1.1 or /2	UDP may be throttled or blocked outright

Migration Gotchas

Don't carry HTTP/1.1 habits into HTTP/2+. Domain sharding, sprite sheets, and aggressive asset concatenation were workarounds for the 6-connection limit — under multiplexing they hurt (more connections fight congestion control; huge bundles defeat fine-grained caching).

Server push is a dead end. If you built around it, migrate to <link rel="preload"> and 103 Early Hints — both survive the version you're on and the ones you're moving to.

Real-world: in most stacks the version is a property of your load balancer / CDN, not your application code — HTTP semantics are identical across versions, so your handlers don't change. You flip it on at the edge and measure tail latency (p99) on real client networks, where HTTP/3's advantages actually appear.

Key Takeaways

Bottom line: the three versions are one continuous fight against head-of-line blocking. Serve H2 and H3 at the edge, keep H1.1 as a floor, and drop the old concatenation/sharding tricks. For the payload inside these requests, continue to Serialization — the format on the wire is the other half of protocol performance.