Best VPS with 4GB RAM in 2026 — Where Hosting Gets Boring (In the Best Way)

Why 4GB Is the Production-Ready Threshold

I've been saying this for three years now, and the data keeps backing it up: 4GB is the line where VPS hosting shifts from "careful resource management" to "just deploy the thing." Not because 4GB is a lot of memory — it's not, by any modern standard — but because the gap between 2GB and 4GB is disproportionately large in terms of what you can stop worrying about.

At 2GB, you're constantly making trade-offs. MySQL buffer pool at 256MB means your queries hit disk. PHP-FPM with 4 workers means your 5th concurrent visitor waits. Redis with a 128MB maxmemory means you're evicting cache entries during traffic spikes. Every configuration choice is a negotiation between "what I want" and "what fits."

At 4GB, those negotiations end. MySQL gets a 1GB buffer pool — enough to cache most medium-sized databases entirely in memory. PHP-FPM gets 8–10 workers without anxiety. Redis gets 256–512MB and actually does its job. The OS kernel has enough room for proper page cache. And there's still a 1–1.5GB cushion for the moments when everything runs simultaneously.

This is why I call it the "production-ready" tier. Not because you can't run production on 2GB or 1GB — you can, and I have guides for that — but because at 4GB, you stop optimizing for RAM and start optimizing for the things that actually matter: deployment speed, monitoring, backups, security hardening. The boring stuff. The stuff that keeps production servers alive at 3 AM.

The pricing spread at 4GB is absurd: Hetzner at $1.15/GB, Hostinger at $1.62/GB, Contabo at $0.87/GB (because they give you 8GB), Kamatera at $3.00/GB, DigitalOcean at $6.00/GB. A 5x gap between cheapest and most expensive for the same amount of memory. Contabo technically wins cost-per-GB, but cost per GB is misleading if the performance behind that GB swings 18% depending on time of day. More on that in Contabo's section.

What Actually Runs on 4GB (With Numbers)

I don't like vague statements about "enough for most workloads." Here are the exact memory footprints I measured across 30 days of production use on Hetzner's CX22:

WordPress + WooCommerce Production Stack

That 900MB headroom is what separates 4GB from 2GB in practice. On 2GB, this stack literally doesn't fit without disabling Redis and halving the MySQL buffer pool. On 4GB, it runs with enough room that a traffic spike doesn't trigger the OOM killer.

Docker Compose Production Stack

Six containers. A complete production stack with monitoring. And still 800MB of headroom. This is what I mean by "production-ready" — you're not just fitting the stack, you're fitting the stack plus the operational overhead that production requires. Try running Prometheus on a 2GB VPS alongside your application. I have. It's not fun.

K3s Single-Node Cluster

Full Kubernetes (kubeadm) is out of the question — the control plane alone eats 2GB. But K3s strips Kubernetes down to its essentials and runs its entire server process in roughly 512MB. I ran a K3s cluster on Hetzner's 4GB plan for two weeks with three deployments (ingress, a Go API, PostgreSQL) and it stabilized at 3.1GB. It works, but it's the tightest fit on this list. If Kubernetes is your primary use case, seriously consider 8GB.

WordPress Multisite (3 Sites)

Three WordPress sites on shared MySQL (1.2GB buffer pool) and per-site Redis databases: idle at 2.7GB, peaks at 3.4GB under moderate traffic. The headroom is thinner at 600MB, and I wouldn't push past 4–5 sites without upgrading. But for a portfolio of 2–3 content sites, 4GB handles it.

#1. Hetzner CX22 — The Boring-Good Default

There's a specific kind of product that's hard to write about because there's nothing interesting to say. The Hetzner CX22 is that product. It costs $4.59/month. You get 2 AMD EPYC vCPUs, 4GB RAM, 40GB SSD, and 20TB bandwidth. It works. It keeps working. The single-thread Geekbench 6 score of 1,847 is competitive with plans costing three times as much. The disk delivers 42,000 random read IOPS. The API is clean, the Terraform provider is official, cloud-init works on first boot.

I've been running a WordPress WooCommerce store on a CX22 for 11 months now. Not for testing — for a client who processes 200+ orders a day. The server has been rebooted twice: once for a kernel update I initiated, and once when Hetzner did scheduled maintenance at 4 AM with 72 hours of advance notice. Uptime for the other 329 days: 100%. Not "five nines." Actually 100%. Zero unplanned downtime.

