TL;DR: Hetzner is 3–10x cheaper than AWS for simple apps with moderate traffic. If you don’t need AWS’s managed stack, global edge, or enterprise checkboxes, default to Hetzner, front it with Cloudflare, and keep your stack boring. If you do need AWS, pay for it intentionally. Numbers, examples, and a no-bullshit checklist below.

Introduction

Cloud bills are where great solo projects go to die. In 2025, performance and reliability are a given. What kills you is waste: paying $150/month for “managed magic” when a €15 VM does the job. This guide is for solopreneurs, freelancers, and small teams who want control, predictability, and runway. We’ll compare Hetzner vs AWS pricing in real terms, explain egress (the silent budget killer), show you where managed databases make sense, and give you a dead-simple decision framework. BareStack builds anti-bloat tools (like BareCRM). Our philosophy is simple: minimalism, performance, and control. This guide applies that same lens to your cloud bill—so you can run your SaaS on Hetzner without drama, or choose AWS only when it truly pays for itself.

Why this matters for solo builders

Cloud bills kill runway: the difference between €20 vs $200/month is real

If you’re a solo founder, “just $100 more” is not just $100 more. It’s another client you have to land, another week before break-even, another feature you can’t ship because you’re chasing infrastructure. A typical solo stack—one app, one worker, one small Postgres, backups, and some object storage—can run for €20–€40/month on Hetzner. The same on AWS often creeps into $100–$200+ after you include EBS volumes, NAT, CloudWatch, and data transfer. That delta compounds across months and products. You don’t get extra credit for using AWS if you don’t need it. Your customers care about speed and reliability, not whether you paid a convenience tax to Big Cloud.

The real question isn’t “Can I afford AWS?” but “What would I build with the €100/month I save?” If the answer is “Anything useful,” don’t light your runway on fire.

AWS is powerful but complex; Hetzner is simple and cheap

AWS is a Swiss Army chainsaw: powerful, flexible, and very capable of cutting off your leg. The platform shines when you need managed everything: RDS, Lambda, Kinesis, CloudFront, multi-region replication, enterprise IAM, and audit trails. If your app needs those today, AWS can be worth it. Hetzner is the opposite. It’s boring by design. Fast VMs, generous traffic, straightforward pricing, and fewer “gotchas.” It’s great for deploying apps without ten layers of managed services. If you prefer simple infrastructure you can reason about—the stuff you can rebuild in an afternoon—Hetzner is a gift.

Your time is money: manage less, ship more (without bloat)

Self-hosting doesn’t mean spending your weekends SSH’d into servers. A modern “semi-managed” workflow—Dockerized apps, an orchestrator like Coolify or CapRover, automated backups, and Cloudflare in front—gets you 80–90% of the convenience of a fully managed stack without blowing your budget. If your ops work is a predictable 1–2 hours/month, the savings dominate. That’s the sweet spot for solos: enough control to avoid lock-in, enough automation to stay sane.

Definitions that actually help

Solopreneur workload: 1–3 apps, 1 small DB, < 1 TB egress/month

This guide is tuned for “solo workload” reality:

1–3 apps or services (e.g., web, API, background worker)
1 small relational DB (Postgres/MySQL)
Block storage 50–200 GB for volumes and snapshots
Object storage 100–500 GB for uploads and backups
Egress < 1 TB/month (with a CDN caching most static assets)
Uptime expectations: “don’t wake me at 2 a.m.” not “five nines with multi-region failover”

If you’re streaming video, crunching petabytes, or doing real-time cross-region analytics, you’re outside this scope—and AWS likely makes sense.

Egress: the line item that silently nukes your budget

Data transfer out of your cloud to the public internet (“egress”) is where AWS prints money. On AWS, the first 10 TB/month tier is ~$0.09/GB, so 1 TB is ~$90. That can exceed your entire Hetzner bill. Hetzner includes generous traffic with each VM (often tens of TB) and charges a low per-TB rate after that. Put a CDN (Cloudflare) in front, cache aggressively, and you’ll keep origin egress low on any provider. But if your app will send lots of bytes to end users, the difference between “included” and “$90/TB” is the difference between profit and pain.

Managed vs self-hosted: convenience tax vs control and savings

Managed services like AWS RDS, ElastiCache, and S3 are wonderful—until the bill arrives. You’re paying to outsource updates, backups, monitoring, failover, and part of your mental load. That’s valid. But it’s a tax. Self-hosting Postgres on a Hetzner VM with point-in-time backups, monitoring, and a standby is totally viable for solo apps. Tools like Coolify and Ansible make it easy. The trade-off is real: you’ll spend some time on ops. If that time is reasonable and predictable, the savings are worth it.

