Four virtues — reliable, adds nothing, wastes nothing beyond a known cost, swappable — turn out to converge in one pattern that’s been sitting in plain sight since 1999: an HTTP GET with a Range header, bounded by a timeout. Paged. A bytestream. Nothing more.

Paged gets the addressability already established across this series — one lookup for the whole resource, then independent, O(1) access to any byte range within it, no coordination required between requests. Bytestream gets the content-agnosticism — the interface doesn’t know or care whether the bytes are a JPEG, a Parquet row group, or a database backup, the same indifference that made S3’s API reimplementable by strangers. Both pieces have had full posts already. The timeout hasn’t, and it’s the part that keeps the whole thing honest.

The DNS Lookup Buys the Redirect for Free

There’s a piece sitting one layer above the byte-range request that makes the whole pattern work without anyone building extra machinery for it. One DNS lookup, coarse and infrequent, happens once per connection, before a single byte-range request goes out. DNS is a dumb wire in exactly the same sense as the request that follows it — a name resolves to an address, content-agnostic, no opinion about what’s actually being fetched.

Because that resolution happens first and separately, every byte-range request that follows inherits redirect and CDN routing for free, without the paging layer ever needing to know it happened. The name resolves to whichever edge node, load-balanced origin, or anycast target is nearest or least loaded right now — decided fresh, per lookup, entirely invisible to the GET and Range header that come after it. The paged bytestream layer doesn’t route. It doesn’t load-balance. It doesn’t need to, because all of that intelligence lives one dumb wire up the stack, resolved once, before the addressable layer ever has to think about it.

Failure Has to Stay Dumb Too

A byte-range request with no timeout is making a promise it never states out loud: I will keep trying, indefinitely, until I succeed. That’s an unbounded commitment dressed up as patience, and it’s the exact shape of hidden cost a smart wire makes — a cost that looks free right up until the day the connection never resolves and nothing downstream knows whether to keep waiting or give up.

A timeout refuses that promise on purpose. It doesn’t try to diagnose why the request is slow — congestion, a dead mirror, a corrupted range, cosmic rays. It doesn’t retry with clever backoff logic on the caller’s behalf, guessing at what might work better. It just counts to a known number and hands back a plain failure signal, on schedule, every time. That’s Use-Pull applied to failure handling specifically: the wire doesn’t decide what recovery should look like. It bounds its own patience, discloses the bound in advance, and lets whoever’s actually equipped to make the recovery decision — retry, fail over to a mirror, surface an error to a human — make it.

One Pattern, All Four Virtues

Reliable, because a bounded wait is a guarantee in a way an unbounded one never is — you always get an answer, success or defined failure, inside a known window. Adds nothing, because the lookup, the range, and the timeout are all agnostic to what’s actually being fetched or where it currently lives. Wastes nothing beyond a known cost, because the timeout is the disclosed cost, stated up front instead of discovered the hard way. Swappable, because every implementation of this pattern — S3, R2, StackIT, any CDN built since — inherited it for free by speaking the same twenty-seven-year-old header, routed through the same decades-old naming layer.

Nobody had to invent a better dumb wire. It’s been DNS plus the timeout on an ordinary HTTP request the entire time.

This post is part of the Gutenberg/Semantic series. Related: In Praise of Dumb Wires on the four virtues this pattern satisfies at once, and Ambiguity Is Not a Bug on surfacing uncertainty instead of hiding it.