QUIC in the wild: what actually changes when you leave TCP
For a long time I treated the TCP-versus-QUIC discussion as an academic one. Both transports eventually move bytes, both have congestion control, and on a healthy path the difference is a couple of round trips at connection setup. Then I spent a week on a link that dropped a quarter of its packets and the distinction stopped being academic.
Head-of-line blocking is not a theory
With a single TCP connection carrying several streams, one lost segment stalls every stream behind it until the retransmission arrives. On a clean path that costs a few milliseconds. On a path where one packet in four disappears, the loss recovery window dominates everything else: you spend most of your time waiting for retransmits that themselves get lost.
QUIC gives each stream its own delivery guarantees. A lost packet blocks only the stream it belonged to. If you are multiplexing many small requests, this is the difference between "sluggish" and "unusable".
The retransmission timer is the real villain
TCP's initial retransmission timeout is one second, and it doubles. Two consecutive losses cost you three seconds before the connection even starts moving data. That number is baked into the kernel and it is why a lossy link feels like it has a one-second floor on some fraction of requests regardless of how much bandwidth you have.
QUIC implementations use a much tighter probe timeout and can send speculative retransmissions. Combined with larger initial congestion windows, the practical effect is that the pathological tail shrinks dramatically.
# what the tail looks like, roughly
p50 155 ms
p90 158 ms
p99 1100 ms <-- retransmission timeout
max 2200 ms <-- two consecutive losses
Where QUIC hurts
UDP is a second-class citizen on a lot of networks. Some middleboxes rate-limit it, some drop it entirely, and a surprising number of consumer routers handle large UDP bursts badly. You also lose the kernel's highly optimised TCP stack: user-space transports copy more, burn more CPU, and need their socket buffers raised or they cap out well below the link rate.
That last point bit me. The default receive buffer is 208 KB, which on a 150 ms path caps throughput far below what the link can do. The fix is one line:
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
When to switch
Clean path, latency-sensitive, few large transfers: TCP is fine and cheaper. Lossy path, many concurrent streams, or you care about the tail: QUIC is not a marginal improvement, it is a different experience. Measure both, keep both, and let the fallback exist.