Hetzner vs AWS: the cost and control comparison

Compute: comparable instances and real monthly spend

For typical app servers, Hetzner Cloud VMs are insanely cost-effective. A 2 vCPU / 4 GB instance is often ~€5–8/month. The closest AWS equivalent on x86 is a t3.medium (2 vCPU, 4 GB) at roughly $30/month on-demand compute plus $8–$10 for a modest EBS volume. You can shave compute with ARM (t4g.medium) if you’re comfortable; still, once you add EBS and transfer, AWS rarely beats Hetzner for steady workloads. Hetzner’s pricing is simple: a flat monthly number that includes a volume and generous traffic. AWS pricing is a menu: instance hours, EBS, IOPS, snapshots, data transfer, and monitoring. Those line items add up.

Storage & databases: block, object, and managed DB trade-offs

Block storage: Hetzner volumes are cheaper and simpler (~€5–6/month for 100 GB) with predictable performance for small apps. AWS gp3 is ~$8–$10 for 100 GB, plus detailed IOPS/throughput knobs. That fine-grained control is useful once you’re big; for solo systems, it’s bloat you don’t need. Object storage: AWS S3 is the gold standard, and it’s priced reasonably for storage itself. But remember: downloads from S3 count as egress. Hetzner’s S3-compatible object storage tends to be low € per GB with lower or included egress when served within Hetzner or via a CDN. For managed Postgres, AWS RDS starts around ~$45–$80/month for small instances before storage and backups. On Hetzner, you can self-host Postgres for ~€5–10/month on a small VM with automated backups, or use Hetzner’s managed DBs in the low double-digits. You decide whether that time saved is worth the extra spend.

Network: egress, NAT, and the hidden AWS gotchas

Network is where AWS sneaks past your mental model. Egress to the internet (~$90/TB). Inter-AZ transfer costs when you spread instances (non-zero per GB). NAT Gateway charges a fixed monthly fee plus per-GB data processing, which often shocks folks running private subnets. CloudWatch logs and metrics pricing is reasonable in isolation but high at scale. Hetzner’s network model is simple: generous “free” traffic per VM (often 20 TB) and a very low per-TB rate after. If you’re a solo builder, the odds you hit Hetzner’s paid egress are slim—especially with Cloudflare in front.

Aspect	Hetzner (typical)	AWS (closest equivalent)	Solo impact
Compute (2 vCPU / 4 GB)	~€5–8/mo (Cloud VM)	~$20–25/mo (t3.small + EBS)	Hetzner 3–5x cheaper for app servers
Compute (4 vCPU / 8 GB)	~€12–16/mo	~$40–55/mo	Same app, AWS costs 3–4x
Block storage 100 GB	~€5–6/mo	~$8–$10/mo (gp3)	Hetzner cheaper, fewer knobs
Object storage 250 GB	Low € (S3-compatible), low egress	~$5–$6 storage + egress fees	Storage cost similar; egress flips the bill
Managed Postgres (small)	Self-manage ~€5–10; Managed = low double-digits	~$45–$80+/mo (RDS small)	AWS managed DB is convenient but pricey
Egress 1 TB/mo	Often included up to high TB; then ~€1/TB	~$90/TB (first 10 TB tier)	This alone can 10x your bill on AWS

Notes: On-demand prices, vary by region. Hetzner includes generous traffic per VM; AWS charges for most egress. Always check current pricing before deploying.

Deep dive: total cost of ownership (TCO) you actually feel

Your time as SRE: updates, patches, backups (tools like Coolify help a ton)

Self-hosting isn’t free; it’s just cheaper. Budget 1–2 hours/month to:

Apply OS and DB updates
Rotate and test backups (DB dumps and VM snapshots)
Review logs and metrics
Exercise basic disaster recovery (restore to a fresh VM quarterly)

Tools matter:

Coolify/CapRover/Portainer for app deploys and SSL
Simple Ansible roles or scripts for Postgres backups and retention
Healthchecks.io or a cron watcher for “did backup run?”
Uptime Kuma or a cheap external monitor

If your time is €50/hour, that’s €50–€100/month of labor. If Hetzner saves you €100–€200/month over AWS, you’re still ahead—and you own the knowledge.

Hidden AWS costs: NAT gateways, inter-AZ transfer, IOPS, CloudWatch

AWS bills like to play peekaboo:

