DEV Community: Vpsfordev

I set up a Node.js production server on Hetzner CX22 for €4.35/mo — here's exactly what I ran

Vpsfordev — Fri, 19 Jun 2026 14:51:18 +0000

Most Node.js hosting guides assume you're using DigitalOcean or AWS. I switched to Hetzner CX22 (€4.35/mo, 2 vCPU, 4GB RAM) and it's been running production workloads for months without a single issue.

Here's the exact setup I use — no fluff, just the commands.

Why Hetzner CX22

A 4GB DigitalOcean droplet costs ~$24/month. The Hetzner CX22 with identical specs costs €4.35/month. I ran benchmarks with autocannon — Hetzner is actually ~3.5% faster. So it's cheaper AND faster. The only trade-off is ticket-only support.

The setup (in order)

1. Create a non-root user immediately

# Login as root (first and only time)
ssh root@YOUR_SERVER_IP

adduser deploy
usermod -aG sudo deploy
rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy

Never run Node.js as root. This takes 30 seconds and saves you from a class of security issues.

2. Firewall on, then forget about it

sudo apt update && sudo apt upgrade -y
sudo apt install ufw -y

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable

All ports closed except 22, 80, 443. Hetzner servers are fully open by default — this step is not optional.

3. Node.js via nvm (not apt)

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts

apt install nodejs gives you an outdated version. nvm gives you the current LTS without sudo.

4. Swap file before anything else

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

On a 4GB VPS, npm install during a deploy can spike RAM by 30-50%. Without swap, it OOM-kills your running app mid-deploy. I learned this the hard way.

5. PM2 with memory limits

npm install -g pm2

ecosystem.config.js for a 2-core server:

module.exports = {
  apps: [{
    name: 'my-app',
    script: './dist/index.js',
    instances: 2,           // one per core
    exec_mode: 'cluster',
    max_memory_restart: '350M',
    node_args: '--max-old-space-size=320',
    env_production: { NODE_ENV: 'production', PORT: 3000 }
  }]
};

The --max-old-space-size flag is critical. Without it, V8 can claim up to 1.5GB on a 4GB machine and crash the server. Two workers × 350MB = 700MB max, leaving ~90MB headroom for the OS.

pm2 start ecosystem.config.js --env production
pm2 save
pm2 startup  # run the command it prints

6. Nginx + free SSL

sudo apt install nginx certbot python3-certbot-nginx -y

/etc/nginx/sites-available/my-app:

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

sudo ln -s /etc/nginx/sites-available/my-app /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d yourdomain.com

Certbot handles HTTPS config and sets up auto-renewal. Done.

Total time

From fresh server to HTTPS Node.js app: ~25 minutes the first time, ~10 minutes once you know the commands.

What I'd do differently

Set up SSH key auth only (PasswordAuthentication no in sshd_config) — I skipped this once and had 2,000 failed login attempts in the logs within an hour
Monitor with pm2 monit before assuming things are fine — one of my workers had a memory leak that only showed up under load

Full step-by-step guide with exact commands at vpsfor.dev →

How many Node.js apps can you run on a 2-core 1GB VPS with PM2? (The math)

Vpsfordev — Wed, 03 Jun 2026 16:06:42 +0000

Every indie hacker running on a $5 VPS has asked this question. The answer depends entirely on what kind of apps you're running — and most guides skip the actual math.

Here's the breakdown I wish I had when I started.

Your real available RAM is not 1GB

The OS and PM2 daemon eat RAM before your app runs a single line of code:

Component	RAM Used
Ubuntu 22.04 (minimal)	~180MB
PM2 daemon	~30MB
Available for your apps	~790MB

So you're working with ~790MB, not 1024MB. Now let's see what fits.

App capacity by type

App Type	Idle RAM	Under Load	Max Apps on 2-core 1GB
Simple bot / webhook	60–90MB	~120MB	6–8 apps (fork mode)
Standard REST API (Express/Fastify)	80–120MB	~200MB	2–3 apps
Next.js / Nuxt SSR	350–500MB	600MB+	1 app only
Heavy AI / Discord bot	600MB+	OOM risk	1 app + swap

The "under load" column is what actually matters — idle numbers are misleading because Node.js apps spike heavily during deploys, GC cycles, and traffic bursts.

Option A: One API, full cluster mode (2 workers)

If you have a single Node.js API and want to use both CPU cores:

// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'my-api',
    script: './dist/index.js',
    instances: 2,             // exactly 2 workers for a 2-core VPS
    exec_mode: 'cluster',
    max_memory_restart: '350M',
    node_args: '--max-old-space-size=320',
    env_production: { NODE_ENV: 'production', PORT: 3000 }
  }]
};

2 workers × 350MB limit = 700MB max, leaving ~90MB headroom. The --max-old-space-size flag is critical — without it, V8 can claim up to 1.5GB and OOM-kill your server.

Option B: Multiple small apps, fork mode

If you're hosting 2–3 separate projects on the same VPS:

