2026 is an exciting year for the Rust compiler (and me)
Concept of the day · distributed systems
Backpressure
A queue that cannot say no is a queue that will fall over.
The mechanism. Backpressure is the signal a slow consumer sends upstream to make a fast producer slow down. Without it, the mismatch accumulates somewhere: an unbounded queue, a growing heap, a socket buffer, a disk. The system does not reject work; it accepts work it will never finish, and then dies with everything in flight.
Unbounded queues are the anti-pattern. An unbounded queue converts an overload problem into a latency problem and then into an out-of-memory crash. Bound every queue. Once bounded, you must decide what happens when it is full, and that decision is the design: block the producer (propagates backpressure naturally), drop the newest, drop the oldest (often right for telemetry — fresh data beats stale), or reject with a 429 and a Retry-After.
Why latency is the wrong signal to monitor. Under overload, latency rises before throughput falls, so a queue that is already doomed looks merely slow. Watch queue depth and wait time, and the ratio of arrival rate to service rate. Little's Law (L = λW) tells you the rest.
Load shedding beats queuing. A request whose client has already timed out is pure waste — you pay to compute a response nobody reads. Check the deadline before starting work, and drop requests that cannot finish in time. This is the single highest-leverage overload defence in most services.
Takeaway. Every link in the chain needs a bound and a documented behaviour at that bound. "It scales" means "it degrades predictably".