NAT Gateway: a monthly fee plus per-GB costs. If you run instances in private subnets that pull images or updates through NAT, it adds up faster than expected.
Inter-AZ data transfer: spreading across availability zones improves resilience but quietly adds per-GB line items.
EBS IOPS and throughput: gp3 is cost-effective, but tuning performance or enabling higher baseline is another knob—and fee.
CloudWatch: logs, metrics, and alarms are reasonably priced per unit, but storing chatty logs for months across many services can be surprisingly expensive.

None of these are “bad” charges; they’re fair for what AWS provides. But if you don’t need this complexity, these are taxes on your attention and budget.

Exit costs and lock-in: plain VMs vs proprietary services

Lock-in isn’t a philosophical debate when you’re small—it’s practical. If you build your app around AWS-only services (DynamoDB streams into Kinesis into Lambda into Athena into Glue), moving gets brutal. If you run plain VMs, Docker containers, and Postgres, migrating between Hetzner and AWS is a day’s work: provision, restore, switch DNS. Even within AWS, avoiding heavy proprietary coupling makes you more resilient to price shocks or vendor outages. You don’t have to be a purist; just be intentional. Use managed where it saves outsized time, and keep the rest portable.

Control is a feature. If you can rebuild your stack in a weekend, your provider can’t hold you hostage.

Deep dive: performance, regions, and compliance

Regions & latency: Hetzner (EU + US growth) vs AWS (global)

Hetzner dominates in Europe with fast, affordable regions and now offers US regions too. Latency across EU is excellent; from EU to US East is serviceable for many apps. AWS, of course, is global: dozens of regions, edge locations via CloudFront, and a mature backbone. If your customers are everywhere and latency-sensitive, AWS plus CloudFront is a killer combo. If you’re EU-first or US/EU only, Hetzner’s footprint is more than enough—and pairing with Cloudflare covers a lot of edge cases (pun intended).

SLAs & support: what you get at low spend levels

At small spend, you’re in the “community and docs” tier on both providers. Hetzner support is lean but responsive; AWS support at the basic tier is mostly forums and knowledge base. For most solo workloads, this is fine. You should be designing for graceful failure anyway:

Redundant app instances when traffic justifies it
Automated failover or fast restore for DBs
Snapshots and offsite backups
A CDN to handle bursts and absorb DDoS

If your business requires premium SLAs and phone support, factor that cost explicitly. Otherwise, keep architecture simple enough that you can self-recover.

Compliance & data sovereignty: EU data, SOC/ISO, and client requirements

Compliance is the grown-up reason to pick AWS. AWS checks nearly every enterprise box: SOC 1/2/3, ISO 27001, PCI, HIPAA, FedRAMP, etc., with region-level policies and per-service guarantees. Hetzner also publishes strong compliance and security practices and is attractive for EU data sovereignty. Many EU clients prefer or require EU hosting—Hetzner is a great fit there. The key is reading your clients’ contracts and RFPs. If they mandate specific certifications or US-based data residency, AWS may be unavoidable. Otherwise, Hetzner plus good operational hygiene gets you most of the way with far less spend.

What you gain/lose choosing each provider

Pick Hetzner when: simple stack, cost-sensitive, comfortable self-hosting

Choose Hetzner if:

Your stack is straightforward (web/API, worker, Postgres, object storage)
Monthly egress is modest (especially < 1 TB)
You want predictable bills and fewer line items
You value control and portability
You’re fine with light ops using Docker, Coolify, and automated backups

What you gain: 60–90% lower bills, simpler architecture, less lock-in. What you lose: deep managed services catalog, global footprint, and enterprise checkboxes. For 80% of solo stacks, the trade is a no-brainer.

Pick AWS when: need managed services, global edge, strict enterprise asks

Choose AWS if:

You rely on managed services like RDS, Lambda, Kinesis, CloudFront, OpenSearch, MSK, etc.
You need global edge presence, multi-region failover, or complex VPC/IAM setups
Your clients require specific compliance standards and detailed audit trails
Your team can amortize platform complexity across multiple apps or clients

What you gain: speed to market with managed services, global coverage, compliance posture. What you lose: cash and simplicity. Make sure you actually use what you’re paying for.

Middle ground: Hetzner compute + Cloudflare + managed DB where needed

You’re allowed to mix. A pragmatic pattern:

Compute and caches on Hetzner
Cloudflare for CDN, WAF, DDoS protection, and origin shielding
Managed DB where it hurts (AWS RDS or a third-party like Aiven/Neon/Supabase), or a well-run self-hosted DB with PITR
S3-compatible object storage (Hetzner) fronted by Cloudflare R2 or CDN to cut egress

