Kamatera vs Hetzner 2026: The Terraform Test That Ended the Debate

Last quarter I migrated a client’s staging environment from Kamatera to Hetzner. The infrastructure consisted of 8 servers: 3 application nodes, 2 database replicas, a Redis cache, a load balancer, and a monitoring instance. On Kamatera, I had provisioned each server through the web UI, carefully dragging sliders to custom-size every box. The Redis server was a clean 1 vCPU / 4 GB build. The app nodes were 2 vCPU / 3 GB each. Every configuration was precisely tuned. The monthly bill was $186.

On Hetzner, I wrote a Terraform configuration in 45 minutes. One terraform apply later, all 8 servers existed. The Redis "waste" — getting a CX22 with 4 GB and 2 vCPUs instead of the theoretically optimal 1 vCPU / 4 GB — cost $4.59/mo. The app nodes, "over-provisioned" at 4 GB instead of 3 GB, cost $4.59 each. The total monthly bill: $62. Same architecture. Same performance (actually slightly better disk I/O). Less than a third of the cost. And the next time we need to spin up an identical environment — for a new client, for a load test, for disaster recovery — it takes 90 seconds instead of an hour of clicking through a web UI.

That migration taught me something I should have known earlier: Kamatera’s custom sizing sounds like precision engineering. In practice, against Hetzner’s bundled pricing, the "waste" from slightly-too-large fixed tiers costs less than the "savings" from precision sizing. And the Terraform infrastructure-as-code workflow that Hetzner enables and Kamatera does not — that is the operational advantage that pricing spreadsheets cannot capture.

The Terraform Story: Why Automation Changes the Comparison

Most VPS comparison articles treat infrastructure automation as a line item in a feature table. A checkmark for "API: Yes" and a note about Terraform support, then move on. That framing misses the operational reality of how modern teams deploy and manage servers.

Here is the Hetzner Terraform configuration that replaced my hour of Kamatera web UI clicking:

resource "hcloud_server" "app" {
  count       = 3
  name        = "app-${count.index + 1}"
  server_type = "cx22"
  image       = "ubuntu-22.04"
  location    = "ash"      # Ashburn, VA
  ssh_keys    = [hcloud_ssh_key.deploy.id]
}

resource "hcloud_server" "db" {
  count       = 2
  name        = "db-${count.index + 1}"
  server_type = "cx32"
  image       = "ubuntu-22.04"
  location    = "ash"
  ssh_keys    = [hcloud_ssh_key.deploy.id]
}

resource "hcloud_server" "redis" {
  name        = "redis-1"
  server_type = "cx22"
  image       = "ubuntu-22.04"
  location    = "ash"
  ssh_keys    = [hcloud_ssh_key.deploy.id]
}

That is the entire infrastructure definition for 6 of the 8 servers. Version-controlled. Reproducible. Destroyable with terraform destroy and recreatable in 90 seconds. The Hetzner Terraform provider covers servers, volumes, firewalls, load balancers, floating IPs, SSH keys, networks, and placement groups. It is official, HashiCorp-verified, and maintained by Hetzner’s own engineers.

On Kamatera, the same task required: open browser, log in, click "Create Server," drag CPU slider to 2, drag RAM slider to 3 GB, type storage amount, select datacenter, select OS, click create. Wait. Repeat 7 more times with different configurations. Copy IP addresses into a spreadsheet. There is no Terraform provider. The API exists but requires custom scripting for anything beyond basic CRUD operations.

For a single server, the workflow difference is negligible. For a fleet of 8, it is the difference between 90 seconds and an hour. For a team managing multiple environments (staging, production, DR) across multiple clients, it is the difference between infrastructure that can be audited through git history and infrastructure that lives in someone’s browser bookmarks.

Head-to-Head Comparison Table

The pricing column tells one story. The automation and geography columns tell a different one. Read the full table before forming a conclusion.

Pricing: Why Bundled Beats Custom (Almost Always)

The pricing story between these two providers is not a close competition. It is a structural mismatch in business models that produces dramatically different price points for identical specifications.

