The Pendulum Swings Local

Computing history is one long custody battle over where the work happens. The mainframe held everything; the PC took it away; the cloud took it back, and for fifteen years "deployment" has meant sending your software to live in someone else's building. Each swing was driven by an economic asymmetry, and each reversed when the asymmetry did.

Look at the current asymmetry honestly. The laptop developers carry today embarrasses the virtual machines most of them rent: more cores, absurdly more memory bandwidth, an NPU idling while a cloud GPU bills by the second. Meanwhile the central cloud's costs are rising with its power bill and its attention is elsewhere. My claim: the pendulum is swinging local again, it will take a specific and predictable set of workloads with it within five years, it will leave another set behind permanently, and the interesting casualty is the word "deployment" itself.

The forces pushing outward

Three pressures, compounding. Hardware abundance at the edge: consumer silicon got so good that the average end-user device is an underused supercomputer, and shipping work to it costs nothing at the margin. Portability: WebAssembly matured into the thing Java promised, a compute unit that runs the same everywhere, which dissolves the old technical excuse for centralizing, and the local-first movement built the state layer to match, the essay we quoted when defending our own desktop decision having quietly become an engineering discipline with production CRDT libraries rather than a manifesto. And physics: latency to a datacenter has a floor, latency to the device in your hand doesn't, and interactive AI made every one of those milliseconds legible to users who never cared before.

Add the motive nobody markets: sovereignty. Data that never leaves the device is data no cloud subpoena reaches, which makes local placement the one privacy architecture that doesn't require trusting anyone's compliance page.

What leaves, what stays

The sorting rule, and it's the whole post in two sentences: compute follows latency, state follows trust. Work migrates toward wherever its latency budget points, and authoritative state stays wherever the parties who must trust it can agree to put it.

So the leavers, over five years: interactive compute of every kind, editor intelligence, small-model inference, media processing, dev environments, the entire category of "round trip to a server to compute something my chip does faster". Collaborative documents keep their working state local with sync behind, because local-first won that argument on user experience alone. The stayers, permanently: coordination between mutually distrusting parties, systems of record with one truth and many writers, batch and training work that wants a gigawatt rather than a laptop, and anything where the state's whole value is that no single participant holds it. Payments don't go local. Consensus doesn't go local. The database of record retreats to the center and gets more important there, not less.

The misfit predictions are where money burns: pushing consensus-shaped problems to the edge because latency is fashionable, or holding interactive compute in a region because that's where the servers already are. Both mistakes come from sorting by hype instead of by the rule.

What happens to "deployment"

Here's the part that touches everyone with a deploy button. When an application is some compute on devices, some at the edge, some central, plus state split by trust boundary, "deploy" stops meaning "copy artifacts to the server" and starts meaning "reconcile a placement decision across a topology", which is a graph problem wearing an ops costume. The unit you reason about stops being a server or a region and becomes the map itself: what runs where, what syncs with what, which piece is authoritative. We have an obvious horse in that race, since modeling infrastructure as a graph is our entire thesis, and the swing local is the strongest tailwind that thesis has: the more places software lives, the more valuable the map of where.

The steelman: we've heard this pendulum before

Skepticism has receipts. Edge computing was the future in 2017 and stayed the future; data gravity is real and pulls compute toward the data, which mostly lives centrally; a fleet of heterogeneous user devices is an operational nightmare compared to one region you control; and the cloud's ops simplicity, one place to look when things break, is worth more than most latency budgets. The pendulum metaphor itself oversells: the PC never killed the mainframe, which is still there, running your bank.

All fair, and the last point is actually the model, not the objection. Swings don't replace; they re-sort, and the mainframe surviving inside its correct niche while losing the general case is precisely what "the cloud never dies, the default dies" looks like from the other end. The claim here is deliberately modest: no exodus, just a re-sorting of specific workload classes by a legible rule, most of it invisible to end users, all of it consequential for whoever sells the picks and shovels. The immodest version, that the center empties, is not on offer and never was.

Five years from now, the question in your architecture reviews won't be "which region", but "which side of the latency-and-trust line", asked per component, the way "cloud or on-prem" quietly became "per workload" once the math got honest. The teams that already have a map of what runs where will find the sorting routine. The teams that don't will discover their topology the way most companies discover their dependencies, during an incident. Which team is yours, and for which of your components could you answer the line question today?