This hybrid approach keeps costs sane while outsourcing only the pieces that truly tax your time.

Case studies (short and real)

1) Solo SaaS (Next.js + Postgres + worker, ~500 GB egress/month)

Stack:

Next.js app with server-side rendering
Background worker processing emails and webhooks
Postgres with daily snapshots and WAL archiving
Object storage for user uploads
Cloudflare in front

Hetzner:

1 × 2 vCPU / 4 GB for app: ~€5–8
1 × 2 vCPU / 2–4 GB for worker/cron: ~€4–6
1 × small VM for Postgres (2 vCPU / 4 GB) or managed DB: ~€5–15
100 GB block storage: ~€5
250 GB object storage: low €
Egress 500 GB: typically included with VM traffic; CDN reduces origin hits
Total: ~€20–€30/month

AWS:

t3.medium for app: ~$30 + EBS ~$8
t3.small/medium for worker: ~$16–$30 + EBS ~$8
RDS db.t4g.micro/small: ~$30–$60 plus storage/backups
S3 250 GB: ~$5–$6 storage (egress extra)
Egress 500 GB: ~$45
CloudWatch/NAT/other: $5–$20 depending on setup
Total: ~$100–$180/month

Verdict: Hetzner wins. Run Postgres yourself with automated backups if you’re comfortable; otherwise, a managed DB still keeps you well under AWS.

2) Agency hosting 10 client sites (WordPress + backups)

Stack:

10 small WordPress sites with daily backups
A staging environment shared across clients
Object storage for media and backups
Cloudflare for caching and SSL

Hetzner:

2–3 modest VMs (4 vCPU / 8 GB): ~€12–€16 each
200–300 GB of block storage: ~€10–€15
500 GB object storage: low €
Traffic: largely included, especially with CDN caching
Total: ~€35–€60/month

AWS:

EC2 for app servers (t3.medium × 2): ~$60 plus EBS ~$16
RDS or self-hosted MySQL: ~$30–$60 for managed, or another EC2 instance
S3 500 GB: ~$12.50 storage + egress
CloudWatch + NAT + inter-AZ: $10–$40
Total: ~$120–$200+/month

Verdict: Hetzner with 2–3 VMs, snapshots, and S3-compatible object storage is 60–80% cheaper. Add Ansible playbooks to standardize hardening and backups.

3) Analytics-heavy app (Kinesis/Lambda/Glue, cross-region, SOC demands)

Stack:

Real-time ingestion (Kinesis)
Serverless compute (Lambda)
ETL (Glue), data lake (S3), warehousing (Athena/Redshift)
Cross-region replication
SOC 2 and ISO 27001 requirements

Hetzner:

You can DIY Kafka, Flink, Airflow, MinIO, etc., but ops load explodes
Cross-region and compliance overhead is significant

AWS:

Fully managed ingestion/storage/processing
Audit-friendly IAM, CloudTrail, Config
CloudFront and multi-region patterns

Verdict: AWS’s managed stack pays for itself in saved engineering time and compliance coverage. This is what AWS is for. Use it and budget accordingly.

Decision framework you can apply today

Quick rule-of-thumb

If monthly egress < 1 TB and you don’t need niche managed services, default to Hetzner.
If you rely on RDS/Lambda/Kinesis/CloudFront or multi-region, default to AWS.
If you’re EU-first and cost-driven, Hetzner wins until compliance forces AWS.

10-minute checklist

List your components: web, API, DB, storage, queue, CDN.
Estimate egress: users × avg asset size × requests/month. Put a CDN in front; re-estimate origin egress.
Decide managed DB (yes/no). If yes and you lack ops time, lean AWS or a managed Postgres vendor.
Put a time value on ops (€/hr). If Hetzner saves > €50/month and ops < 2 hrs/month, choose Hetzner.
Add a CDN (e.g., Cloudflare) to reduce origin egress on either platform.
Sanity check migration: avoid proprietary services if you might switch later.
Write your “failure plan”: snapshots, backups, restore test frequency.

Budget breakpoints

Under €50/month: Hetzner almost always.
€50–€300/month: Mixed (Hetzner compute + Cloudflare; consider managed DB where painful).
€300+/month or strong compliance/global: AWS begins making sense.

The best default: Hetzner for compute + Cloudflare for edge + conservative use of managed DBs where you actually feel the pain.

Frequently asked questions

Is Hetzner reliable enough compared to AWS?

