Apparently, the internet belongs to the hyperscalers. Maybe it’s time we take it back

The past month has been an uncomfortable reminder of something many of us already suspected: the Internet doesn’t really belong to us anymore. It belongs to the hyperscalers. When AWS hits a wobble, half the world stalls. When Cloudflare has a bad morning, entire regions grind to a halt. And when both incidents happen almost back to back, it stops feeling like a coincidence and starts looking like a systemic warning.

‍

For years, we’ve built on the comforting assumption that cloud infrastructure is always-on, self-healing and magically resilient. That the messy bits, routing, edge behaviour, global failover and control-plane logic, were someone else’s problem. But the recent outages made something clear: if you don’t control the underlying infrastructure, you don’t control your own uptime.

‍

It’s ironic. The cloud gave us unprecedented freedom at the application layer, but only by locking us deeper into infrastructure we don’t own, can’t influence and often barely understand. That’s not a criticism of the hyperscalers; they run some of the most complex systems ever engineered. Outages are inevitable. The problem is that we outsourced so much that we no longer have meaningful control when things go wrong.

‍

At some point, we stopped being operators and quietly became tenants.

‍

How we handed over control

This wasn’t a hostile takeover. It was a series of perfectly logical decisions.

‍

Cloud regions were cheaper and faster than building our own.

‍

Managed services were easier than running stacks ourselves.

‍

Global CDNs solved reach and performance without effort.

‍

Managed routing and DNS abstracted complexity.

‍

One by one, layers of control were traded for convenience. Everything still “felt” like ours (our app, our customers, our SLA, our uptime), so we didn’t notice how much we’d handed over.

‍

But convenience slowly turned into dependence.

‍

Dependence turned into reliance.

‍

And now reliance is starting to look a lot like fragility.

‍

When the giants stumble, we fall with them

The striking thing about the recent outages wasn’t the outages themselves. It was their blast radius. A routing issue in one region spills traffic into another. A global CDN misbehaves and, suddenly, retry storms take down services that weren’t even part of the original fault. Edge nodes drift out of sync, and every app built on top of them inherits the chaos.

‍

Everything sits on top of something else, and when the layer beneath slips, the impact is immediate and widespread.

‍

Ten years ago, if a hosting provider struggled, its own customers suffered. Today, when a hyperscaler or global CDN stumbles, it can disrupt authentication, payments, content delivery, APIs, SaaS platforms and entire national systems. It’s not that the cloud is unreliable – it’s that too much relies on the same cloud at the same time.

‍

The world is changing, but our architectures aren’t

There was a time when choosing a cloud provider was a purely technical decision. Today, it’s entangled with geopolitics, data residency, sovereignty debates, latency expectations and compliance requirements. Cross-border routing isn’t just about performance anymore; it’s about policy. The Internet is getting more fragmented, not less.

‍

But our architectures still behave as if every cloud region, every control plane, every traffic flow will always be available and stable. The past month showed us that the assumption doesn’t hold up anymore.

‍

A more balanced internet is a more resilient one

Let’s be honest: the hyperscalers do promise infallibility – at least on paper. “Five nines.” “Zero downtime.” SLAs so generous they sound like marketing dares: 250% service credits, mathematically impossible availability targets.

‍

But SLAs today aren’t guarantees.

‍

They’re insurance payouts.

‍

Numbers are designed to look comforting, not to reflect real-world complexity. We’ve all seen enough outages to know that nobody is delivering five nines at Internet scale – not consistently, not globally, and definitely not for everyone at once.

‍

The mistake wasn’t believing the cloud would never fail.

‍

The mistake was letting ourselves build architectures where someone else’s uptime target quietly became our own.

‍

If anything, the recent outages should be viewed as a nudge. A reminder that resilience isn’t inherited from a provider. It’s designed. It’s tested. And ultimately, it’s owned.

‍

The internet may structurally belong to the hyperscalers, but that doesn’t mean the systems we build on top of it have to be at their mercy.

‍

Taking back control doesn’t mean abandoning the cloud

When I say “take it back,” I’m not talking about abandoning the cloud or dragging racks of servers back into the office. That era isn’t coming back – nor should it. The hyperscalers remain essential pillars of the modern Internet. The issue isn’t the cloud itself. The issue is building systems that behave as if the cloud will never fail.

Taking back control starts with something simpler and more realistic: bringing balance back into the architecture.

‍

For years, we optimised for global scale, even when our risks were local. We designed around global control planes, global failover logic and global traffic flows, even when our users – and our outages – were regional. The hyperscaler model nudged everyone in that direction because global was easier, cheaper and always one click away.

‍

But the reality of 2025 is that regional and local resilience matter again. The more autonomy a region has – in routing, in failover, in handling upstream chaos – the less damage a global incident can cause. It isn’t about replacing the hyperscalers; it’s about not letting our entire architecture depend on pressure points outside our control.

‍

This shift doesn’t require a revolution. It just requires different defaults.

• Local-first where it makes sense.
• Regional independence instead of centralised orchestration.
• Fewer cross-border dependencies that break when a global platform wobbles.
• Multi-region setups that are actually tested.
• Critical paths that can stand on their own when upstream falters.

Small decisions add up.

‍

And each one takes back a little more control – control we quietly surrendered when everything moved into someone else’s infrastructure.

‍

“Taking it back” isn’t anti-cloud.

‍

It’s anti-helplessness.

‍

Final thought

Apparently, the Internet belongs to the hyperscalers. Fair enough.

‍

But our resilience, our uptime, our customer experience – those should belong to us. And that starts with reclaiming the parts we can control instead of assuming the global cloud works all the time.

‍

Maybe we don’t need to own the internet.

‍

But we do need to stop pretending that someone else’s infrastructure is a substitute for our own responsibility. And the sooner we design around that reality, the less painful the next global outage will be.