Hetzner owns its datacenters. Hetzner builds its own server hardware. Hetzner sells fixed-tier bundles with aggressive volume pricing that treats the entire package as a unit cost. Kamatera leases datacenter space, prices each resource component individually, and offers the flexibility to combine them in any ratio. The result: Hetzner’s bundles are radically cheaper for any configuration that matches (or approximates) a standard tier.

Tier-by-Tier Price Comparison

The pattern is clear and consistent: Hetzner is 62-69% cheaper at every standard tier, and the percentage discount increases at larger configurations. A fleet of 5 servers at the 4 vCPU tier costs $120/mo on Kamatera versus $42.45/mo on Hetzner. The annual delta: $930. For a startup optimizing burn rate, that is three months of additional runway at the Hetzner price point.

The Bandwidth Multiplier

Hetzner bundles 20 TB of outbound bandwidth into every plan. Kamatera includes 5 TB on basic configurations and meters additional usage. For workloads pushing 10 TB monthly — a busy API backend, a media CDN origin, a file distribution server — Hetzner’s bandwidth is a zero-cost variable. On Kamatera, the same 10 TB costs additional money on top of the compute bill.

This bandwidth gap compounds the pricing advantage. At the 4 vCPU tier with 10 TB egress, the effective cost comparison is not $24 vs $8.49. It is $24 + bandwidth overage vs $8.49 + nothing. The total cost of ownership analysis must include bandwidth, and doing so makes Hetzner’s advantage even more pronounced. Our price comparison table shows how this scales across all providers.

Why the Gap Is So Large

Three structural factors explain the 2-3x price difference:

1. Vertical integration. Hetzner designs, builds, and operates its own server hardware in owned datacenters. Every intermediary margin that other providers pay to third parties, Hetzner captures internally.
2. Bundle optimization. When you sell a fixed 2C/4G/40G package, you can optimize the hardware bill as a unit. When you sell individual resources on sliders, each component carries its own margin. The sum of individual component margins exceeds the margin on an optimized bundle.
3. European operational costs. Hetzner is headquartered in Germany and operates with European cost structures for non-US infrastructure. Even their US datacenters benefit from the organizational efficiency of a company that has optimized hosting economics for 25+ years.

The Exceptions Where Custom Sizing Wins

I promised a fair comparison, so here are the scenarios where Kamatera’s custom configurator produces a genuinely better price. They are narrower than you might expect.

Exception 1: Extreme RAM-to-CPU Ratios

A Redis cache server needs 16 GB RAM but only 1 CPU core. On Kamatera, build a 1 vCPU / 16 GB custom server. On Hetzner, the cheapest plan with 16 GB RAM is the CX42 (8 vCPU / 16 GB) at $15.59/mo. You are paying for 7 CPU cores you will never use. But here is the catch: $15.59/mo for those 7 "wasted" cores might still be less than Kamatera charges for the custom 1C/16G build. Kamatera’s per-component pricing for 16 GB of RAM alone approaches or exceeds the Hetzner bundle price. The custom model saves money only when the ratio is extreme enough that even the cheapest Hetzner bundle with the required RAM is more expensive than the Kamatera custom build.

Exception 2: Sub-Minimum Configurations

Kamatera’s smallest server is 1 vCPU / 1 GB at $4/mo. Hetzner’s smallest is the CX22 at 2 vCPU / 4 GB for $4.59/mo. If you genuinely need the absolute minimum for a lightweight task — a DNS server, a monitoring ping target, a VPN endpoint — Kamatera saves $0.59/mo ($7.08/year). Of course, Hetzner gives you 3 GB more RAM and an extra CPU core for that $0.59. Whether the "savings" justify getting dramatically less hardware is a question worth asking honestly.

Exception 3: Large Heterogeneous Fleets

An agency managing 30 client servers where each client has a unique resource profile (Client A: 3C/6G, Client B: 1C/4G/100G, Client C: 4C/2G) would accumulate measurable waste rounding each configuration to Hetzner’s nearest tier. At 30 servers, even $2-3/mo of waste per server adds up to $720-1,080/year. Kamatera’s precision sizing eliminates that waste. But the comparison must also include the engineering cost of managing 30 individually configured servers through a web UI versus a Terraform configuration that deploys all 30 in under 3 minutes.