Yes for most solo workloads. Hetzner is widely used in production across Europe and beyond. You still need redundancy and backups—same as on AWS. Use two small app instances behind a load balancer when traffic justifies it, and ensure you can restore your DB quickly.

What about DDoS and security?

Put Cloudflare in front for CDN, WAF, and DDoS mitigation. Keep your systems patched, use provider firewalls/security groups, and follow least-privilege for SSH and database users. Don’t expose admin panels to the world; use IP allowlists or VPN. Same playbook on both providers.

Can I get a managed database on Hetzner?

Yes, Hetzner offers managed databases. Many solo builders still self-host Postgres on a small VM, with automated backups and WAL archiving. If you don’t want to think about DBs, use a managed option—either Hetzner’s or a third-party like Aiven, Neon, or Supabase.

Will my costs explode later if I pick Hetzner?

Only if egress or ops needs spike. Use a CDN to keep origin egress low, monitor usage monthly, and scale sensibly. If you outgrow Hetzner or need AWS features, migrate the pieces that need it. Containers and good backup discipline make migration straightforward.

How hard is migration between Hetzner and AWS?

If you avoid proprietary services, it’s mostly re-provisioning VMs, restoring backups, and switching DNS. With containers, it’s easier: push images to a registry, redeploy, restore DB, and go. The pain comes from tight coupling to AWS-only services.

Does Hetzner work for US-based clients?

Yes. Hetzner now offers US regions. Check latency from your users to the nearest region, confirm compliance and contract language, and run a pilot. For many US SMBs and startups, Hetzner is fast enough and far cheaper.

What about backups and disaster recovery?

Automate everything:

Nightly snapshots of VMs, retained for 7–14 days
Database dumps with point-in-time recovery (WAL), stored in object storage
Offsite copies in a separate provider/region
Quarterly restore tests to verify you can rebuild under pressure

This is non-negotiable regardless of provider.

How does “hetzner vs aws pricing” shake out for freelancers?

For freelancers hosting client apps or sites, Hetzner usually cuts 60–80% off the monthly cloud bill. That margin is either profit or lower invoices that make you more competitive. It’s the simplest “AWS alternative for small teams” when you don’t need managed bells and whistles.

Can I really run SaaS on Hetzner?

Absolutely. Many do. For a typical solo SaaS (Next.js, Node/Go/Rails back end, Postgres, Redis, object storage), Hetzner’s performance and pricing are hard to beat. “Run SaaS on Hetzner” is not a stunt—it’s a perfectly reasonable default. Put Cloudflare in front, automate your backups, and you’re good.

Any gotchas with Hetzner?

Fewer regions than AWS; if you need APAC or niche locales, check latency first.
Support is solid but not “enterprise concierge.” Keep your stack simple so you can self-recover.
Managed service catalog is smaller. Plan what you’ll self-host or outsource elsewhere.
As always, validate current pricing; providers adjust over time.

Internal links and further reading

Our manifesto on anti-bloat software: https://barestack.org/manifesto
Coolify self-hosting guide for solopreneurs: https://barestack.org/blog/solopreneurs-guide-coolify-self-hosting-made-easy
Self-hosting for small business (practical starter): https://barestack.org/blog/self-hosting-small-business-guide
Open-source CRM vs SaaS (control vs convenience): https://barestack.org/blog/open-source-crm-vs-saas-no-bullshit-comparison
Simple CRM vs enterprise CRM (why bloat loses): https://barestack.org/blog/simple-crm-vs-enterprise-crm
BareCRM vs HubSpot (anti-bloat comparison): https://barestack.org/blog/barecrm-vs-hubspot-anti-bloat-crm
All posts: https://barestack.org/blog
BareStack FAQ: https://barestack.org/faq
Compare page: https://barestack.org/compare

Conclusion: pick control over bloat

Here’s the no-bullshit call: for most solo stacks, Hetzner wins on cost, simplicity, and control. AWS wins when you absolutely need its managed services, global edge, or enterprise compliance posture. Do a one-hour audit today. If your monthly egress is modest and your app is simple, move compute to Hetzner, front with Cloudflare, and keep a clean, portable setup. Keep only what you must on AWS. That’s the BareStack way: minimalism, performance, and honest trade-offs. If you want software that shares that philosophy, try BareCRM—the minimalist CRM built for solo builders and small teams: https://app.barestack.org

—

Pricing reminder: Numbers above are illustrative, on-demand, and vary by region. Always check current provider pages before you deploy. And when you write comparisons like Hetzner > AWS for my use case, put them in code or escape the >—MDX doesn’t like raw angle brackets.