DEV Community: Vpsfordev

Linode became Akamai Cloud — is it still worth it for Node.js in 2026?

Vpsfordev — Mon, 26 Oct 2026 14:02:06 +0000

Linode has a 15+ year reputation for being the "boring, reliable" VPS choice. Since the Akamai acquisition in 2022, pricing has crept up and the UI got more enterprise-flavored. For a new Node.js project in 2026, is there still a reason to pick it over Hetzner or DigitalOcean?

Pricing (2026)

Plan	vCPU	RAM	Storage	Transfer	Price/month
Nanode 1GB	1	1 GB	25 GB SSD	1 TB	$5
Linode 2GB	1	2 GB	50 GB SSD	2 TB	$12
Linode 4GB	2	4 GB	80 GB SSD	4 TB	~$18
Linode 8GB	4	8 GB	160 GB SSD	5 TB	$48

The one number that stands out: transfer allowances. 1–5 TB included vs the 1 TB that's typical everywhere else.

Performance

Standard plans run Intel Xeon with regular SSD — not NVMe. That shows up clearly in disk-bound benchmarks:

Metric	Linode 4GB	Hetzner CX22
Express API (light load)	11–20ms	8–15ms
Disk read (sequential)	~400 MB/s	~2,000 MB/s
Price/month	~$18	~€4.35

CPU and network are perfectly adequate for a typical Node.js API — most workloads are network-bound, not disk-bound, so this matters less day-to-day than the benchmark gap suggests. NVMe is only available on Linode's premium tiers.

What Akamai actually brings to the table

Akamai's backbone means genuinely solid peering and low-latency routing across 20+ regions, plus CDN integration if your app needs it. The flip side: pricing has moved up since the acquisition, and the dashboard now carries more enterprise cruft than the old Linode UI did.

Who this is actually for

✅ Existing Linode users — no compelling reason to migrate if things already work
✅ Projects that will burn through transfer quota — the included bandwidth is the best in this comparison
✅ Teams that value documentation — Linode's Node.js + PM2 + Nginx guide is one of the better ones in the industry
❌ New projects optimizing purely for price-per-spec — Hetzner wins here
❌ Disk-intensive workloads on standard (non-premium) tiers

Verdict

If you're already on Linode, the Akamai rebrand isn't a reason to leave. If you're starting fresh in 2026 and comparing providers from zero, Hetzner or DigitalOcean are the more obvious defaults — Linode/Akamai earns its spot specifically when transfer allowance or Akamai's CDN integration matters to you.

Full benchmarks, region list, and Node.js setup steps at vpsfor.dev →

PHP2Shell: if you use aaPanel, apt upgrade won't patch you

Vpsfordev — Fri, 23 Oct 2026 14:05:12 +0000