The table reveals the uncomfortable truth for the custom-sizing argument: even in the supposedly favorable scenarios, Hetzner’s bundled pricing wins more often than not. The "waste" in a slightly oversized Hetzner tier is cheaper than the "precision" of a Kamatera custom build. Precision has a price, and at Hetzner’s rates, imprecision is cheaper.

Performance Benchmarks

We tested 2 vCPU / 4 GB configurations from Kamatera (New York) and Hetzner (Ashburn) — their closest US East facilities. Three runs per test, median values reported. Full data available in our benchmark database.

CPU Performance: Hetzner 4,300 vs Kamatera 4,250

The 1.2% gap is within measurement noise between consecutive runs on the same server. Both providers use modern server-grade processors. In practical terms, a Go compilation finishing 0.3 seconds faster on Hetzner is not a decision factor. Call it parity. For workloads where CPU matters (CI/CD, video encoding, scientific computing), both providers deliver equivalent performance per core.

Disk I/O: Hetzner 52,000 vs Kamatera 45,000 IOPS

The 15.6% gap is the benchmark delta that matters most. Both use local NVMe storage, but Hetzner’s storage controller optimization delivers measurably higher throughput. In real-world terms:

• WordPress page generation: A content page with 12 database queries loads ~12% faster on Hetzner under concurrent traffic
• MySQL complex queries: Joins across 3+ tables with random access patterns complete notably faster when IOPS is the bottleneck
• Elasticsearch indexing: Bulk document ingestion processes ~15% more documents per second on Hetzner
• Log aggregation: Write-intensive logging pipelines benefit from Hetzner’s higher write IOPS consistently

For database-driven applications where disk is the bottleneck, Hetzner delivers better performance at a fraction of the price. The performance advantage compounds with the price advantage. You get faster storage for less money.

Network: Hetzner 960 Mbps vs Kamatera 920 Mbps

Both approach the 1 Gbps port cap. The 40 Mbps delta is invisible in practice. As with every provider comparison, the network metric that shows up on your bill is bandwidth allowance, not speed. Hetzner’s 20 TB versus Kamatera’s 5 TB is the number that determines your actual network costs.

The Geography Factor: Where Physics Overrides Pricing

This section exists because there is one scenario where Hetzner’s pricing advantage becomes irrelevant. Not unimportant — irrelevant. And it is determined by physics, not infrastructure.

Kamatera: 3 US Datacenters

• New York, NY (US East) — Financial district, dense peering
• Dallas, TX (US South Central) — Central US hub, serves Texas/Oklahoma/Louisiana/Arkansas
• Santa Clara, CA (US West) — Silicon Valley, strong interconnects

Hetzner: 2 US Datacenters

• Ashburn, VA (US East) — Virginia data corridor, one of the densest peering exchanges in the world
• Hillsboro, OR (US Pacific Northwest) — Oregon tech corridor

The Dallas Gap

Kamatera’s Dallas datacenter serves 7.6 million people in the DFW metroplex alone, plus the broader South Central US, with sub-10ms latency. A user in Houston hitting Kamatera’s Dallas server: ~8ms. The same user hitting Hetzner’s Ashburn server: ~32ms. That 24ms delta is photons traveling through 2,400 km of fiber optic cable. No CDN, no caching layer, no edge function can eliminate it on the origin connection.

The latency comparison reveals a nuanced picture. Hetzner actually wins the East Coast (Ashburn is closer to DC, Atlanta, and Miami than New York) and the Pacific Northwest (Hillsboro beats Santa Clara for Seattle). Kamatera wins Central US decisively and is competitive on the West Coast. For applications where the majority of users are in Texas, Oklahoma, or the broader South Central region, Kamatera’s Dallas presence creates a latency advantage that no amount of Hetzner price cutting can neutralize.

For applications serving a geographically diverse US audience, neither provider is optimal. Vultr’s 9 US locations provide the most complete coverage. Our US datacenter selection guide covers the full decision framework.

But for the specific subset of workloads where Central US latency matters — game servers serving the Texas gaming community, trading applications connecting to Dallas exchanges, real-time collaboration tools for South Central enterprises — Kamatera’s Dallas datacenter is the only option between these two providers. Geography overrides pricing when physics is the constraint.

Infrastructure Automation Compared

For teams that deploy manually through web UIs, this section is academic. For teams that treat infrastructure as code, it is the most important section in this article.

Hetzner: First-Class Automation Citizen

• Terraform provider — Official, HashiCorp-verified, maintained by Hetzner engineers. Covers servers, volumes, firewalls, load balancers, floating IPs, SSH keys, private networks, placement groups, and certificates.
• hcloud CLI — Command-line tool for direct server management. hcloud server create --type cx22 --image ubuntu-22.04 --location ash provisions a server in one command.
• API — RESTful, well-documented, rate-limited at reasonable thresholds. Full coverage of all platform resources.
• Ansible modules — Community-maintained Ansible collection for Hetzner Cloud resources.
• Pulumi support — Via the Terraform bridge, Pulumi can manage Hetzner infrastructure in Python, TypeScript, Go, or C#.

Kamatera: Manual-First with API Fallback

• Terraform provider — Does not exist. No official provider, no community provider with meaningful adoption.
• CLI — Does not exist as a standalone tool.
• API — Exists, functional for basic CRUD operations. Documentation is adequate but not full. The API works for scripting but requires custom code for anything resembling infrastructure automation.
• Web UI — Well-designed, with the excellent custom configurator sliders. The primary management interface for most Kamatera users.

What This Means in Practice

For a solo developer managing 1-3 servers, the automation gap is irrelevant. You click through the UI, configure your server, and move on. The custom sliders are actually a better experience than Hetzner’s dropdown selection for one-off provisioning.

For a team managing 10+ servers across multiple environments, the gap is a chasm. Consider the operational workflows:

The operational cost of managing Kamatera infrastructure at scale is measured in human hours. The operational cost of managing Hetzner infrastructure is measured in seconds of terraform apply. This gap is invisible in a feature comparison table but determines the real total cost of ownership for any team beyond the solo-developer stage. If you want to go deeper on containerized deployments and automation workflows, our Docker guide covers the full pipeline.

Feature Comparison

Free Trial

Kamatera offers $100 in credit for 30 days. Hetzner offers nothing — you pay from day one. At $4.59/mo for the entry tier, Hetzner is a low-risk bet, but it is not zero-risk. The rational evaluation sequence: start with Kamatera’s free trial to benchmark your workload, measure actual resource usage, then calculate whether Hetzner’s nearest tier costs less. Data-driven provider selection instead of guesswork.

Support Channels

Kamatera provides phone support, live chat, and ticket-based support. In our testing, all three channels connected to a competent human within an hour. I called about a networking issue on a Friday evening and reached an engineer who understood subnet masks without me explaining the concept. That responsive human support has real value during production incidents.

Hetzner provides ticket-only support with response times ranging from 3 hours to a full business day. The technical quality of responses tends to be high — detailed, accurate, no script-reading — but they arrive on Hetzner’s schedule. There is no phone number to call when production is down at 2 AM. For organizations where "we can call the vendor" is a procurement requirement, Kamatera satisfies it and Hetzner does not.

Windows Server

Kamatera supports Windows Server 2019, Windows Server 2022, and FreeBSD alongside every major Linux distribution. Hetzner is Linux-only. For .NET Framework applications, IIS hosting, SQL Server instances, or RDP access, this is a binary filter that ends the comparison. Windows VPS workloads go to Kamatera, period.

Block Storage and Volumes

Both providers offer attachable block storage volumes. Hetzner’s volumes are priced at approximately $0.052/GB/month. Kamatera prices block storage as part of the custom configuration. For workloads requiring large amounts of persistent storage beyond the root disk — log aggregation, media archives, database dumps — both providers handle the use case, but Hetzner’s pricing is more transparent and more competitive.

