If you were online yesterday, June 12, 2025, you might have noticed things got a little… chaotic. Cloudflare, the superhero of internet infrastructure, hit a snag that left a colorful mess (pun intended—check out that awesome image above!) across the web. Let’s dive into what happened during this 148-minute outage, why it mattered, and take a deeper look at the fascinating tech behind it—Durable Objects.
The Outage That Shook the Web
Yesterday, Cloudflare’s lights flickered, and it wasn’t just a minor glitch. For 148 minutes (that’s 2 hours and 28 minutes, to be exact), services like Workers KV, WARP, Access, and even parts of the Cloudflare Dashboard went dark. This wasn’t a small hiccup—Cloudflare handles over 25 million HTTP requests per second and boasts a network spanning 330 cities across 125 countries. When it stumbles, the internet feels it.
The culprit? A failure in the underlying storage infrastructure for Workers KV, a key component for many Cloudflare services. Workers KV is designed as a “coreless” service, meaning it should run independently across Cloudflare’s global data centers with no single point of failure. However, it relies on a central data store for a “source of truth.” When that store—tied to Google Cloud—went down, it triggered a cascading effect. Yep, Google Cloud’s outage yesterday amplified the chaos, impacting not just Cloudflare but the countless websites and apps depending on it for CDN and web firewall services.
Cloudflare’s CTO, Dane Knecht, owned up to it, promising a detailed postmortem (which they’ve already started drafting—kudos for transparency!). The outage wasn’t just a tech fail; it sparked a bigger debate about relying on hyperscalers, a point DHH hammered home in his own X posts about returning to bare metal.
Why This Matters
With Cloudflare powering a huge chunk of the internet, this outage had real-world impacts. Teams worldwide scrambled as their websites lagged or went offline. The dependency on third-party providers like Google Cloud raised eyebrows—why would a company with 330 data centers lean on someone else’s infrastructure? Bas speculates it’s a trade-off: Cloudflare’s all-in on its Workers platform and Durable Objects, but building a fully independent distributed file system might stretch their engineering resources thin. Fair point! This incident is a wake-up call to balance convenience with resilience, especially when the internet’s original DARPA design aimed to survive nuclear strikes.
Diving into Durable Objects: The Tech Behind the Scenes
Now, let’s geek out a bit! The YouTube video gives us a great starting point to unpack Durable Objects, the innovative tech at the heart of this outage. These are Cloudflare’s secret sauce for building stateful serverless applications, and they’re pretty cool once you get under the hood.
What Are Durable Objects?
Durable Objects are a compute-with-storage building block in Cloudflare’s serverless ecosystem. Unlike traditional serverless functions that are stateless (they forget everything after each run), Durable Objects let you keep state—think of them as persistent JavaScript objects that stick around and can be accessed anywhere in Cloudflare’s network. They run on V8 isolates, the same engine powering Google Chrome, with each isolate acting like a browser tab—isolated but capable of holding data.
How Do They Work?
Here’s the magic: when you define a Durable Object in your code, it looks like a regular JavaScript class. But Cloudflare handles the heavy lifting—spinning it up, persisting its state, and syncing it across their global network. Each Durable Object is tied to a specific location, and synchronization ensures consistency. This is where things get interesting (and a bit tricky). The persistence and syncing rely on underlying storage, which, in this case, looped back to Google Cloud. When that link broke, the whole chain faltered.
Durable Objects vs. D1
Cloudflare also offers D1, a serverless SQLite database built on Durable Objects. D1 is great for relational data but isn’t colocated with your application code, which can add latency. Durable Objects, on the other hand, give you low-level control with embedded SQLite, perfect for distributed systems. The trade-off? You might need to build custom database tools, unlike D1’s out-of-the-box features. It’s a choose-your-own-adventure scenario based on your app’s needs!
The Zero Cold Start Promise
One perk of Durable Objects is their near-zero cold start times. Since they load during the TLS handshake, your code is ready to roll almost instantly—unlike some serverless platforms (cough, AWS Lambda, cough) where cold starts can slow things down. However, if a Durable Object isn’t busy, it might get evicted from memory, making in-memory caching less useful unless it’s handling heavy traffic.
Lessons Learned and Looking Ahead
Cloudflare’s response was solid—frequent status updates and a commitment to fix the root cause. Their postmortem will likely dive into decoupling from upstream dependencies like Google Cloud, a move that could bolster resilience. For developers, this is a nudge to weigh the pros and cons of third-party services. Want scalability and zero cold starts? Great! Just don’t put all your eggs in one basket.
As for Durable Objects, they’re a game-changer for stateful serverless apps, especially with AI agents and distributed systems. But this outage highlights the need for redundancy in their storage layer. Maybe we’ll see Cloudflare roll out a homegrown solution—fingers crossed!
Wrap-Up
Yesterday’s Cloudflare outage was a messy but educational moment for the internet. It showcased the power and pitfalls of modern infrastructure, with Durable Objects playing a starring role. Whether you’re a developer or just a curious soul, it’s a reminder to build with resilience in mind. Got thoughts? Drop them below—I’d love to chat! And hey, if you need more details, I can always dig deeper with a search. Until next time, keep exploring the tech frontier!
Top comments (0)