module.exports = {
  apps: [
    {
      name: 'api',
      script: './api/dist/index.js',
      instances: 1,
      exec_mode: 'fork',
      max_memory_restart: '250M',
      node_args: '--max-old-space-size=200',
    },
    {
      name: 'worker',
      script: './worker/dist/index.js',
      instances: 1,
      exec_mode: 'fork',
      max_memory_restart: '200M',
      node_args: '--max-old-space-size=160',
    }
  ]
};

Two apps × ~200MB = 400MB used, ~390MB free for spikes. Fork mode is better here than cluster — each app runs independently, and a crash in one doesn't affect the other.

3 things I learned the hard way

1. Always create a swap file — it's not optional on 1GB

fallocate -l 2G /swapfile
chmod 600 /swapfile
mkswap /swapfile
swapon /swapfile
echo '/swapfile none swap sw 0 0' >> /etc/fstab

Deploys temporarily spike RAM usage by 30–50%. Without swap, a npm install on a busy server will OOM-kill your running app.

2. max_memory_restart is a safety net, not a target

If PM2 is regularly hitting the limit and restarting your app, that's a memory leak — fix the code, don't raise the limit. Use pm2 monit to watch RSS (resident set size) over time.

3. Node.js v20+ saves you ~20% RAM for free

Modern V8 engines use pointer compression by default on 64-bit systems, reducing heap object size significantly. If you're still on Node 16/18, upgrading alone might give you room for one more small app.

The quick decision guide

1 production API → cluster mode, 2 instances, max_memory_restart: '350M'
2 small projects → fork mode, 1 instance each, max_memory_restart: '250M'
3+ bots/webhooks → fork mode, max_memory_restart: '120M', add swap
Next.js SSR → 1 app only, upgrade to 2GB RAM if possible

Full PM2 ecosystem configs for 1GB, 2GB, and 4GB VPS tiers at vpsfor.dev →

I benchmarked Hetzner CX22 vs DigitalOcean for Node.js in 2026 — 5 cheaper, 4% slower

Vpsfordev — Mon, 01 Jun 2026 16:27:02 +0000

Most Node.js developers default to DigitalOcean because it's what every tutorial uses. I did too — until I checked the bill.

A 4GB DigitalOcean Premium droplet costs $24/month. A Hetzner CX22 with the same specs costs €4.35/month. That's a 5× price difference. So I ran the benchmarks to find out what you actually give up.

The Setup

Tool: autocannon — 10 concurrent connections, 60-second sustained load
App: Standard Express.js API returning JSON
Runtime: Node.js v25 on Ubuntu 22.04
Tiers compared: Both at 2 vCPU / 4GB RAM (equivalent specs)

Results

Throughput (requests per second)

Provider	Plan	RPS	Price/mo
Hetzner	CX22 (2 vCPU, 4GB)	4,250	~€4.35
DigitalOcean	Premium AMD (2 vCPU, 4GB)	4,100	~$24.00
DigitalOcean	Basic (1 vCPU, 2GB)	2,300	$6.00

Hetzner is ~3.5% faster than DigitalOcean Premium at the same spec tier. For a 5× price difference, that's not a typo.

Disk I/O — npm install speed

Installing a real project with 300+ dependencies:

Hetzner CX22: 18.4 seconds
DigitalOcean Premium: 21.2 seconds

Hetzner uses NVMe over Fabrics (NVMe-oF) which consistently outperformed DO in sequential read/write tests with fio.

Bandwidth included

Provider	Included bandwidth
Hetzner CX22	20 TB/month
DigitalOcean Premium	4 TB/month

If you're serving large assets or have high-traffic APIs, this matters a lot.

Why the price gap is this large

Hetzner is a European DC operator with 30+ years in infrastructure. They don't have a venture-backed marketing budget or a $200M/year developer relations program. What they do have is AMD EPYC Milan/Genoa nodes, NVMe storage, and 20TB of transfer — at a price point that makes no sense until you use it.

DigitalOcean Premium uses similar EPYC hardware, but you're paying for the platform: managed databases, one-click apps, a polished dashboard, live chat support, and 14+ global regions.

When to pick which

Hetzner CX22 if:

You're comfortable with SSH, PM2, and Nginx
Your users are in Europe or North America
You want maximum Node.js throughput per euro
You're a solo dev or small team that can handle their own incidents

DigitalOcean if:

You need managed Postgres, Redis, or S3-compatible storage
Your users are globally distributed (DO has 14+ regions vs Hetzner's 5)
You need live chat support or hourly billing for ephemeral environments
You're working with a team that can't deal with Linux emergencies at 2am

The verdict

For 90% of solo developers and early-stage startups, Hetzner CX22 is the better choice. You get equivalent raw performance for a fraction of the cost. The only real trade-offs are fewer regions and ticket-only support.

I migrated a Node.js API from DigitalOcean Basic ($12/mo) to Hetzner CX22 (€4.35/mo) and saw slightly better response times with the same PM2 + Nginx setup. The monthly bill dropped by ~$8 for a server that's technically more capable.

Full methodology, raw fio and autocannon output, and a complete setup guide at vpsfor.dev →