The tunnel will not come up
A wrong peer public key, a listening port that is firewalled on the server side, or a server clock that drifted far enough to fail the replay window check.
Handshake clean and quick
Running WireGuard?
WireGuard is wonderful until the handshake stops completing or the tunnel comes up but nothing flows. Small, boring misconfigurations cause both: an AllowedIPs range that overlaps an existing route, an MTU that was fine on Ethernet and drops every reply on a cellular link, or a persistent keepalive that was never set on the roaming side. We work through the kernel module output and the routing table until the issue is visible and then close it.
What it is
WireGuard is a modern VPN protocol written by Jason Donenfeld, upstreamed into the Linux kernel in version 5.6 in March 2020. It uses a small set of curated cryptographic primitives, Noise IK for the handshake, ChaCha20Poly1305 for the data channel, and Curve25519 keys, with no cipher negotiation and no X.509 anywhere.
The configuration model is deliberately plain: each peer has a private key, a public key, a set of AllowedIPs and an optional endpoint. There are userspace implementations for every mainstream operating system, an Android and iOS client, and a growing set of commercial mesh products like Tailscale and Netbird that build their control plane on top of the protocol.
The honest version
No technology is all upside. This is where WireGuard earns its place and where it tends to cause trouble.
Sound familiar?
The WireGuard problems that bring people to us, and what you have once each one is fixed.
A wrong peer public key, a listening port that is firewalled on the server side, or a server clock that drifted far enough to fail the replay window check.
Handshake clean and quick
The classic MTU fence: handshake and small packets succeed, every full-size TCP packet is silently dropped on the path, and connections sit until they time out.
MTU correct for the real path
A roaming client behind NAT with no keepalive loses its NAT binding after about ninety seconds, so inbound traffic from the server stops reaching it until the client speaks first.
Keepalive set where NAT demands it
A broad AllowedIPs entry on one peer that swallows traffic that should go to a different peer or to the local network entirely.
AllowedIPs tight and correct
A systemd unit ordering issue where wg-quick runs before the network stack is ready, or a non-privileged user running the command without CAP_NET_ADMIN.
Interface comes up on every reboot
A roaming client on mobile data switching between carriers, or a NAT in front of the server mapping to different public addresses over time, which is normal but noisy if nobody expected it.
Flap handled, logs quiet
wg-quick relies on resolvconf or systemd-resolved to push the DNS line into the resolver, and distributions that ship neither leave the client with the old DNS after bringing the tunnel up.
DNS applied with the tunnel
A wg-quick down that did not run cleanly, leaving a route in the main table that refuses to be replaced on the next up.
Routes tidied before each start
What we do
Call for one broken peer, or hand us the whole VPN estate.
How it works
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
We fix the cause, not the symptom. If something is down, getting it back up comes first.
Backups, monitoring, updates and access, so the same problem can't quietly come back.
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
We work on the whole stack, so the problem can be wherever it actually is.
In practice it is almost always one of four things: the peer public key does not match what the other side thinks it should, the UDP port is not reachable through the firewall on the listening side, the system clocks are more than a few minutes apart, or the preshared key was set on one side and not the other. The kernel logs will not tell you which, so we work through them in order.
That is the classic MTU problem. The handshake and small packets get through, but every full size TCP packet is slightly too large for the path and is silently dropped. The fix is to measure the real path MTU and set the WireGuard MTU below it, often around 1280 on cellular or PPPoE.
You need PersistentKeepalive on any peer that sits behind a NAT and wants inbound traffic to keep flowing when it is idle. Without it, the NAT mapping ages out after roughly ninety seconds and the server cannot reach the client until the client speaks. For server-to-server links on fixed IPs, keepalives are not needed.
Raw WireGuard is excellent when you have a small number of peers and someone to own the key distribution. Tailscale is the sensible call once you have more than a handful of users, want single sign-on, or need ACLs and device posture without writing a control plane yourself. We help pick between the two rather than default to either.
Add the new key as an additional peer entry on each side, let both sides accept it, cut clients over, then remove the old key. On a small deployment you can do it by hand; once there are more than twenty peers, it is worth generating config from a template and pushing it through Ansible or a similar tool.
Pricing an engagement starts with a free call. Describe what the tunnel is doing and we come back with a written estimate before any hours are booked.
Free estimate
Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.
Your message is with a real person, and we'll get back to you soon.
Rather talk now? Call us: