Why We Killed WireGuard and Tailscale for Our Own mTLS Agent
Why HookDeploy replaced WireGuard and Tailscale with a first-party mTLS agent: unlimited free development agents, no per-seat networking costs passed to customers, and built-in GDPR compliance via EU-restricted exit nodes.
Every private webhook delivery product has to answer the same question: how does a request that hits our edge get to your infrastructure without touching the public internet? Early on, we built HookDeploy’s answer on two of the best tools in the space, WireGuard and Tailscale. We ripped both out and replaced them with a first-party mTLS agent.
That wasn’t a step down. It was the right call, and here’s why.
WireGuard: powerful, but not built for this
WireGuard is genuinely excellent technology. Fast, minimal attack surface, a clean protocol. But it’s a kernel-level VPN primitive, not a customer-facing product. Setting it up means generating keypairs, exchanging public keys, configuring peer entries, managing allowed IP ranges, and keeping a wg0 interface healthy on infrastructure someone else operates.
That’s a reasonable ask for a customer running a dedicated networking team. It’s an unreasonable ask for the developer who just wants their webhooks to land on their laptop or their staging server without setting up a VPN tunnel first. We were asking every customer to become a part-time network engineer just to receive a webhook privately. The complexity wasn’t a rough edge we could polish away. It was baked into what WireGuard fundamentally is.
Tailscale: the right idea, the wrong cost model
Tailscale solves the usability problem WireGuard has. It wraps WireGuard in a mesh network with a real control plane, OAuth-based enrollment, and none of the manual key exchange. We built real, working integration on it, proven end to end.
The problem was cost, and specifically, whose cost it was. Tailscale’s pricing scales with the number of devices on a tailnet. Every customer who wanted private delivery would need to either join our tailnet or run their own, and either path meant our customers absorbing a per-seat cost for infrastructure that, from their point of view, should just be a feature of the product they’re already paying us for. We’d effectively be asking customers to pay a second vendor to use a capability we were selling them.
That’s a bad trade for a customer, and a strange one for us to build our core value proposition on top of.
Our own mTLS agent: control, cost, and reach
So we built our own. A lightweight agent that runs on customer infrastructure, authenticates over mutual TLS, and terminates the connection on their end. Delivery transits from our Workers and Queues to VPS exit nodes distributed globally (seven regions and counting) via Cloudflare Tunnels and Cloudflare’s VPC connectivity, and the agent takes it from there.
Four things changed once we owned this layer end to end:
We control the security model completely. No third-party mesh network sitting between a customer’s webhook and their server, no dependency on someone else’s control plane being available or configured correctly. mTLS is a well-understood, auditable primitive, and every hop in the chain is one we designed and can reason about.
We can offer unlimited free development agents. Because we’re not paying a per-device fee to a third party, and because a development agent costs us nothing until it’s actually forwarding production traffic, we could make the pricing lever production commitments, not seats. A team of 25 developers can all run agents for free. The only thing that costs money is a standing production agent, which is also the only thing that costs us anything real in terms of an uptime and retry promise. That’s a materially better deal for customers than per-seat tunnel pricing ever could have been.
Agent parity became a real, enforceable principle, not a hope. Because it’s our code, agent-based destinations go through the exact same feature pipeline as standard HTTPS destinations: transformations, response capture, marker headers, rate limiting, all of it. Only the transport differs. That’s much harder to guarantee when you’re layering your product logic on top of somebody else’s networking tool.
We can restrict traffic to EU exit nodes, with GDPR compliance built in. Because we operate the exit node network ourselves, customers with EU data residency requirements can pin their agent traffic to EU-based nodes only. That’s not a feature we could have offered cleanly on top of a third-party mesh network, where node selection and data routing decisions belong to someone else’s infrastructure. Owning the transport layer means owning the compliance guarantees that go with it.
The honest version
WireGuard and Tailscale weren’t wrong choices when we started. They got us a working private-delivery model fast, and they proved the demand was real before we invested in building our own transport layer. But “the fastest path to a working prototype” and “the right foundation for the product at scale” aren’t always the same infrastructure. Once we understood exactly what we needed (customer-simple setup, no per-seat cost passed to customers, full control over security guarantees, and the ability to make hard residency commitments) building it ourselves was the clear answer, not a fallback.