Load Balancers

Both offer managed load balancers. Hetzner charges $5.83/mo for a load balancer that handles up to 25 targets. Kamatera’s load balancer pricing varies based on configuration. For multi-server architectures behind a load balancer, both providers are adequate, though Hetzner’s Terraform-managed load balancer configuration is significantly easier to maintain.

Who Should Pick Which

The DevOps team managing infrastructure as code. Hetzner, full stop. The official Terraform provider, hcloud CLI, and well-documented API create a first-class automation experience. Provisioning, scaling, and destroying infrastructure through version-controlled code is not optional for modern engineering teams — it is baseline. Kamatera’s lack of Terraform support makes it incompatible with this workflow.

The startup optimizing burn rate. Hetzner’s 2-3x cheaper pricing directly extends runway. A 5-server production stack costing $42/mo instead of $120/mo saves $936/year. For a seed-stage startup, that is meaningful capital preserved for product development instead of infrastructure.

The application serving Central US users with latency requirements. Kamatera’s Dallas datacenter is the only option. A real-time collaboration tool, game server, or trading application serving Texas users at 3ms instead of 32ms — that delta is the entire user experience for latency-sensitive workloads.

The first-time evaluator without production data. Start with Kamatera’s $100/30-day free trial. Deploy your application, measure actual CPU, RAM, and I/O usage under real traffic. Then calculate the Hetzner tier that matches or exceeds your measured requirements. Data-driven provider selection instead of guessing from spec sheets.

The Windows/.NET shop. Kamatera. Hetzner does not support Windows. This is not a nuanced recommendation. It is a binary filter. If Windows is a hard requirement, the comparison has exactly one outcome.

The bandwidth-heavy media server. Hetzner’s 20 TB bundled bandwidth makes egress a non-issue. A podcast CDN origin, video distribution point, or large file server pushing 10+ TB monthly would face significant bandwidth charges on Kamatera. On Hetzner, that egress is included.

The team that values human support over documentation. Kamatera’s phone and live chat support provide a safety net that Hetzner’s ticket system does not. For organizations without deep in-house technical expertise, being able to call a human during a production incident has value that scales inversely with team capability. The less experienced your team, the more valuable the phone line.

Benchmark Visualization

Hetzner wins all three metrics. The CPU advantage is noise. The disk I/O gap is the one that affects real applications.

Frequently Asked Questions

Is Hetzner cheaper than Kamatera?

Yes, dramatically. Hetzner is 2-3x cheaper at every standard configuration. The CX22 (2 vCPU / 4 GB / 40 GB) costs $4.59/mo while the equivalent Kamatera custom build costs approximately $12/mo. At 8 vCPU / 16 GB, Hetzner charges $15.59/mo versus Kamatera’s ~$48/mo. Hetzner also bundles 20 TB bandwidth into every plan, while Kamatera includes 5 TB. The gap increases at larger tiers.

Does Hetzner have US datacenters?

Yes. Hetzner operates 2 US datacenters: Ashburn, VA (East Coast) and Hillsboro, OR (Pacific Northwest). Kamatera has 3 US locations: New York, Dallas, and Santa Clara. The critical difference is Kamatera’s Dallas datacenter — it serves the South Central US with sub-10ms latency, while Hetzner’s nearest facility is 32ms away in Ashburn. For Central US latency requirements, this geographic gap overrides pricing.

Does Hetzner have an official Terraform provider?

Yes. The Hetzner Terraform provider is official, HashiCorp-verified, and maintained by Hetzner’s engineering team. It supports servers, volumes, firewalls, load balancers, floating IPs, SSH keys, networks, and placement groups. Kamatera has no Terraform provider — official or community. For teams managing infrastructure as code, this is often the single most important decision factor.

Does Kamatera offer a free trial?

Yes. Kamatera offers $100 in free credit for 30 days — enough to deploy multiple configurations and benchmark your workload. Hetzner does not offer any free trial or credit. The rational evaluation approach: use Kamatera’s trial to measure your application’s actual resource requirements, then calculate whether Hetzner’s nearest fixed tier costs less than the Kamatera custom build tuned to your measurements.

