I've been monitoring 5 VPS providers from Helsinki for 30 days — here's the actual data

Originally published on byte-guard.net.

Affiliate disclosure. This post contains affiliate links for Contabo. If you sign up through them I may earn a small commission at no cost to you. All benchmark data below comes from my own infrastructure — it was collected before any affiliate relationship existed.

Most VPS comparison posts are written by people who have never paid a bill to any of the providers they're reviewing. You can usually tell in the first paragraph: the specs are scraped from a marketing page, the "benchmarks" are six years old, and every provider turns out to be "great for beginners."

This one is different. I run the blog you're reading right now on a Hetzner CPX22 in Helsinki. I run my automation stack on a Contabo VPS in Germany. Both have been running continuously since early April 2026. Uptime Kuma has been checking the blog every 60 seconds since day one — that's over 46,000 health checks at this point. For the three providers I don't directly operate (Vultr, Linode/Akamai, and DigitalOcean), I ran latency probes from the Hetzner server to each provider's nearest European test endpoint.

The result is one post with actual numbers.

Methodology — what's real and what's probed

Directly operated (real uptime data):

• Hetzner CPX22, Helsinki — production blog host since April 7, 2026. Uptime Kuma checks blog.byte-guard.net and byte-guard.net every 60 seconds.
• Contabo Cloud VPS 10, Germany — private automation server (N8N, WireGuard) since ~April 18. No automated monitor, but zero unplanned restarts observed over 22 days.

Probed from Hetzner Helsinki (latency only, no uptime data):

• Linode/Akamai — 50-packet ICMP probe to speedtest.frankfurt.linode.com
• Vultr — 50-packet probe to fra-de-ping.vultr.com (Frankfurt) and ams-nl-ping.vultr.com (Amsterdam)
• DigitalOcean — ICMP blocked from external; HTTP probes also refused. No latency data available — I note this explicitly rather than substituting a different data source.

All latency probes were run on 2026-05-10 from the Hetzner VPS (Helsinki, Finland). Results will vary from other origins — I'm measuring specifically from Finland to European datacenters.

Uptime — the headline number

Hetzner (33 days, 46,934 checks)

Data period: 2026-04-07 to 2026-05-10. Checks every 60 seconds.

The 33-day uptime on the main blog is 99.9787% — effectively zero downtime for the monitoring period. Every observed "down" event on the tools subdomain was transient (single-check failures that resolved on the next poll), consistent with brief container restart spikes rather than genuine outages.

The cve.byte-guard.net max response of 30,502 ms is a real outlier — a cold-start latency spike on a FastAPI container that hadn't handled a request in a while. It's not a Hetzner problem; it's a Python process that was sleeping. The avg of 152 ms is the steady-state number.

The internal monitoring numbers (tools/paste/cve) look faster than the blog because Uptime Kuma checks them from within the same server — Docker network latency, not public internet.

Contabo (22 days)

I don't have automated uptime monitoring on the Contabo server since it doesn't run a public-facing service. Direct observation: zero unplanned reboots in 22 days. The server's uptime output as of May 10:

11:23:29 up 21 days, 18:10, 1 user, load average: 0.09, 0.04, 0.01

Load average of 0.09 on a 4-vCPU box running N8N, Redis, and WireGuard is exactly what you'd expect from a lightly-loaded automation server.

Vultr, Linode, DigitalOcean

I don't run servers on these providers. For uptime, I won't invent numbers — check their status pages, Linode status, and DigitalOcean status directly if historical uptime matters to your decision. All three are generally regarded as 99.9%+ providers in practice, but I'm not going to copy-paste a claim I can't verify.

Latency — probed from Helsinki

All tests run from the Hetzner CPX22 in Helsinki. Results are 50-packet ICMP probes (ping -c 50 -q). The "jitter" column is the mdev value — standard deviation of round-trip times, which matters for real-time workloads.

Tested 2026-05-10. Probe source: Hetzner Helsinki. All providers probed via publicly documented test endpoints.

Three things stand out:

1. Linode Frankfurt is marginally faster to Helsinki than Hetzner Helsinki. Not by much — 22.8 ms vs 23.6 ms — and the jitter is essentially identical (0.23 vs 0.21 ms). Both routes are stable and consistent. If you're building a latency-sensitive service and your users are in Northern/Central Europe, Linode Frankfurt is a legitimate option.

2. Vultr's jitter varies by datacenter. Frankfurt (27.1 ms avg, 1.08 ms jitter) is noticeably bumpier than Amsterdam (27.9 ms avg, 0.14 ms jitter), even though the average round-trip times are close. For most self-hosting workloads this won't matter. For anything that cares about consistency (WebRTC, real-time APIs, game servers), pick Amsterdam if Vultr is your provider.

3. Contabo has the highest jitter by a wide margin. At 2.83 ms mdev, the round-trip times to our Contabo server swing considerably more than the other providers. This matches what the self-hosting community generally observes about Contabo's shared CPU architecture — they pack more tenants per host, which introduces scheduling noise. The absolute latency (34.1 ms) is also higher than the others, partly because our Contabo server is in Germany rather than Finland, and partly because of the higher jitter floor.