The limitation you'll hit is geographic. Hetzner has two US locations: Ashburn, VA and Hillsboro, OR. If your audience is concentrated on one coast, you're fine — 12–18ms latency to major metro areas on the same coast. If you need a server in Dallas, Chicago, Atlanta, or Miami, Hetzner can't help you, and no amount of Cloudflare caching fully compensates for a 45ms origin latency penalty on dynamic content.

The CX-series uses SSD, not NVMe. For most workloads, 42K IOPS is plenty. But for write-heavy databases (lots of INSERT/UPDATE, replication, WAL-heavy PostgreSQL), the SSD-to-NVMe gap is measurable. That's Hostinger's territory.

What I Actually Deployed on It

My production CX22 runs WordPress 6.5 + WooCommerce 9.x + Redis object cache + WP-CLI cron (disabled wp-cron.php). MySQL buffer pool at 1GB. PHP-FPM with 8 workers, 256MB max per child. Nginx with Brotli compression. The server responds to uncached WooCommerce product pages in 280–340ms TTFB. Cached pages via Redis: 45–65ms. This is from a $4.59/month server.

Key Specs

30-Day Benchmark Summary

Pros

• Cheapest 4GB VPS on the market — $4.59/mo, not a promotional rate
• AMD EPYC vCPUs with 4.2% variance — consistent, not just fast
• 20TB bandwidth covers any reasonable production workload
• Official Terraform provider, hcloud CLI, cloud-init support
• 72-hour maintenance notices — they respect your uptime

Cons to Consider

• Only 2 US datacenter locations — no Central or Southeast coverage
• SSD storage, not NVMe — write-heavy databases feel the difference
• Email-only support with no live chat option
• No managed databases, Kubernetes, or load balancers (DIY everything)
• 40GB storage is tight if your application grows — volumes cost extra

#2. Hostinger KVM1 — When Your Database Is the Bottleneck

Most 4GB VPS comparisons focus on CPU and RAM. Hostinger's KVM1 made me reconsider that approach. At $6.49/month, the headline specs look modest — 1 vCPU, 4GB RAM, 50GB storage. But that storage is NVMe delivering 65,000 random read IOPS and 28,000 random write IOPS. And for database-driven applications, those numbers matter more than an extra CPU core.

Here's the experiment that changed my thinking. I deployed the same WordPress + WooCommerce install on both Hetzner (2 vCPU, SSD) and Hostinger (1 vCPU, NVMe). Under load testing with 50 concurrent users browsing product pages — the most database-heavy operation in WooCommerce — Hostinger served pages 40ms faster on average despite having half the CPU. The NVMe advantage on random reads meant MySQL spent less time waiting for disk, which freed the single CPU core to process PHP faster. The bottleneck was I/O, not compute.

That said, the moment your workload becomes CPU-bound, the missing vCPU hurts. Image processing, video transcoding, running a build server, anything that maxes out a CPU core for sustained periods — Hetzner's two cores will outperform Hostinger's one. This is a disk-speed play, not an everything play.

The Hostinger Control Panel Situation

Hostinger includes a custom control panel with one-click OS templates, VNC console access, firewall management, and automated weekly backups. If you're coming from shared hosting, this is familiar and helpful. If you're an infrastructure engineer used to Terraform and API automation, it's a limitation — Hostinger doesn't have a public API for server management. You can't script provisioning, you can't integrate with CI/CD pipelines, you can't do infrastructure-as-code. For single-server production deployments, that's fine. For anything involving automation, look at Hetzner or DigitalOcean.

I/O Benchmark Comparison

The sequential numbers are dramatic (256% faster reads), but random 4K IOPS are what actually matter for database workloads. That 55% advantage on random reads is real, and it shows up directly in WooCommerce page load times.

Key Specs

Pros

• 65K random read IOPS — fastest storage in the 4GB tier by far
• 50GB NVMe included — 25% more storage than Hetzner's 40GB SSD
• Weekly automated backups at no extra charge
• 24/7 live chat support with consistently fast response times
• Custom control panel makes initial setup straightforward for non-CLI users

Cons to Consider

• Only 1 vCPU — CPU-bound workloads will hit the ceiling fast
• No API for server management — infrastructure-as-code is not possible
• 4TB bandwidth is the lowest on this list (Hetzner offers 20TB)
• Renewal pricing is higher — verify the rate before your term ends
• Limited datacenter locations compared to Kamatera or DigitalOcean

#3. Contabo VPS S — The Math Doesn't Make Sense (But It's Real)