Why is Hetzner so much cheaper than Kamatera?

Three structural factors: vertical integration (Hetzner owns datacenters and builds hardware, eliminating third-party margins), bundled pricing optimization (a fixed 2C/4G/40G package is cheaper to produce than individual resources on sliders), and 25+ years of hosting economics optimization as a German company. Kamatera prices each resource with its own margin; Hetzner optimizes the entire package as a unit cost.

When does Kamatera’s custom configurator save money over Hetzner?

Rarely. The custom model saves money only when the required resource ratio diverges dramatically from Hetzner’s fixed tiers — like extreme RAM-to-CPU ratios above 8:1. Even then, Hetzner’s next-tier-up bundle is often cheaper than Kamatera’s custom build because the "wasted" resources in a slightly oversized Hetzner tier cost less than the precision premium on Kamatera. The custom advantage is real but narrow.

Which has better benchmarks — Kamatera or Hetzner?

Hetzner wins all three primary metrics. CPU: 4,300 vs 4,250 (1.2% — effectively noise). Disk I/O: 52,000 vs 45,000 read IOPS (15.6% — meaningful for database workloads). Network: 960 vs 920 Mbps (4.3% — irrelevant in practice). The disk I/O gap is the only benchmark that affects real application performance. Better performance at 2-3x lower price makes Hetzner’s value proposition exceptionally strong.

Can I run Windows VPS on Hetzner?

No. Hetzner only supports Linux distributions. For Windows Server (.NET Framework, IIS, SQL Server, RDP), Kamatera is the only option between these two providers. Kamatera supports Windows Server 2019 and 2022 alongside Linux and FreeBSD. This is a hard requirement that immediately resolves the comparison for any Windows workload.

How much bandwidth does Hetzner include versus Kamatera?

Hetzner bundles 20 TB of bandwidth into every plan at no additional cost. Kamatera includes 5 TB on basic configurations and meters additional usage. For bandwidth-heavy workloads — API backends, media CDN origins, file distribution servers pushing 10+ TB monthly — Hetzner’s bundled bandwidth makes egress a zero-cost variable. This bandwidth gap compounds the compute pricing advantage significantly.

Final Verdict

The Terraform migration I described at the start of this article ended with a 67% cost reduction and an infrastructure codebase that fits in a single Git repository. The client’s staging environment, previously a collection of manually provisioned Kamatera servers that required an hour to recreate, became a terraform apply away from full reproduction. The "waste" from Hetzner’s slightly oversized tiers — an extra vCPU here, an unused GB of RAM there — cost less than one month of the savings from switching.

That outcome is representative of the general case. For the vast majority of workloads, Hetzner wins on every axis that can be measured with numbers: 2-3x cheaper, 15% faster disk I/O, 20 TB bundled bandwidth, official Terraform automation. The pricing gap is not marginal — it is structural. A team spending $120/mo on Kamatera for 5 standard-configuration servers would spend $42/mo on Hetzner for equal or better performance. The $936/year saved buys a lot of things that matter more than custom slider precision.

Choose Hetzner for: standard configurations at any tier, Terraform-managed infrastructure, bandwidth-heavy workloads, startups optimizing burn rate, database-driven applications (15% I/O advantage), and any team that values automation over manual flexibility. Hetzner is the rational default.

Choose Kamatera for: applications that must serve Central US users from Dallas, Windows Server requirements, first-time evaluations using the $100 free trial, teams that need phone support as a procurement requirement, and the narrow set of workloads with extreme resource ratios (RAM-to-CPU above 8:1) across a large fleet where precision sizing generates meaningful savings.

The decision framework is a flowchart with three nodes. First: does your application need Dallas? If yes, Kamatera. Second: does your workload need Windows? If yes, Kamatera. Third: for everything else, Hetzner delivers better performance at dramatically lower cost with infrastructure automation that transforms how you manage servers. The third branch covers the vast majority of real-world workloads.