Every few years the transport layer gets rebuilt, and every rebuild makes the same trade: move complexity out of the kernel and into the application, then pay for it in cycles per byte. QUIC is the current version of that trade. It folds the TLS handshake into the transport handshake, gives every stream its own delivery guarantee, and runs entirely in userspace over UDP. TCP with TLS 1.3 keeps the kernel fast path and the middlebox ecosystem that has grown around it for forty years.
QUIC saves one round trip at connection setup and removes transport head-of-line blocking, but it moves packet processing into userspace, where a single core handles roughly one to three gigabits per second instead of ten or more.
Part One: What is being compared
TCP with TLS 1.3 is two handshakes stacked. The TCP three-way handshake costs one round trip before any bytes of TLS flow, then TLS 1.3 costs another round trip for a full handshake. Session resumption with a pre-shared key cuts the TLS part to zero round trips, but the TCP handshake still has to happen, so a resumed connection costs one round trip before the first request byte.
QUIC merges them. Its handshake carries the TLS 1.3 messages inside QUIC packets, so a fresh connection is ready after one round trip and a resumed connection can send application data in the very first flight, a zero-round-trip resumption. Streams are independent: a lost packet blocks only the stream whose bytes it carried, while TCP blocks every byte behind the gap because the kernel has one ordered byte stream per connection.
The second difference is where the code runs. TCP lives in the kernel, benefits from decades of tuning, and is often implemented in hardware on the network card. QUIC lives in the application, which means the application owns congestion control, loss recovery, pacing and encryption, and also owns the CPU cost of all four.
Part Two: The arithmetic
Start with handshake latency. On a 100-millisecond round trip, a fresh TCP plus TLS 1.3 connection needs 200 milliseconds before the first byte of response, and a resumed one needs 100. QUIC needs 100 for a fresh connection and zero for a resumed one, so a page load that opens six new connections saves roughly half a second in the fresh case and 600 milliseconds in the resumed case. For a user on a 4G link at 80 milliseconds, the saving is real but smaller than the marketing suggests, because the browser already pools and reuses connections.
Now the loss behaviour. TCP treats the connection as one stream, so a single lost segment stalls delivery of everything after it until the retransmission arrives, even if the later bytes belong to an unrelated resource. QUIC delivers each stream independently, so one lost packet stalls one stream. On a link with 1 percent loss and 100 milliseconds of round trip, the classic square-root formula puts a single TCP connection's throughput ceiling near 1.2 megabits per second regardless of available bandwidth. Six multiplexed resources share that ceiling and block each other; six QUIC streams share the congestion window but not the delivery order.
Then the CPU bill. Encrypting and decrypting in userspace, plus per-packet header processing, costs roughly two to three times the cycles of kernel TCP with hardware offload. A well-tuned QUIC server on one core lands somewhere between one and three gigabits per second, depending on packet size and whether the NIC supports generic and large receive offload. The same core running kernel TCP with TLS termination on a smart NIC can exceed ten. At 1,500-byte packets that gap is smaller; at small request-response packets, where per-packet overhead dominates, it widens.
Part Three: Where the model breaks
The first break is the middlebox. UDP is treated differently from TCP on many networks: some operators rate-limit it, some block it outright, and some consumer routers drop packets larger than 1,200 bytes. QUIC has to probe the path and fall back, and a connection that silently degrades to TCP has paid the complexity cost without the benefit. This is why every serious QUIC deployment keeps a TCP path and a working fallback.
The second break is that zero-round-trip resumption is replayable. The first flight can be replayed by an attacker, so it may only carry requests that are safe to repeat, which rules out most state-changing operations. The latency win applies to the first request of a session, not to the request that matters.
The third break is that head-of-line blocking did not disappear, it moved. QUIC removes transport-level blocking but congestion control is still shared across the connection, so a loss still halves the window for every stream. At high loss, all streams slow down together. The benefit is that they do not wait on each other's retransmissions, which matters most for many small objects and least for one large transfer.
Part Four: The later cost
Operating QUIC is a different job. Because the protocol is encrypted end to end, middleboxes cannot inspect or help it, so observability has to come from the endpoints: per-stream timing, packet-level traces, and a key log for debugging that must be handled like a secret. Load balancers need to route on connection IDs rather than addresses, because a mobile client's address changes mid-connection and the connection is supposed to survive it. Connection migration is a feature, and it is also a new class of bug.
TCP's cost is the opposite: it is boring, instrumented everywhere, and offloaded by hardware. Its weakness is that the kernel's congestion control and loss recovery evolve slowly and are shared by every application on the host, so a latency-sensitive service competes with a bulk transfer in the same stack.
There is also a deployment asymmetry. QUIC ships with the application, so a fix reaches users when they reload the page. TCP improvements require kernel upgrades across the fleet and sometimes across the customer's operating system. That velocity is worth a lot when you are tuning congestion control for a specific traffic mix.
Part Five: Outside the team
For a user, the difference appears as time to first paint on a cold connection and as whether a video call freezes when one participant's Wi-Fi hiccups. On a lossy mobile link, independent streams mean the page's text arrives while the images are still recovering. On a clean fibre link, the difference is close to unmeasurable.
For the operator, the difference is cores. A CDN terminating QUIC at ten million concurrent connections spends a meaningful fraction of its fleet on packet processing that TCP would have pushed into the NIC. That cost is paid per byte, so it scales with traffic in a way that hardware offload does not.
A fair comparison holds round-trip time, loss rate, object count and packet size fixed, then measures time to first byte, time to last byte and CPU seconds per gigabyte. Comparing a QUIC benchmark on a lossy link against a TCP benchmark on a clean one is the standard way to reach the wrong conclusion.
Market sizing check
If most consumer traffic eventually runs over QUIC and the transition takes the better part of a decade, the tooling around it — load balancers, observability, hardware offload and managed edge termination — is plausibly $3B to $8B a year by 2032. The swing factor is how quickly NIC vendors absorb QUIC processing into silicon.
These figures synthesise published ranges under a stated adoption model; they are not a measurement of any vendor's revenue.
The comparison that matters
The comparison that matters is between a protocol that buys a round trip and per-stream delivery with userspace CPU, and one that keeps kernel speed and universal reach. QUIC wins on high-latency, lossy, many-object workloads and on any product where connection setup is on the critical path. TCP with TLS 1.3 wins on bulk throughput, on networks that mistreat UDP, and anywhere CPU per byte is the binding constraint.
The ranking assumes the path is clean enough for UDP and the server has cores to spare. Remove either assumption and the answer flips without the protocols changing.
Deploy QUIC where the first round trip and per-stream delivery are worth two to three times the CPU per byte, and keep a TCP path because a meaningful share of the internet will still drop your UDP packets.
SOL: HCqPmPJM3NVtS6YrmVaTZYnuP8XZ2PFgQZKT94VK1LkS
If this saved you time, a tip is appreciated.
Top comments (0)