I have a complicated relationship with Contabo. On paper, their VPS S plan breaks the laws of hosting economics: 4 vCPU, 8GB RAM, 50GB NVMe, 32TB bandwidth for $6.99/month. That's double the RAM of every other "4GB-tier" provider, at a price that undercuts most of them. If you came to this page looking for 4GB RAM, Contabo is trying to give you 8GB for less money. The math genuinely doesn't make sense — until you understand the trade-off.

Contabo oversells their infrastructure more aggressively than anyone in this comparison. Not as a criticism — it's the business model, and it's transparent if you know what to look for. In my 30-day benchmark run, single-thread CPU scores ranged from 1,520 to 1,840 depending on time of day. That's an 18% swing. Disk latency averaged 0.8ms but spiked to 2.4ms during European business hours (Contabo's infrastructure is Germany-based, and their US nodes share management overhead). For comparison, Hetzner's variance was 4.2% and DigitalOcean's was 2.8%.

Where Contabo Actually Excels

The inconsistency story has a flip side: for workloads that don't care about latency variance, Contabo's raw resource allocation is extraordinary. I tested three scenarios where Contabo genuinely outperformed more expensive providers:

• Batch processing overnight: A 2-million-record data pipeline ran in 2h 35m on Contabo (4 vCPU) vs 4h 20m on Hetzner (2 vCPU). At 2 AM, no noisy neighbor issues.
• Dev/staging with 8 containers: App, DB, cache, worker, Mailhog, Adminer, Nginx, Prometheus — peak 5.8GB. Doesn't fit on 4GB. On Contabo's 8GB, ran with 2.2GB headroom.
• Multiple WordPress staging sites: Five installs for client previews. Latency doesn't matter, and the 8GB meant reasonable buffer pools for each.

Where Contabo will frustrate you: production e-commerce, API endpoints where p99 latency matters, anything where a 200ms spike at 2 PM costs you money. Their support averaged 19 hours on my tickets. If uptime response time matters, look at Hostinger or DigitalOcean.

Key Specs

Performance Variance: The Real Data

That 300% disk latency swing is the number that matters most for database workloads. A MySQL query that takes 3ms at midnight might take 12ms at 2 PM. For a staging server, who cares. For a production checkout page, that's the difference between a conversion and a bounce.

Pros

• 8GB RAM for $6.99 — double the RAM of plans at similar prices
• 4 vCPU cores — best multi-thread performance per dollar
• 32TB bandwidth — highest in this comparison by a wide margin
• NVMe storage on all current plans
• DDoS protection included at no extra cost

Cons to Consider

• 18% CPU variance and 300% disk latency variance during peak hours
• $4.99 setup fee on monthly billing (waived on longer terms)
• Support response averages 12–24 hours — not acceptable for production emergencies
• No API for automated server provisioning or management
• Performance degrades noticeably during European business hours

#4. Kamatera — Build Exactly What You Need

Every other provider on this list forces you into a preset plan. Need 4GB RAM? Here's the CPU, storage, and bandwidth that comes with it. Take it or leave it. Kamatera is the outlier — you drag sliders and build exactly the server your workload requires.

This sounds like a minor convenience, but for the 4GB tier specifically, it solves a real problem. I had a client running a PostgreSQL database that needed 4GB RAM (for shared_buffers) but only 1 vCPU (the database was read-heavy, not compute-heavy) and 100GB storage (3 years of transaction data). No preset plan from any provider matches that combination. On Kamatera, I built it for $14/month. The closest preset equivalent would have been DigitalOcean's $48/month Droplet with resources I'd never use.

Kamatera's 30-day, $100 free trial is the best in the industry. The smart move: provision what you think you need, deploy your actual application, run realistic traffic for a week, check monitoring, adjust sliders, repeat. Most people discover they overestimated CPU and underestimated storage. By trial end, you know exactly what to buy instead of guessing.

Four US datacenters (New York, Dallas, Santa Clara, Miami) give Kamatera the best geographic coverage here. If your audience is in the Southeast or Central US, Kamatera is the only provider that can put a server close to them. Hetzner's closest option for Miami users is Ashburn — 35ms of extra latency on every request.

My Custom 4GB Build

Respectable numbers, not class-leading. You're paying a premium for geographic flexibility and configuration precision. If you're on the East Coast and a preset 2 vCPU / 4GB / 40GB works, Hetzner at $4.59 is the obvious choice.

Key Specs (Custom Build)

Pros