On 21 October the PHP project shipped emergency releases for CVE-2026-109618 and CVE-2026-109619 ("PHP2Shell" in the press — PHP itself doesn't use that name). Both allow unauthenticated remote code execution on any PHP that serves web requests: PHP-FPM, mod_php, php-cgi, FrankenPHP, LiteSpeed. A proof-of-concept leaked early.

Fixed versions: 8.5.12, 8.4.27, 8.3.36, 8.2.35. PHP 8.1 and older get no official fix.

Most coverage stops there. Here's the part that bit a server I checked this week.

The aaPanel / BaoTa trap

apt on that box showed two PHPs:

bt-php81/now 8.1.13 amd64 [installed,local]
php8.1-cli/now 8.1.31-1+ubuntu20.04.1+deb.sury.org+1 amd64 [installed,upgradable to: 8.1.32...]

The one actually serving the websites was the panel's:

php-fpm: master process (/www/server/php/81/etc/php-fpm.conf)
PHP 8.1.13 (cli) (built: Dec  1 2022 08:28:57) (NTS)

aaPanel compiles its own PHP into /www/server/php/<version>/. apt sees it as a local package and apt upgrade never touches it. A December 2022 PHP build, behind public Nginx on 80/443 — and no amount of apt upgrading would have changed that.

Check your server in 2 minutes

# Anything serving PHP?
ps aux | grep -E "php-fpm|php-cgi|apache2|httpd" | grep -v grep

# apt-installed PHP
apt list --installed 2>/dev/null | grep -i php

# Panel-installed PHP (aaPanel/BaoTa)
for v in /www/server/php/*/bin/php; do "$v" -v | head -1; done

Anything below the fixed versions is vulnerable.

Fix

Don't need PHP? Stop and disable it (sudo systemctl disable --now php8.1-fpm, or stop it in the panel). Many "Node.js-only" servers still run PHP from an old WordPress, phpMyAdmin, or a panel default.
apt PHP: upgrade, then verify the package actually mentions the fix instead of assuming: apt changelog php8.3-fpm 2>/dev/null | grep -E "CVE-2026-10961[89]"
aaPanel: install PHP 8.3/8.4 from the App Store, check /www/server/php/83/bin/php -v is ≥ 8.3.36 / 8.4.27, switch each site, then remove 8.1.
Snapshot the server first.

Patching doesn't remove anything an attacker already dropped, so also look for PHP files modified since 20 Oct and processes running as your web user that aren't PHP-FPM.

Full guide — reachability checks, the official temporary mitigations (and why one of them can take down a small VPS), and a compromise checklist: vpsfor.dev →

Vultr has 32 regions for Node.js — here's when that actually beats Hetzner

Vpsfordev — Fri, 23 Oct 2026 12:37:36 +0000

Hetzner wins almost every VPS price comparison for Node.js — but only if your users are in Europe or North America. If your API needs to be fast in Tokyo, Seoul, or Johannesburg, Hetzner's 5 regions don't help you. That's where Vultr's 32 datacenters change the calculus.

Pricing (2026)

Plan	vCPU	RAM	Storage	Bandwidth	Price/month
1 vCPU	1	1 GB	25 GB NVMe	1 TB	$6
1 vCPU	1	2 GB	55 GB NVMe	2 TB	$12
2 vCPU	2	4 GB	80 GB NVMe	3 TB	$24
4 vCPU	4	8 GB	160 GB NVMe	4 TB	$48

NVMe on every tier is worth noting — DigitalOcean only gives you that on Premium plans, not Basic.

Performance

Metric	Vultr (AMD HF)	Hetzner CX22	DO Basic 4GB
Express API (light load)	9–16ms	8–15ms	10–18ms
Disk read (sequential NVMe)	~1,500 MB/s	~2,000 MB/s	~500 MB/s
Price/month (2 vCPU/4GB)	$24	~€4.35	$24

For a region Hetzner and DigitalOcean both cover, Hetzner still wins on price-per-spec. The reason to pick Vultr isn't raw performance — it's reach.

The region list that matters

32 datacenters including Tokyo, Seoul, Singapore, Mumbai, São Paulo, Mexico City, Johannesburg, and Sydney — on top of the usual US/EU spread. If your API serves APAC or LATAM users, this is one of the few budget providers with dedicated hardware there instead of routing through a single regional hub.

Who this is actually for

✅ Apps needing low latency to Asia-Pacific, Africa, or Latin America specifically
✅ Multi-region deployments — consistent pricing and NVMe across every datacenter
✅ Short-lived workloads — hourly billing on every plan
❌ Pure EU/US budget optimization — Hetzner wins on price-per-spec here
❌ Teams that need first-class support — ticket response is inconsistent compared to DigitalOcean

Verdict

Don't pick Vultr for Europe or North America unless hourly billing specifically matters to you — Hetzner is cheaper for the same specs. Pick it the moment your user base includes APAC, LATAM, or Africa, where it has datacenters competitors simply don't.

Full region list, benchmarks, and Node.js setup steps at vpsfor.dev →

DigitalOcean costs 30-40% more than Hetzner for Node.js — is the premium worth it?

Vpsfordev — Thu, 15 Oct 2026 12:50:28 +0000

After benchmarking Hetzner vs DigitalOcean for Node.js, I kept getting the same question: "but what about support and dashboard UX?" Here's what the premium actually buys you, beyond the spec sheet.

Pricing (2026)

Plan	vCPU	RAM	Storage	Price/month
Basic 1GB	1	1 GB	25 GB SSD	$6
Basic 2GB	1	2 GB	50 GB SSD	$12
Basic 4GB	2	4 GB	80 GB SSD	$24
Basic 8GB	4	8 GB	160 GB SSD	$48

Hetzner CX22 (2 vCPU, 4GB) runs ~€4.35/mo. DigitalOcean's equivalent Basic 4GB is $24/mo — roughly 5x. Premium AMD droplets (NVMe, dedicated thread) cost ~2x the Basic tier on top of that.

What the premium actually buys you

Live chat support that responds. This is the real differentiator — tickets get answered in minutes, not the 24-48h typical of budget providers.
A dashboard that doesn't fight you. Droplet creation, snapshots, firewalls — all obvious without reading docs.
A 1-Click Node.js Marketplace image that pre-installs Node, PM2, and Nginx — saves roughly 15 minutes on initial setup.
Managed databases, load balancers, and S3-compatible Spaces in the same dashboard if you need them later.

What it doesn't buy you

Basic plans use shared Intel CPUs with regular SSD, not NVMe — NVMe only comes on Premium droplets. Disk throughput on Basic was clearly the weak point:

Metric	DigitalOcean Basic 4GB	Hetzner CX22
Express API (light load, EU)	10–18ms	8–15ms
Disk read (sequential)	~500 MB/s	~2,000 MB/s
Price/month	$24	~€4.35

Premium AMD droplets close most of that gap, but then you're paying closer to 6-7x Hetzner's price for comparable performance.

Who this is actually for

✅ You're new to VPS and don't want to debug SSH/firewall issues solo
✅ Client work where "who do we call at 2am" needs a real answer
✅ Short-lived environments — hourly billing is available
✅ You'll actually use managed databases or load balancers later
❌ Pure budget optimization — Hetzner or Contabo give more spec per dollar
❌ Disk-heavy workloads on Basic plans specifically

Verdict

The premium is real, and for client work where support response time matters, I'd pay it again. If you're a solo dev optimizing your own side project's bill, it's genuinely hard to justify over Hetzner on specs alone — the thing you're paying for is the safety net, not the hardware.

Full benchmarks, regions, and Node.js setup steps at vpsfor.dev →

Contabo gives you 8GB RAM for $7/mo — I tested if the catch is real

Vpsfordev — Sun, 11 Oct 2026 13:08:19 +0000

Every time Contabo comes up in a VPS thread, someone says "there has to be a catch at that price." 8GB RAM, 6 vCPU, 200GB NVMe for ~$15/mo is roughly half what Hetzner charges for similar specs. Here's what the numbers actually look like once you dig past the spec sheet.

Pricing (2026)

Plan	vCPU	RAM	Storage	Price/month
VPS S	4	8 GB	100 GB NVMe	~$7
VPS M	6	16 GB	200 GB NVMe	~$15
VPS L	8	30 GB	400 GB NVMe	~$27

For comparison, DigitalOcean charges $48/mo for 4 vCPU + 8GB. Contabo's VPS S gives you the same RAM for $7. That's not a typo.

Where the catch actually is

It's not the hardware — NVMe is on every plan, and raw specs are genuinely generous. The catches are:

Support is slow. 24–48h ticket response time. No live chat. If something breaks at 2am, you're waiting.
Network is noisier. Budget tiers share bandwidth more aggressively than Hetzner or DigitalOcean — expect occasional latency spikes during peak EU hours.
No hourly billing. Monthly only — can't spin up and tear down for quick tests.

What the benchmarks show

Running a simple Express API on the VPS S tier:

Metric	Contabo VPS S
Express API response (EU)	12–18ms
Disk read (sequential NVMe)	~1,200 MB/s
Node.js cold start	~180ms
Uptime over the test period	99.94%

CPU is "good for the price" rather than best-in-class — there's some variance depending on which physical host you land on, which is the usual tradeoff with oversubscribed budget CPU.

Who this actually makes sense for

✅ Side projects and bots where RAM headroom matters more than raw speed
✅ Self-hosted tools (n8n, Grafana, small databases) that want breathing room
✅ Anyone who doesn't need sub-10ms response times or instant support
❌ Production apps where a 24h support SLA is a problem
❌ Latency-sensitive workloads (WebSockets, real-time APIs)

Verdict

If you're running Node.js APIs or self-hosted tools and support speed isn't critical, Contabo is genuinely hard to beat on specs-per-dollar. I wouldn't put a client's production app on it without a monitoring + alerting setup you trust, but for personal projects and bots it's been solid.

Full benchmark details, region list, and setup steps at vpsfor.dev →

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 →