TECH_COMPARISON
HTTP/2 vs HTTP/3: A Detailed Comparison for System Design
Compare HTTP/2 and HTTP/3 protocols — explore differences in transport layer, head-of-line blocking, connection migration, and performance.
HTTP/2 vs HTTP/3
HTTP/2 and HTTP/3 are both modern HTTP versions designed to improve web performance, but they differ fundamentally in their transport layer. HTTP/2 runs over TCP. HTTP/3 runs over QUIC, a UDP-based transport protocol.
The Head-of-Line Blocking Problem
HTTP/2 solved HTTP-level head-of-line blocking by multiplexing multiple streams over a single TCP connection. But TCP itself has head-of-line blocking — if a single TCP packet is lost, all streams are blocked until it is retransmitted.
HTTP/3 solves this completely. QUIC streams are independent at the transport level. A lost packet in one stream does not affect other streams. This is especially impactful on lossy mobile networks.
Connection Setup Speed
HTTP/2 over TLS 1.3 requires 2 round trips: one for TCP, one for TLS. HTTP/3 combines transport and encryption in a single QUIC handshake — 1 round trip for new connections, 0 round trips for repeat connections (0-RTT).
On a 200ms latency connection, this saves 200-400ms on every new connection.
Connection Migration
When a mobile device switches from WiFi to cellular, its IP address changes. TCP connections break because they are identified by the (source IP, source port, dest IP, dest port) tuple. QUIC connections use a connection ID that survives IP changes, enabling seamless migration.
For more on networking protocols, see our concepts library and system design interview guide. Explore pricing for practice.
The Bottom Line
HTTP/3 is the future of web transport. Its advantages — no head-of-line blocking, faster connections, connection migration — are most impactful on mobile and high-latency networks. HTTP/2 remains the safe default where UDP is blocked or server support is limited.
GO DEEPER
Master this topic in our 12-week cohort
Our Advanced System Design cohort covers this and 11 other deep-dive topics with live sessions, assignments, and expert feedback.
// RELATED_COMPARISONS
REST vs GraphQL: A Detailed Comparison for System Design
Compare REST and GraphQL APIs — learn the trade-offs in flexibility, performance, caching, and developer experience for modern system design.
REST vs gRPC: A Detailed Comparison for System Design
Compare REST and gRPC for system design — explore trade-offs in performance, serialization, streaming, and language support for microservices.
GraphQL vs gRPC: A Detailed Comparison for System Design
Compare GraphQL and gRPC — explore trade-offs in flexibility, performance, schema design, and when to use each in modern distributed systems.
Monolith vs Microservices: A Detailed Comparison for System Design
Compare monolithic and microservices architectures — understand trade-offs in scalability, deployment, team structure, and operational complexity.
REST vs WebSocket: A Detailed Comparison for System Design
Compare REST and WebSocket protocols — understand when to use request-response vs persistent bidirectional connections in system design.
SOA vs Microservices: A Detailed Comparison for System Design
Compare SOA and microservices architectures — learn how they differ in service granularity, communication, governance, and data management.