It's the work, not the machine.

Scale was the answer.

For as long as we have had computers, we have been chasing more. Software has always pushed against the limits of available compute, its demands outpacing the gains that better hardware delivered. The newest processors were fast, until they weren't. Storage was plentiful, until it filled. Bandwidth was abundant, until it saturated.

The fix always seemed obvious: build bigger, faster machines. And for decades it worked. Nearly every major advance came from adding capacity, with quicker processors, more memory, larger storage, bigger data centers, and faster networks. Whole industries grew up around that one idea. Moore's Law became a roadmap, cloud computing became a business model, and the hyperscalers became some of the most valuable companies on earth. In every era, scale was the answer, and in every era it was the right one.

The work fit the machine.

Underneath that history is a simpler pattern. Every era of computing is defined by the relationship between work and machines, and when that relationship changes, a new era begins. Mainframes were built for batch work, personal computers for interactive work, the cloud for web-scale distributed work. In each case the dominant way of executing matched the dominant work of its time. The work fit the machine.

Something changed.

We are building larger and faster systems at a pace never seen before, and yet we keep losing ground. Modern workloads run everywhere at once, across clouds, regions, clusters, networks, and edge environments, and teams now spend enormous effort deciding where work should run, when it should run, and how it should move between resources. The systems are bigger than ever, and the work is harder than ever to place.

The reason is the old pattern running in reverse. The workload changed shape and the execution model did not.

The mismatch is the cause.

For most of the last twenty-five years, infrastructure was built around predictable work: web applications, APIs, databases, the services beneath them, all of it scaling in fairly linear ways. That work has since become larger, more dynamic, and more distributed than the systems beneath it were designed to run, and it places fundamentally different demands on the resources that execute it. The challenge is no longer scaling machines to do the work. It is matching the work to the right machines.

When the work no longer fits the machine, we compensate, layering on orchestration, scheduling, and management tools until the systems grow more complex and their inefficiencies compound. So what looks like a performance problem, a scaling problem, or a cost problem is usually the same problem seen from a different angle. Complexity is the symptom. The mismatch is the cause.

The bottleneck moved.

For decades the binding constraint was computational capacity. Capacity still expands, faster than ever, but a growing share of our effort goes to coordinating work rather than executing it. None of this means scale stops mattering. We will go on building larger processors, clusters, networks, and data centers. It means raw capacity can no longer solve for work that is misaligned with the machine. The bottleneck has moved from compute volume to compute fit.

The next era is compute fit.

The next era will not be defined by who builds the largest machines. It will be defined by who best fits the work to them. The companies that shape the coming decade will not simply add more capacity; they will unlock the value sitting unused in the capacity that already exists.

Every era of computing is a story about the relationship between work and machines. When that relationship breaks, a new era begins, and I believe we are entering one of those moments now.

The workload changed shape. The execution model did not. It's the work, not the machine.