Concept · Networking & Delivery

HTTP/1 vs HTTP/2 vs HTTP/3

01

Why this matters

Picking HTTP/2 over HTTP/1 gave an instant 2× speedup on a typical page load with no app code changes. HTTP/3 fixes the one failure mode HTTP/2 still had. In interviews: naming the specific wins of each version shows you understand the transport, not just "we'll use REST."

02

The three versions in one sentence each

  • HTTP/1.1 (1999) — one request at a time per TCP connection; browsers work around by opening 6 connections.
  • HTTP/2 (2015) — many requests concurrently over one connection (multiplexing) + header compression + server push.
  • HTTP/3 (2021) — same as HTTP/2 but over QUIC/UDP, eliminating head-of-line blocking.
03

HTTP/1.1 — the original sin

One request sent, one response returned, repeat. To parallelize, browsers open 6 TCP connections per hostname. Each connection needs its own handshake (3-way TCP + TLS = ~200ms at typical latencies). Modern pages fetch 50–100 resources; even with 6 connections, you're blocked on "the 7th request can't start until slot 1 is free."

Workaround: domain sharding. Serve assets from 4 subdomains so the browser opens 24 connections. Common in 2010; now dead.

04

HTTP/2 — multiplexing changed the world

One TCP connection. Many streams multiplexed inside it. Each stream carries one request + response. Requests go out in parallel without waiting.

  • Multiplexing. 100 requests over one connection, not 6.
  • HPACK header compression. Repeated headers (cookies, UA) compressed to a few bytes each. Saves 50–90% header bytes.
  • Stream prioritization. CSS blocking render gets priority over a below-fold image.
  • Server push. Server sends resources the client will need before the client asks. Cool in theory, effectively abandoned in practice — caching issues made it a net loss.

Adoption: ~95% of top-1M sites support HTTP/2 today. It's the default. You should never deploy HTTP/1.1-only in 2025.

The remaining flaw

HTTP/2 still runs on TCP. If one packet is lost, every stream stalls while TCP retransmits — even streams with no lost packets. TCP's head-of-line blocking leaks into HTTP/2. Painful on lossy networks (mobile, weak WiFi).

05

HTTP/3 — moving off TCP

HTTP/3 runs HTTP semantics on QUIC over UDP. QUIC implements its own reliable delivery, per-stream — a lost packet only blocks its own stream. The 47 other in-flight streams keep flowing.

Other wins:

  • 0-RTT resumption. Returning visitors send the first HTTP request before the handshake completes. Saves a full RTT — 100ms+ on mobile.
  • Connection migration. QUIC connections are identified by a connection ID, not IP. Switch from WiFi to cellular mid-video — the connection survives.
  • Encrypted transport by default. QUIC bundles TLS 1.3. No plaintext HTTP/3 exists.

Cost: UDP is often rate-limited or blocked on enterprise networks. HTTP/3 clients fall back to HTTP/2. This is fine — you get the win for most users and degrade gracefully for the rest.

~45%
of Cloudflare traffic on HTTP/3
~30%
typical P95 latency cut vs HTTP/2 on lossy networks
0-RTT
repeat-connection handshake cost
06

What to do in 2025

Your API

Default to HTTP/2 at the LB

Nginx/Envoy/ALB all speak HTTP/2. Zero app changes. 2× faster for most clients.

Consumer frontend

Enable HTTP/3 at CDN

Cloudflare, Fastly, CloudFront: one toggle. Modern browsers negotiate it. Fallback to HTTP/2 free.

Internal microservices

HTTP/2 or gRPC

gRPC runs on HTTP/2. Multiplexing over a persistent connection + protobuf = great for high-RPS internal calls.

Mobile apps

HTTP/3 most beneficial

Handoff between cell towers and WiFi is where HTTP/3's connection migration saves users from stalls.

07

Used in problems

YouTube/Netflix serve media over HTTP/3 for mobile users. Video conferencing uses HTTP/3 for signaling. Live streaming uses HTTP/3 for low-latency ingest. E-commerce benefits directly from HTTP/2 multiplexing of product-image loads.

Next up