HTTP/3 and QUIC: How the Web Moved to a New Transport

TL;DR — HTTP/3 is HTTP over QUIC, and QUIC is a new transport built on UDP that moves TLS 1.3, stream multiplexing, connection migration and congestion control into userspace. The wins: no TCP-layer head-of-line blocking between streams, a combined crypto-plus-transport handshake in one round trip, and connections that survive IP changes. The costs: UDP on the server side, a fatter CPU profile, and middleboxes that still treat UDP as second-class traffic. Roughly 40% of websites now answer on HTTP/3 — here’s how the protocol actually achieves what it promises, and where it doesn’t.

Transport protocols are supposed to be frozen geology — TCP has carried the web since 1983-ish primordial days, and every attempt to evolve it (SCTP, MPTCP, TCP Fast Open) hit the same wall: kernels are slow to update and middleboxes break what they don’t recognize. QUIC’s historical move was to sidestep that wall entirely: implement the transport in userspace, on top of UDP, where a browser or server can ship a new protocol version like software. Google ran the experiment at scale from 2013; the IETF standardized the result as RFC 9000 (QUIC v1, 2021), RFC 9001 (its TLS 1.3 integration) and RFC 9114 (HTTP/3). This is infrastructure-evolution engineering in the same family as the eBPF story — bypassing a frozen kernel layer by moving it somewhere you can iterate.

The Problem QUIC Was Built to Kill

HTTP/2 multiplexed many request streams over one TCP connection — and immediately inherited TCP’s packet-level arithmetic: one lost packet stalls every stream on the connection, because TCP delivers bytes strictly in order, even bytes belonging to unrelated requests. That’s transport-layer head-of-line blocking, and no amount of HTTP-layer cleverness fixes it. Add the handshake tax — TCP’s SYN/SYN-ACK, then TLS’s own round trips before a single HTTP byte — and the latency floor of an HTTPS page load was structurally fixed.

QUIC attacks both directly:

• Independent streams. QUIC’s streams are first-class transport objects; a lost packet delays only the stream(s) whose bytes it carried. Frame-level numbering lets receivers acknowledge data precisely and reassemble out of order across streams.
• One combined handshake. TLS 1.3 is folded into the QUIC handshake (RFC 9001), so crypto negotiation and transport establishment happen in the same round trip — and a resumed connection can send HTTP data in the very first packet (0-RTT).
• Connection migration. The connection is identified by a CID (connection ID), not the 4-tuple — so when your phone’s IP changes from Wi-Fi to cellular mid-download, the connection (and its congestion state) survives.

TLS Lives Inside, Not Beside

A design point worth internalizing: QUIC did not invent new cryptography. The handshake is TLS 1.3 (RFC 8446), with the records fed through QUIC’s encryption levels — Initial, Handshake, 1-RTT — rather than a TCP byte stream. That decision inherited a mature, analyzed handshake instead of a bespoke one (the original Google QUIC’s custom crypto was replaced for exactly this reason), and it means the certificate ecosystem — including everything we covered in Certificate Transparency — continues to apply unchanged. QUIC also hard-wires forward secrecy and forbids TLS features that assume reliable ordered delivery, since it provides its own.

The handshake’s structure explains the performance story: the client’s first flight already carries cryptographic material; the server’s reply completes both transport and crypto; and HTTP frames ride the 1-RTT keys immediately. On resumption, previously stored parameters let the client encrypt request data into packet zero. The “HTTP/3 is one round trip” claim is this, precisely — not magic, just merging what TCP split.

What UDP Actually Costs

The honest engineering ledger has debits:

• Kernel bypass is CPU work. TCP’s fast path is decades of kernel optimization; QUIC reimplements reliability, ordering and congestion control in application space. Early deployments paid measurable CPU premiums; kernel offloads and UDP segmentation (UDP GSO) have clawed much of it back, but a QUIC server is still doing more per byte than a TCP one.
• UDP is treated as suspect. Some networks throttle or block UDP outright (a non-trivial fraction globally), and DPI boxes mishandle unfamiliar UDP flows. QUIC’s answer is graceful: clients race HTTP/2 and HTTP/3 connections or fall back via Alt-Svc — but that means every QUIC deployment permanently maintains a TCP path too.
• Encryption vs. observability. Middleboxes lost the ability to passively inspect TCP flows — which defenders also used. Network telemetry shifts to what QUIC exposes deliberately: connection-level events, loss signals, and transport logs.
• Amplification discipline. An unauthenticated UDP server is a reflection amplifier; QUIC’s Initial-packet padding and address-validation (retry/token) mechanics exist precisely to prevent it being drafted into DDoS service.

