HTTP/2 and HTTP/3
HTTP/2 and HTTP/3 are two ways to carry the same HTTP requests and responses more efficiently. HTTP/2 multiplexes streams over TCP, while HTTP/3 maps HTTP onto QUIC so loss on one stream does not stall the others.
itNetworking | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — HTTP/2 and HTTP/3
HTTP/2 and HTTP/3 are not two replacement HTTPs waiting outside the old HTTP's house with boxes. They keep the familiar meaning of methods, status codes, fields, and content. The useful change is how one connection carries those messages. HTTP/2 divides them into frames and interleaves streams over TCP. HTTP/3 carries HTTP over QUIC, which uses UDP underneath. Same conversation, different plumbing, and plumbing is where the queues live.
Before HTTP/2, concurrent browser work often meant several TCP connections, or pipelining with an unfortunate tendency for one request to hold up the procession. HTTP/2 gives each exchange a stream, so a large response does not have to occupy the entire HTTP message lane. But TCP still delivers one ordered run of bytes. Lose one segment and later bytes wait, which can leave several streams staring at the same missing parcel.
HTTP/3 changes that particular arrangement. QUIC orders data within each stream, not across every stream. If one stream loses data, another stream whose data arrived can continue. This is not a universal permission slip stamped “faster.” Congestion, flow control, server queues, application dependencies, and QPACK field compression can still make progress wait. The protocol moved a queue; it did not repeal queues, which was probably beyond its charter.
The surprising part is that protocol version is decided per hop. A browser can speak HTTP/3 to an edge proxy, while that proxy speaks HTTP/2 to an origin. An HTTPS address does not carry a version label. HTTP/2 is commonly chosen with ALPN during a TLS handshake. HTTP/3 needs a QUIC connection and can be advertised through Alt-Svc. That is why a rollout normally keeps the earlier path: some networks obstruct UDP, and a graceful fallback is compatibility rather than defeat.
The Intro explains the connection models, loss behavior, compression, discovery, 0-RTT replay risk, and migration in full. The Slides place the two stacks and their failure modes beside each other. Keep the Cheatsheet nearby when a frame, stream, flow-control window, or deployment signal needs a precise name. The quiz then asks whether the mental model survived contact with the wire.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.rfc-editor.org/rfc/rfc9110.html
Supports
- HTTP methods, status codes, fields, content, messages, connections, and intermediary semantics
- Stable HTTP semantics across version-specific mappings
- Safety, idempotency, and replay considerations for requests
- https://www.rfc-editor.org/rfc/rfc9113.html
Supports
- HTTP/2 as binary framing over TCP
- Streams, multiplexing, frame types, flow control, settings, errors, and graceful shutdown
- TLS ALPN negotiation with h2 and deprecation of the h2c upgrade mechanism
- HPACK use and TCP head-of-line blocking limits
- https://www.rfc-editor.org/rfc/rfc7541.html
Supports
- HPACK static and dynamic tables, literal representations, and connection compression state
- Field-list size limits, sensitive-field handling, and compression security considerations
- https://www.rfc-editor.org/rfc/rfc9000.html
Supports
- QUIC as a secure general-purpose transport over UDP
- Independent ordered streams, flow control, congestion control, acknowledgments, and loss recovery
- Connection identifiers, path validation, migration, and address changes
- Zero round-trip data prerequisites and replay risk
- QUIC version 1 publication in May 2021
- https://www.rfc-editor.org/rfc/rfc9114.html
Supports
- HTTP/3 as a mapping of HTTP semantics over QUIC
- Request streams, control streams, critical unidirectional streams, frames, and settings
- Per-stream progress under loss and remaining connection-level limits
- HTTP/3 endpoint discovery, server push, zero round-trip data, and transition differences from HTTP/2
- HTTP/3 publication in June 2022
- https://www.rfc-editor.org/rfc/rfc9204.html
Supports
- QPACK static and dynamic tables
- Dedicated encoder and decoder streams
- Blocked-stream limits, required insert counts, acknowledgments, and cancellation
- Compression-efficiency and blocking-risk tradeoff
- QPACK publication in June 2022
- https://www.rfc-editor.org/rfc/rfc7838.html
Supports
- Alternative services as another endpoint for an origin
- Alt-Svc advertisement, authority, lifetime, and security requirements
- https://www.rfc-editor.org/rfc/rfc9308.html
Supports
- QUIC applicability, UDP blocking, fallback, traffic classification, and operational considerations
- Performance dependence on network and application conditions
- Migration, load-balancing, and observability considerations
- https://github.com/sindresorhus/awesome
Supports
- Starting index used to discover networking, testing, and web-performance lists
- https://github.com/denji/awesome-http-benchmark
Supports
- Curation of curl and Hurl as HTTP testing tools
- Curation of h2load as an HTTP/2 benchmarking tool
- Topic relevance to HTTP/2 and HTTP/3 testing and benchmarking
- https://curl.se/docs/http3.html
Supports
- curl HTTP/3 build backends and capability
- HTTP/3-only and fallback modes
- Alt-Svc cache use and HTTP/3 connection testing
- https://hurl.dev/docs/manual.html
Supports
- Hurl request execution and testing
- HTTP/2 and HTTP/3 selection
- Response assertions and protocol-version testing
- https://nghttp2.org/documentation/h2load-howto.html
Supports
- h2load request, client, and concurrent-stream benchmark controls
- ALPN selection, flow-control options, timing-based tests, and HTTP/3 support
- Warning against benchmarking public servers without authorization
- https://www.ietf.org/blog/http2-approved/
Supports
- HTTP/2 work beginning in 2012 from SPDY
- IETF approval of HTTP/2 and HPACK in February 2015
- https://www.rfc-editor.org/rfc/rfc7540.html
Supports
- HTTP/2 publication in May 2015
- https://blog.cloudflare.com/http-3-from-root-to-tip/
Supports
- HTTP over QUIC adopting the HTTP/3 name in 2018
- https://blog.cloudflare.com/cloudflare-gateway-http3-inspection/
Supports
- Cloudflare QUIC and HTTP/3 edge deployment milestones
- Operational and security tradeoffs for inspection of QUIC and HTTP/3 traffic
- https://www.fastly.com/documentation/guides/full-site-delivery/performance/enabling-http3-for-fastly-services/
Supports
- HTTP/3 as an optional viewer upgrade with fallback
- HTTP/3 support for viewer connections rather than Fastly-to-origin connections
- 0-RTT and ACL handling guidance
- Protocol selection and fallback telemetry considerations
- https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/DownloadDistValuesGeneral.html
Supports
- CloudFront viewer configuration for HTTP/2 and HTTP/3
- TLS 1.3 and connection migration conditions for CloudFront HTTP/3
- https://techdocs.akamai.com/property-mgr/docs/http3-support
Supports
- Akamai HTTP/3 property behavior, gradual rollout, Alt-Svc, and continued HTTP/2 support
- https://developers.cloudflare.com/speed/optimization/protocol/http3/
Supports
- Cloudflare HTTP/3 configuration
- https://nginx.org/en/docs/http/ngx_http_v3_module.html
Supports
- NGINX HTTP/3 listener configuration, Alt-Svc advertisement, connection IDs, and stream limits
- https://blog.cloudflare.com/accelerating-udp-packet-transmission-for-quic/
Supports
- UDP implementation and host-path performance concerns for QUIC
