The Cloud’s Broken Abstractions
The cloud, as we know it today, is fundamentally flawed. The issues go beyond user experience or poor API design; the building blocks of today’s clouds are the wrong shape. Virtual machines (VMs) are tied to CPU and memory resources, making it difficult to run multiple VMs on a single computer without taking isolation into one’s own hands. This leads to additional complexity, management overhead, and performance penalties. The cloud abstraction is the wrong shape, and it’s time to fix it.
Cloud providers have attempted to solve this problem with “Platform-as-a-Service” (PaaS) systems, but these abstractions are inherently less powerful than a computer and are often bespoke to a particular provider. This means learning a new way to write software for each compute vendor, only to find that something easy on a normal computer is nearly impossible due to some obscure limit of the platform system. It’s a frustrating experience that has led many to question the cloud’s value proposition.
The problems don’t stop there. Cloud providers’ disk offerings are also suboptimal. Remote block devices, which were introduced when hard drives were the norm, make sense in that context. However, with the widespread adoption of solid-state drives (SSDs), the seek time has decreased dramatically, making remote block devices a significant bottleneck. The IOPS overhead of remote systems has increased from 10% with hard drives to over 10x with SSDs, making it difficult to configure an EC2 VM to achieve high IOPS without breaking the bank.
The Unspoken Consequences of Cloud Lock-in
While cloud providers tout the benefits of their platforms, the unspoken consequences of cloud lock-in are significant. The costs of using a cloud provider’s network, for example, are often prohibitively expensive. The standard price for a GB of egress from a cloud provider is 10x what you would pay racking a server in a normal data center. This makes it difficult for projects with modest budgets to scale affordably. The fundamental technology is sound, but the limits placed on users by cloud providers make it challenging to build affordable solutions.
The pain of using cloud providers’ APIs has led to the development of projects like Kubernetes, which attempt to paper over the pain. However, even Kubernetes struggles with the fundamental limits of cloud abstractions. VMs are hard to manage, disk is slow, and networking is complicated. It’s tempting to dismiss Kubernetes as a solution, but the truth is that it’s a product attempting to solve an impossible problem: making clouds portable and usable.
The reality is that making Kubernetes good is inherently impossible. It’s a project in putting high-quality lipstick on a pig. We’ve been muddling along with these miserable clouds for 15 years now, but it’s time to fix the underlying problems.
The Changing Landscape: Agents and the Future of Compute
Something has changed in the landscape: we have agents now. Agents, by making it easier to write code, mean there will be a lot more software. This, in turn, means we need private places to run them, easy sharing with friends and colleagues, and minimal overhead. The cloud, which was an annoying pain, becomes a much bigger pain as we write more software. We need a lot more compute, and we need it to be easier to manage.
Agents help to some degree, but they struggle with the fundamental limits of cloud abstractions as much as we do. They need more tokens than they should, and they get a worse result than they should. Every percent of context window the agent spends thinking about how to contort classic clouds into working is context window not used to solve the problem.
The launch of exe.dev today addresses the VM resource isolation problem, allowing users to provision CPU and memory and run the VMs they want. The platform also includes a TLS proxy, an authentication proxy, local NVMe disk with blocks replicated off-machine asynchronously, and regions around the world for machines. There’s still more to build, but it’s a step in the right direction.
The Skeptical Case: What Could Go Wrong?
While the launch of exe.dev is promising, there are potential pitfalls to consider. What if the new platform is not scalable? What if it’s not secure? What if it’s not compatible with existing software? These are all valid concerns that need to be addressed. However, the bigger question is: what’s the alternative? Continuing to use broken cloud abstractions is not a viable option.
The lesson here is that it’s time to rethink the cloud. We need to stop papering over the pain and address the underlying problems. We need to build new abstractions that are more powerful, more flexible, and more scalable. We need to build a cloud that’s worth using.
What’s Next: A Verifiable Event to Watch
The next verifiable event to watch is the adoption of exe.dev by developers and businesses. Will they flock to the new platform, or will they stick with the status quo? The answer will depend on how well exe.dev addresses the fundamental problems of cloud computing. If it succeeds, it could be a game-changer. If it fails, it will be back to the drawing board.
One thing is certain: the cloud needs to change. It’s time to fix the broken abstractions and build a cloud that’s worth using.
Bookmark this one — it will matter to your business decisions this week.
By Priya Nair, AI & Startup Reporter at TrendFlashy
Ready to launch your own asset?
Check out our guide on Building a Profitable Online Business.