DigitalOcean: their Frankfurt datacenter blocks ICMP from external hosts and doesn't run an HTTP speedtest endpoint. This isn't unusual for large providers, but it does mean I have no latency numbers for them from Helsinki. If you need to benchmark DO, you'll need to spin up an instance and test from there.

Pricing (verified May 2026)

Closest equivalent plans across all five providers — chosen for comparability, not cherry-picking:

Contabo "unlimited" = fair use policy, 200 Mbit/s port. Check their current ToS.

†Vultr's 8 GB shared-CPU plan runs $120/mo — their pricing tier jumps sharply above 4 GB. The 4 GB plan is shown as the practical entry point. Verified May 2026.

The Hetzner/Contabo pricing gap vs the US-headquartered providers is stark. Linode and DigitalOcean both land at $48/month for 8 GB — more than 5× Hetzner's €8.98. Vultr's shared tier is cheaper but the RAM ceiling is lower before the price jumps significantly. The European providers have the pricing advantage for a reason: Hetzner and Contabo own their hardware and run their own datacenters, while Vultr/DO/Linode tend to mark up leased capacity. You pay for the global footprint and polished API/dashboard experience with the US providers.

Provider summary

Hetzner — best for most self-hosters in Europe

Thirty-three days of real production data gives me something useful to say about this one: it just works. The uptime numbers speak for themselves. The dashboard is clean, provisioning takes under a minute, the console doesn't require JavaScript gymnastics, and the €8.98/month CPX22 is genuinely hard to beat on price-to-performance for European users.

The one gap: limited non-European coverage. If your users are in Asia-Pacific or you need multiple regions, Hetzner's reach (Germany, Finland, US-East, US-West, Singapore) is narrower than the US providers.

What I run on it: Ghost blog, Nginx Proxy Manager, Uptime Kuma, three FastAPI subdomains. All in Docker. No issues.

Contabo — best for secondary infrastructure on a budget

At €4.50/month for 4 vCPU and 8 GB RAM, Contabo offers a spec sheet that nothing else at this price comes close to. The tradeoffs are real: higher latency (34 ms from Helsinki vs 23 ms from Hetzner), noticeably more jitter (2.83 ms mdev), and an older CPU generation that benchmarks lower on compute-intensive tasks.

For automation workloads, VPNs, or anything that's not handling real-time user traffic, the jitter doesn't matter. My N8N instance runs fine on it. I'd buy it again for the same use case. I'd reach for Hetzner first for anything user-facing.

Affiliate link: Contabo Cloud VPS 10 — the plan I actually pay for.

Linode/Akamai — surprising latency from Finland, expensive everywhere

Linode Frankfurt is the closest provider to Helsinki that isn't Hetzner itself — 22.8 ms avg vs Hetzner's 23.6 ms, with 0.23 ms jitter. That result surprised me. The network is clean.

The problem is the price. At $48/month for 8 GB RAM (verified May 2026), you're paying 5× Hetzner for equivalent specs, and 10× Contabo. The value proposition for European self-hosters is weak unless you need Linode's specific compliance certifications or managed Kubernetes. For US-based users, they're a reasonable choice — competitive pricing in USD, good support reputation, solid API.

Vultr — global footprint, inconsistent in Europe

Vultr's Frankfurt datacenter had more jitter (1.08 ms mdev) than I'd expect from a premium provider — not terrible, but noticeably worse than Linode Frankfurt or Hetzner Helsinki over the same probe window. Amsterdam was much cleaner (0.14 ms mdev) if you're in Western Europe. Pricing is comparable to Linode: expensive for European users compared to Hetzner/Contabo.

Where Vultr makes sense: hourly billing, 30+ global regions, and a fast API for ephemeral workloads. If you're spinning up test environments programmatically and need regions outside Europe, Vultr is a solid choice.

DigitalOcean — the safe default you're probably already using

I have less to say about DO than the others because their Frankfurt endpoint actively blocked my probes. Not a red flag — just means I can't contribute latency data here. DO's reputation is strong: excellent documentation, the most polished dashboard of the five, and a massive community ecosystem. The price premium is real (~$48/month for 8 GB vs Hetzner's €8.98), but the developer experience has historically been worth it for people who value that.

If you're already on DigitalOcean and happy, staying there is fine. If you're choosing fresh and your workload fits in Europe, you're leaving significant money on the table compared to Hetzner.

The decision matrix

What's next

This post covers the 30-day mark. I'll revisit the Hetzner uptime data at 90 days and add a Contabo automated monitor between now and then.

If you want the tools that generated some of this data — SSL/header scanner, DNS propagation checker — they're free at tools.byte-guard.net. Built them for this kind of audit work.

Questions or different numbers from your own setup? I'm enim on the usual channels — always interested in seeing what the same benchmark looks like from a different origin.