System Design AI

HTTP/2 and HTTP/3: The Follow-Up Questions Interviewers Ask, With Answers

Interviewers often ask follow-up questions after you mention HTTP/2 or HTTP/3 because the protocol choice affects latency, scalability, and how you design your edge and backend. They want to see whether you understand the low-level mechanics, not just the headline benefits.

A solid answer shows you can translate protocol features into concrete design decisions—like how you size your load balancers, choose a CDN, or plan a migration path. Below are the typical probes, from the most common to the toughest, with sample candidate answers.

Core protocol differences

1. How does HTTP/2 multiplexing differ from HTTP/1.1 pipelining?

I would say that HTTP/2 multiplexes multiple streams over a single TCP connection, each with its own stream identifier, allowing frames from different requests to interleave. In HTTP/1.1 pipelining, requests are sent sequentially on one connection and responses must return in order, which can cause head-of-line blocking. For example, with three 100 KB requests, HTTP/2 can deliver all three in parallel over one connection, whereas HTTP/1.1 would wait for the first response before the second even starts.

2. What is header compression in HTTP/2 and why does it matter?

HTTP/2 uses HPACK to compress headers by maintaining a static table of common header fields and a dynamic table of previously seen values. This reduces the overhead of sending repetitive headers like User-Agent or cookies. In practice, a typical request with 20 headers of about 40 bytes each (800 bytes) can shrink to roughly 120 bytes on later requests over the same connection, saving roughly 85 % of header bytes per request.

3. Explain the role of streams and stream IDs in HTTP/2.

Each logical request/response pair is a stream identified by an odd-numbered ID for client-initiated streams and even-numbered for server-initiated streams. Streams allow independent flow control and priority settings. For instance, if a client opens streams 1, 3, and 5, the server can pause stream 3 while still delivering data on streams 1 and 5, preventing one slow request from throttling the others.

4. How does HTTP/3’s use of QUIC change connection management?

HTTP/3 runs over QUIC, which is built on UDP and provides built-in encryption, connection migration, and loss recovery. Unlike TCP, QUIC connections are identified by connection IDs chosen by the endpoints rather than by address and port, allowing a client to change IP addresses (e.g., from Wi-Fi to cellular) without tearing down the connection. In a real-world scenario, a mobile user can maintain a single QUIC connection across network switches, reducing reconnection latency from several hundred milliseconds to under 50 ms.

5. What are the implications of UDP-based transport for firewalls and CDNs?

Because QUIC uses UDP, many traditional firewalls that block or rate-limit UDP may drop traffic, requiring explicit allow-lists. CDNs need to support UDP termination and packet reassembly; otherwise, they fall back to HTTP/2. For example, a CDN may offer HTTP/3 as a setting you turn on per distribution, and clients on networks that block UDP still fall back to HTTP/2, so you must monitor which protocol your traffic actually negotiates.

6. How do you handle loss recovery in QUIC compared to TCP?

QUIC implements its own loss detection using packet numbers and acknowledges each packet, similar to TCP’s ACKs but with finer granularity. It never reuses a packet number, so lost frames are resent in new packets and an acknowledgement is never ambiguous the way a TCP retransmission can be. In practice, both detect a lost packet in roughly one RTT; the difference is that with QUIC only the stream that lost data waits for the retransmission, whereas with TCP every HTTP/2 stream on the connection waits behind the gap.

7. What migration strategy would you use to move a large service from HTTP/1.1 to HTTP/2 then to HTTP/3?

I’d adopt a phased rollout. First, enable HTTP/2 on the edge (e.g., ALB) while keeping backend services unchanged; this gives immediate multiplexing benefits. Next, instrument a small percentage of traffic (1-2 %) to use HTTP/3 via a feature flag, monitoring QUIC metrics like connection migration success. Finally, once QUIC stability is confirmed across regions, increase the flag to 100 % and keep HTTP/2 as the fallback for clients and networks that block UDP. Throughout, use canary deployments and A/B testing to compare latency and error rates.

8. How do you measure the performance impact of HTTP/3 in production?

I’d collect end-to-end latency, TLS handshake time, and error rates using distributed tracing (e.g., OpenTelemetry). Compare the 95th-percentile latency for HTTP/2 vs HTTP/3 over a representative traffic mix. Report the median and tail latency and the handshake time for each protocol side by side, split by network type, because the gain is largest on lossy and high-latency links.

9. What architectural considerations differentiate a senior-level answer from a staff-level answer on this topic?

A senior answer focuses on trade-offs: when multiplexing outweighs head-of-line blocking, the cost of TLS handshake, and the operational burden of UDP. A staff answer goes further: it outlines how to design observability for QUIC metrics, plans for progressive feature-flag rollout across heterogeneous edge locations, and anticipates future protocol evolutions (e.g., HTTP/4) by abstracting transport layers. Staff candidates also discuss how to align protocol choices with business SLAs and cross-team ownership.

How to practice this

  1. Sketch a diagram of a typical client-to-service request flow using HTTP/2 and then replace the transport layer with QUIC for HTTP/3. Label where multiplexing, header compression, and connection migration happen.
  2. Write a short answer for each of the nine questions above on a whiteboard or digital canvas. Aim for 60-120 words per answer and include a concrete number or example.
  3. Use System Design AI’s practice brief to get feedback on your canvas and refine the explanations. Iterate until the senior-level answer clearly flows into the staff-level depth.

Questions people ask

What is the biggest latency win from HTTP/3?

HTTP/3’s 0-RTT resumption can shave off a full round trip, roughly 100 ms on a typical 100 ms RTT connection, especially for short-lived requests.

Can I use HTTP/2 without TLS?

Technically yes, but most browsers require TLS for HTTP/2 over the public internet, so in practice you’ll almost always deploy it with TLS.

Does QUIC replace TCP entirely?

No. QUIC runs over UDP and coexists with TCP. Services often support both; traffic is steered based on client capability.

How do I debug a failed QUIC connection?

Enable verbose logging on the client and server, capture UDP packets with tools like Wireshark, and look for handshake failures or mismatched connection IDs.