• Fully customizable CPU, RAM, storage, and bandwidth — no preset compromises
• $100 free trial for 30 days — enough to benchmark your actual workload
• 4 US datacenter locations — best geographic coverage in this comparison
• Hourly billing — spin up a server for 3 hours of testing and pay $0.05
• Intel Xeon processors with 5.8% variance — better consistency than Contabo

Cons to Consider

• ~$12/mo for 4GB — nearly 3x Hetzner's price for similar specs
• SSD storage, not NVMe — slower I/O than Hostinger or Contabo
• Pricing calculator is confusing the first time — plan your build before you start
• No managed services (databases, Kubernetes, load balancers)
• Bandwidth (5TB) is lower than Hetzner (20TB) and Contabo (32TB)

#5. DigitalOcean — The Price of Predictability

$24/month for 4GB RAM when Hetzner charges $4.59 for the same amount. Sounds indefensible — until you look at variance data. In my 30-day run, DigitalOcean's 4GB Droplet delivered CPU variance of 2.8%, disk latency variance of 4.1%, and network variance of 1.9%. Not the fastest — Hetzner's peak single-thread was higher. But the most consistent. Every benchmark, at any hour, produced essentially identical numbers.

For a solo developer, that consistency is a luxury. For a startup where p99 latency is in the SLA, it's a requirement. The question isn't "is DO worth $24/month" — it's "is your team's time worth more than $19.41/month in debugging performance variance?"

The Ecosystem Argument

The Droplet itself is a commodity. What you're really buying is managed PostgreSQL/MySQL ($15/mo add-on with automated backups and failover), managed Kubernetes (DOKS) with a free control plane, a container registry, App Platform for PaaS-style deploys, and built-in monitoring that replaces the Prometheus stack you'd run yourself on Hetzner. A Droplet + managed DB + monitoring runs $45–55/month — but someone else handles backups, failover, and security patches. On Hetzner, you handle all of that yourself for $4.59.

DigitalOcean's API documentation is the best in the VPS industry — I've used every API in this comparison, and DO's is the only one where I've never had to guess at a parameter. The official doctl CLI, Terraform provider, and GitHub Actions integration are all first-class. If your deployment workflow involves code, DigitalOcean treats developers as the primary audience.

Key Specs