Where Adoption Actually Stands

The numbers tell a maturing story: W3Techs measures HTTP/3 support on roughly 40% of websites (higher in the top-traffic ranks), all major browsers ship it enabled, and CDNs terminate it by default — yet actual request share sits lower (around a fifth of requests in recent measurements), because negotiation requires a prior visit (Alt-Svc advertisement over HTTP/2), UDP reachability, and client-side heuristics. Translation: server-side support has saturated the platforms; client usage follows the install base and network policies, on the same slow default-driven curve that decided DNSSEC validation adoption — big defaults move first, the long tail follows. There is also a measurement subtlety worth knowing when you read adoption charts: “supports HTTP/3” means the server advertises it, while “uses HTTP/3” means a specific request actually negotiated it — the gap between the two numbers is mostly first-visit negotiation and UDP-hostile middleboxes, not client capability.

Operating HTTP/3 Without Surprises

1. Terminate at the edge, keep TCP warm. Enable HTTP/3 on the CDN/load balancer and keep HTTP/2 pristine behind it; the fallback path is part of the design, not a failure mode.
2. Watch UDP health separately. Add QUIC/UDP error rates and 0-RTT rejection rates to monitoring — a network silently throttling UDP will show up as fallback share creeping up before users complain.
3. Size the CPU. Enable UDP GSO/GRO offloads and expect higher per-connection cost than TCP; capacity plan on connections-per-core, not bandwidth alone.
4. Test migration on real mobile networks. Connection migration is the headline user-facing win; verify your load balancers hash on CID (not 4-tuple) or migration breaks at the infrastructure layer.
5. Log the negotiation. Record Alt-Svc issuance and QUIC version/transport parameters per client cohort — the telemetry you’ll want when debugging “slow for some users in some networks” next quarter.

Key Takeaways

• HTTP/3 (RFC 9114) runs HTTP over QUIC (RFC 9000), a UDP-based userspace transport with TLS 1.3 (RFC 9001) built into its handshake.
• The core wins: per-stream delivery (no transport head-of-line blocking), 1-RTT combined handshake with 0-RTT resumption, and connection migration via connection IDs.
• The costs are real: userspace CPU work, UDP’s second-class treatment by middleboxes, the permanent TCP fallback path, and reduced passive network observability.
• Adoption is default-driven: ~40% of websites support it, all major browsers and CDNs ship it, and actual traffic share climbs with the client base — roughly a fifth of requests today.
• Operationally: terminate at the edge, monitor UDP health distinctly, size for CPU, and verify CID-based load balancing so migration works.

FAQ

Is HTTP/3 faster than HTTP/2?
On lossy or high-latency paths and connection-heavy mobile workloads, usually yes — independent streams and 1-RTT setup are structural advantages. On clean, nearby, long-lived connections the difference shrinks to noise.

Why UDP instead of a new protocol number?
Deployability. New IP protocol numbers are dropped by middleboxes; UDP passes everywhere. QUIC is TCP-grade reliability rebuilt where software can ship it.

Does QUIC replace TLS?
No — it embeds TLS 1.3 as its handshake. Certificates, CT logs and the PKI you already operate apply unchanged.

What is 0-RTT, and is it safe?
Sending request data in the first packet using cached parameters. It’s replayable, so servers must treat 0-RTT requests as idempotent-only — a classic case where a latency win shifts correctness responsibility to the application.

What is connection migration?
QUIC connections are identified by connection IDs, not IP:port pairs, so an IP change (Wi-Fi → cellular) doesn’t kill the connection or its congestion-control state.

Can I inspect HTTP/3 traffic in my middleboxes?
Not passively — it’s encrypted including most metadata. Plan on endpoint-side telemetry and QUIC’s explicit signal surfaces instead of DPI.

References

1. RFC 9114 — HTTP/3
2. RFC 9000 — QUIC: A UDP-Based Multiplexed and Secure Transport
3. RFC 9001 — Using TLS to Secure QUIC
4. RFC 8446 — TLS 1.3
5. W3Techs — HTTP/3 usage statistics
6. IETF QUIC Working Group
7. Wikipedia — QUIC (history: Google experiment → IETF)
8. Chromium — QUIC project page (Google-era history)
9. Cloudflare — The road to QUIC
10. Cloudflare — HTTP/3: the past, present and future

Current as of September 2026. Educational engineering reference — benchmark on your own traffic; protocol performance is workload-shaped.

Published by Hmmnm

Hands-on cybersecurity tutorials, CVE breakdowns, and guided learning paths — written and lab-tested by the Hmmnm team.

Learning Paths · About Hmmnm · Editorial policy