Why We Chose Cloudflare as Our Cloud Provider
How HookDeploy's edge-first architecture led us to Cloudflare: Workers for zero-latency ingestion, R2 for egress-free payload storage, and Cloudflare Tunnels with VPC connectivity to route webhooks privately to our first-party mTLS agent on customer infrastructure.
When we started building HookDeploy, the pitch was simple: webhooks hit our edge, get inspected and transformed, then travel to your infrastructure through an encrypted private connection, never touching the public internet again. That pitch only works if the edge is actually fast and actually everywhere. So the cloud provider decision wasn’t really a cost exercise. It was an architecture decision.
Here’s why Cloudflare won.
The workload is inherently edge-shaped
A webhook receiver has one job at the moment of impact: accept the request, write it somewhere durable, and get out of the way. Every millisecond in that synchronous path is a millisecond your upstream provider (Stripe, Shopify, whoever) is waiting on a response before it considers the delivery successful.
Cloudflare Workers run at the edge, close to wherever the webhook is actually coming from, with none of the cold-start tax you’d pay spinning up a traditional container or Lambda in a single region. Our ingestion Worker does the bare minimum synchronously (validate the slug, check the cache, read the body, write it to storage, respond) and pushes everything else (metadata inserts, usage counters, forwarding, subscription fanout) into the background via ctx.waitUntil. That pattern only exists because Workers make it cheap and natural to defer work without blocking the response.
R2 killed the egress tax
Webhook payloads are exactly the kind of data object storage is built for: write once, read occasionally, delete after a retention window. The catch with most cloud storage is egress pricing, which punishes you every time a customer wants to actually look at their own data.
R2 has no egress fees. For a product where “let the customer inspect and replay their captured requests” is core functionality, that’s not a minor discount, it’s the difference between a viable pricing model and one that quietly bleeds margin every time someone opens their request inspector.
KV as a genuinely fast cache layer
Every webhook that hits us needs an endpoint lookup, a plan check, and increasingly a response-config and verification-config lookup, before we can decide what to do with it. Round-tripping to Postgres for that on every request would be untenable at any real volume.
Workers KV sits right next to the Worker itself, so a cache hit costs almost nothing. We consolidated what used to be three separate config lookups into a single cached RPC result and cut our cold-path latency substantially in the process. That kind of optimization is only possible because the cache and the compute live in the same place.
Private delivery without building our own network
The core promise of HookDeploy is that once a webhook reaches us, it never touches the public internet again on its way to your infrastructure. Building that ourselves would normally mean standing up point-to-presence networking, managing our own tunneling protocol, and running it across every region we care about.
Instead, we route delivery through Cloudflare Tunnels and Cloudflare’s VPC connectivity, from our Workers and Queues straight through to our own VPS exit nodes distributed globally. From there, our first-party mTLS agent (running on the customer’s infrastructure) is what actually terminates the connection and delivers the payload. No third-party mesh networking layer, no separate VPN protocol to operate, no split-brain between “how Cloudflare routes traffic” and “how we route traffic.” One connectivity model, end to end, that we control and can reason about at every hop.
One network, not a patchwork of regions
We operate multiple regional Supabase projects for data residency reasons, but the ingestion and API layers don’t need to think about regions at all. Cloudflare’s network handles routing a request to the nearest edge location automatically. We didn’t have to build or maintain a global load balancer, and customers don’t experience latency cliffs depending on where in the world their webhook source happens to live.
The honest tradeoffs
This isn’t a “Cloudflare has no downsides” post. Workers’ CPU-time model takes getting used to if you’re coming from long-running servers. Debugging distributed background work via ctx.waitUntil means you give up some of the straightforward stack traces you’d get from a monolith. And leaning this heavily into one vendor’s edge platform is a real dependency to accept, not something to gloss over.
But for a product whose entire value proposition is “fast, private, edge-native webhook delivery,” building on a platform that’s already fast, private, and edge-native by default was the right bet.