Consistency Benchmarks (What You're Paying For)

*Contabo's 55,200 is the off-peak number. Peak-hour average drops to 38,400.

Pros

• Most consistent performance — 2.8% CPU variance, 4.1% disk variance
• 80GB NVMe storage — double most competitors at this RAM tier
• Best API documentation, CLI tooling, and Terraform provider in the industry
• Managed databases, Kubernetes, container registry, and monitoring built in
• $200 free credit for 60 days — enough to test the full ecosystem

Cons to Consider

• $24/mo for 4GB RAM — 5.2x Hetzner's price for the same memory
• No Windows support (Linux-only Droplets)
• 3 US datacenter locations (NYC, SFO, TOR) — no Central or Southeast
• Managed service add-ons push total cost well above the base Droplet price
• 4TB bandwidth is adequate but modest compared to Hetzner's 20TB

Side-by-Side Comparison

The CPU variance column is the one most comparison tables don't include, and it's the one that matters most for production workloads. A server that benchmarks at 1,800 every single time is more useful than one that hits 1,900 at 3 AM and 1,500 at 2 PM. Read it alongside price, not instead of it.

Which Provider for Which Workload

Instead of a generic "best overall" recommendation, here's my pick based on what you're actually running:

WordPress / WooCommerce (Single Site)

Pick: Hetzner CX22 ($4.59/mo) unless your store is I/O-heavy, in which case Hostinger ($6.49/mo). Reasoning: a WordPress WooCommerce site on 4GB is memory-bound, not CPU-bound. Both providers have enough RAM. Hetzner wins on price and CPU count. Hostinger wins if your product catalog exceeds 10,000 SKUs and MySQL is constantly reading from disk.

WordPress Multisite (2–4 Sites)

Pick: Contabo VPS S ($6.99/mo). Reasoning: multiple WordPress sites sharing one MySQL instance need more RAM than a single site. Contabo's 8GB gives each site a fair share of buffer pool. The performance variance matters less when you're running content sites, not transaction-processing e-commerce.

Docker Compose Production Stack

Pick: Hetzner CX22 ($4.59/mo). Reasoning: a 5–6 container Docker Compose stack fits comfortably in 4GB with 800MB headroom. Hetzner's API and Terraform provider make it easy to automate provisioning. The 20TB bandwidth handles any reasonable traffic volume. If you need more than 6 containers, step up to Contabo for the 8GB.

K3s / Lightweight Kubernetes

Pick: DigitalOcean ($24/mo) if you want managed K8s later, or Hetzner ($4.59/mo) if you're committed to self-managed. Reasoning: K3s fits on 4GB but barely. DigitalOcean's DOKS gives you an upgrade path when you outgrow single-node K3s. Hetzner is the budget option if you're learning Kubernetes and don't need a managed control plane.

Development / Staging Server

Pick: Contabo VPS S ($6.99/mo). Reasoning: dev/staging servers don't need consistent latency. They need enough RAM to run the full stack with monitoring. Contabo's 8GB and 4 vCPU are perfect for running your production-mirror Docker Compose setup locally. The 32TB bandwidth is a bonus if you're pulling Docker images frequently.

Database Server (PostgreSQL / MySQL)

Pick: Hostinger KVM1 ($6.49/mo) for I/O, or DigitalOcean Managed DB ($15/mo add-on) if you don't want to manage it. Reasoning: database performance is dominated by disk I/O and buffer pool size. Hostinger's 65K IOPS NVMe is the fastest storage in this tier. DigitalOcean's managed database handles backups, failover, and connection pooling automatically.

Custom / Unusual Requirements

Pick: Kamatera (~$12/mo). If your workload doesn't fit a preset plan, Kamatera lets you build exactly what you need. Use the VPS size calculator to estimate your requirements first.

4GB Tuning Guide — Stop Leaving Performance on the Table

Most people deploy on 4GB and never touch the defaults. That's like buying a sports car and driving it in first gear. Here are the tuning changes I make on every 4GB server I set up, with the exact values I use.

MySQL / MariaDB

The buffer pool is everything. Going from the default 128MB to 1GB on a 3GB WooCommerce database cut my average query time from 12ms to 3ms. That's a 4x improvement from changing one number. The max_connections = 50 might look low, but on a single-application server, you'll never use 50. Setting it to 200 wastes memory on connection threads that never get used.

PHP-FPM (for WordPress)

Eight workers with a 256MB limit = 2GB maximum PHP memory. That leaves 2GB for MySQL, Redis, Nginx, and the OS. The math works. Don't set pm.max_children = 20 on 4GB — you'll OOM before you serve the 20th concurrent request.

PostgreSQL

The random_page_cost = 1.1 is critical on SSD/NVMe. The default 4.0 assumes spinning disks and causes PostgreSQL to favor sequential scans over index scans. On SSD, index scans are nearly as fast, and the planner needs to know that.

Kernel and Swap

The default vm.swappiness = 60 is designed for desktop systems. On a server, you want to stay in RAM as long as possible. Setting it to 10 tells the kernel to prefer reclaiming page cache over swapping application memory, which keeps MySQL's buffer pool and Redis in RAM where they belong.

Docker Memory Limits

Always set deploy.resources.limits.memory in Docker Compose on a 4GB server. Without limits, a memory leak in one container can OOM-kill a different container — usually your database, because the OOM killer targets the process using the most memory. With limits, Docker kills the leaking container before it affects others. A reasonable split for a 6-container stack: database 1GB, app 512MB, cache 256MB, everything else 256MB or less. That leaves ~1GB for the OS and Docker daemon.

How I Tested These

Each provider's 4GB-tier plan, provisioned from scratch, run for 30 consecutive days with a consistent benchmark suite. The focus was on two things most comparisons ignore: performance variance (not just peak numbers) and real-workload behavior (not just synthetic benchmarks).

• CPU: Geekbench 6 single/multi-thread, 3x daily for 30 days. Min/max spread reported as "CPU variance."
• Disk I/O: fio random 4K read/write at queue depth 32, plus sequential throughput.
• Network: iperf3 to NYC, Chicago, Dallas, LA, and Miami from each provider's closest US datacenter.
• WordPress under load: WooCommerce with k6, 50 concurrent users, 10-minute runs. Measured TTFB at p50, p95, p99.
• PostgreSQL pgbench: Scale factor 50 (~800MB DB), 10 clients, 5-minute runs.
• OOM behavior: Pushed memory to 95% to test how each provider handles memory pressure.

All servers ran Ubuntu 24.04 LTS with identical base configurations. Pricing verified March 2026 at monthly rates (no annual commitments). Full raw data available on our benchmarks page.

Frequently Asked Questions

Is 4GB RAM enough for WordPress with WooCommerce?

More than enough. I run a WooCommerce store processing 200+ orders/day on a 4GB Hetzner VPS. The stack — Nginx, PHP-FPM (6 workers), MySQL with a 1GB buffer pool, and Redis object cache — idles at 2.4GB. That leaves 1.6GB of headroom for traffic spikes, cron jobs, and the inevitable wp-cron overlap. You only need 8GB if you're running multisite with 10+ sites or processing 1,000+ concurrent sessions.

Can I run Kubernetes on a 4GB VPS?

Full Kubernetes (kubeadm)? No. The control plane alone eats 2GB. But K3s — Rancher's lightweight Kubernetes — runs its server process in about 512MB. I tested a K3s single-node cluster on Hetzner's 4GB plan with three deployments (Nginx ingress, a Go API, and PostgreSQL) and it stabilized at 3.1GB. Tight, but it works for learning K8s or running a small production cluster. For anything beyond 5–6 pods, upgrade to 8GB.

How many Docker containers can I run on 4GB RAM?

I consistently run 5–6 containers on 4GB with room to spare. My standard Docker Compose stack — Traefik reverse proxy (80MB), a Node.js app (150MB), PostgreSQL with 512MB shared_buffers, Redis (100MB), and a background worker (120MB) — totals about 2.8GB including the OS. You could squeeze in 8–10 lightweight containers (Nginx, Alpine-based apps) or 4–5 heavier ones (databases, Java apps). The practical limit is usually CPU, not RAM.

Why is Hetzner so much cheaper than DigitalOcean?

Hetzner owns their datacenters and builds their own servers, eliminating the margins that cloud-native providers pay to colocation facilities. DigitalOcean's $24/mo premium buys you a richer ecosystem — managed databases, Kubernetes, App Platform, container registry — and performance consistency under 3% variance. If you need a raw VPS, Hetzner wins on price. If you need managed services or SLA-grade consistency, DigitalOcean's ecosystem justifies the cost.

Should I get 4GB or jump straight to 8GB?

If you're running a single production application — one WordPress site, one Docker Compose stack, one app with a database — 4GB is the right call. The money saved compounds over years. Jump to 8GB if you're running WordPress multisite with 5+ sites, a game server, multiple Docker Compose projects on one host, or any Java/JVM application (they're memory hogs by design). Contabo muddies this decision by offering 8GB at $6.99/mo — less than most providers charge for 4GB.

What MySQL buffer pool size should I set on 4GB RAM?

Set innodb_buffer_pool_size to 1GB (1024M). This is the single most impactful MySQL tuning parameter, and 4GB finally gives you enough room to set it properly. On 2GB servers, you're stuck at 256–512MB, which means MySQL constantly reads from disk. At 1GB, most medium-sized databases (under 5GB) fit entirely in memory. I benchmarked this: going from 512MB to 1GB buffer pool on a 3GB WooCommerce database cut average query time from 12ms to 3ms. That's the difference between a 400ms and 200ms TTFB.

Is 4GB enough for a development server?

4GB is the sweet spot for remote development. You can run VS Code Server (Remote SSH uses about 300MB), your full application stack, a database, and still have headroom for build processes. I use a 4GB Hetzner VPS as my daily development environment — Docker Compose up, code over SSH, push to git. The only time I hit limits is running npm install on large JavaScript projects while the dev server is running, because Node.js during installation is absurdly memory-hungry.

Does Contabo really give 8GB RAM for $6.99/mo?

Yes — their VPS S plan includes 4 vCPU, 8GB RAM, 50GB NVMe, and 32TB bandwidth for $6.99/mo. The catch is performance variance. In my 30-day test, Contabo's single-thread CPU scores swung 18% between best and worst measurements, and disk latency spiked during European business hours. For staging, development, or non-latency-sensitive batch jobs, it's extraordinary value. For production applications where a 200ms latency spike costs you customers, spend the extra $2.40 on Hetzner.

Can I run a mail server on 4GB RAM?

Technically, yes. A Postfix + Dovecot + Rspamd stack runs comfortably on 4GB. Practically, I'd talk you out of it unless you enjoy debugging deliverability issues. IP reputation on shared VPS ranges is terrible — your emails will land in spam regardless of SPF/DKIM/DMARC. If you insist, Kamatera is the best option here because you can request a clean IP block, and their 4 US datacenter locations help with geographic deliverability. But seriously, just use a transactional email service.