DEV Community: devstack-blog

Hetzner Price Increase 2026: Cheaper VPS Alternatives

devstack-blog — Sun, 08 Nov 2026 04:53:15 +0000

Originally published at LeanStack.

For years Hetzner was the default answer to "where do I get a cheap VPS?" In 2026 that changed. Hetzner raised prices more than once, citing the jump in memory and SSD costs driven by AI data-center demand, and other European hosts such as OVHcloud and netcup followed.

Short answer: if your server already runs and its price did not change on your invoice, there is little reason to move: migrating costs time and the alternatives went up too. If you are ordering a new small server, compare before you click. For U.S. users, DigitalOcean is now cheaper than Hetzner's U.S. locations; for lots of RAM on a budget, Hostinger's KVM plans are worth a look if you accept a 24-month prepay.

What actually changed

April 1, 2026: first price adjustment for cloud and dedicated servers, with higher DRAM and NAND costs given as the reason.
June 15, 2026: a further "standardization and price adjustment" of server products, applying to new orders and rescales.
Size of the increase: this is where reporting disagrees. Some articles quote about 10%, while others show individual small plans going up by 30–50%. The difference comes from which plans you compare, so the only number that matters is the one on your invoice. ## Hetzner's current prices (checked November 8, 2026)

Regular Performance cloud servers, monthly, excluding VAT, IPv4 included:

Plan	vCPU	RAM	NVMe	Traffic	Germany/Finland	U.S. (Ashburn, Hillsboro)
CPX02	1	1 GB	20 GB	20 TB	€6.49	–
CPX12	1	2 GB	40 GB	20 TB	€11.99	–
CPX22	2	4 GB	80 GB	20 TB	€19.99	–
CPX11	2	2 GB	40 GB	1 TB	–	€17.99
CPX21	3	4 GB	80 GB	2 TB	–	€32.49

Two things stand out. First, U.S. locations cost roughly three times as much as the cheapest European plan. Second, the cheaper Cost-Optimized line (from €5.99) was marked "currently not available", and some plans showed as temporarily unavailable to order.

Should you move an existing server?

Probably not, unless your bill went up. Before migrating, check:

Your latest invoice. If the price did not change, the increase does not affect you yet.
Do not rescale casually. Resizing a server re-prices it at today's rates.
Migration cost. Moving Postgres, DNS, TLS and deploy scripts takes a weekend for a small app. Saving €2 a month is not worth that; saving €20 might be.

The alternatives

DigitalOcean: best for U.S. users

DigitalOcean's Basic Droplets are priced in dollars with simple monthly billing:

Droplet	vCPU	RAM	SSD	Transfer	Price
Basic	1	512 MiB	10 GiB	500 GiB	$4
Basic	1	1 GiB	25 GiB	1,000 GiB	$6
Basic	1	2 GiB	50 GiB	2,000 GiB	$12

The $6 Droplet matches Hetzner's CPX02 on RAM at a similar price, with U.S. data centers. You get far less included traffic than Hetzner's 20 TB, which only matters for bandwidth-heavy apps.

Hostinger VPS: most RAM per dollar, with a catch

Hostinger's KVM plans give much more memory for the money, but the advertised price requires paying for 24 months up front, and renewal is higher:

Plan	vCPU	RAM	NVMe	Bandwidth	Intro (24-month prepay)	Renewal
KVM 1	1	4 GB	50 GB	4 TB	$6.49/mo	$11.99/mo
KVM 2	2	8 GB	100 GB	8 TB	$8.79/mo	$14.99/mo

If your app needs RAM (Node.js plus Postgres plus a cache), KVM 2 at $8.79 is hard to beat for two years. Budget for the renewal price when you plan the third year.

Vultr

Vultr is another common Hetzner alternative with many U.S. and Asian locations and hourly billing capped at a monthly price. Its regular Cloud Compute plan with 1 vCPU, 1 GB RAM, 25 GB SSD and 1 TB of transfer is listed at $5 a month in most locations, with a 512 MB plan around $2.50 in some regions. A few locations, such as Tokyo, cost slightly more, so check the price for the region you pick at checkout.

For a U.S. audience, that makes Vultr's 1 GB plan the cheapest of the mainstream options here, $1 below DigitalOcean, with less included transfer than Hetzner.

Skip the server entirely: Render or Railway

If the price increase is a good moment to stop managing servers, platforms like Render (about $13/month for the smallest always-on web service plus Postgres) or Railway (from $5/month, usage-based) remove OS updates and patching. I compare them with real prices in Cheapest Way to Host a Node.js + Postgres App in 2026.

Or host from a PC you already own

For side projects, a home PC with Cloudflare Tunnel costs about $3 a month in electricity and domain fees. I ran a production app this way for 12 days before moving it to Google Cloud's free e2-micro VM; here is the setup, the outages and the risks.

Side-by-side: about €6–9 a month

Provider	Plan	vCPU	RAM	Monthly price	Notes
Hetzner	CPX02 (EU)	1	1 GB	€6.49 + VAT	20 TB traffic; EU only at this price
DigitalOcean	Basic 1 GiB	1	1 GiB	$6	U.S. locations, monthly billing
Vultr	Cloud Compute 1 GB	1	1 GB	$5	1 TB transfer; price varies a little by region
Hostinger	KVM 1	1	4 GB	$6.49	24-month prepay, renews at $11.99
Hostinger	KVM 2	2	8 GB	$8.79	24-month prepay, renews at $14.99

How much RAM do you actually need? My own Node.js + PostgreSQL app, a multi-school exam platform, runs on a 1 GB VM using about 520 MB with Postgres tuned down and a 2 GB swap file. So the 1 GB plans above are enough for a small app; pick 2 GB or more only if you add Redis, a search engine or heavier caching.

My verdict

Hetzner is still good value in Europe, especially for traffic-heavy apps, but it is no longer the automatic cheapest choice. For a small Node.js app serving U.S. users, a $6 DigitalOcean Droplet is the simplest replacement. If you need memory and can prepay, Hostinger KVM 2 gives 8 GB for under $9 a month for two years. And if your server's price has not changed, keep it: the cheapest migration is the one you do not need.

As for me, I skipped all of them for now: my app moved from a home laptop to Google Cloud's free e2-micro, and when it outgrows that I will choose by vCPU count, not RAM, because password hashing during logins is my real bottleneck.

Some links are affiliate links; see the disclosure.

Cheapest Way to Host a Node.js + Postgres App in 2026

devstack-blog — Sun, 08 Nov 2026 04:53:07 +0000

Originally published at LeanStack.

Every week someone asks the same question on Reddit: what is the cheapest way to host a Node.js API with a Postgres database that is not a toy? The honest answer depends on how much downtime and maintenance you can accept, so this guide gives you real 2026 prices for five options and tells you which one fits which situation.

Short answer:

About $3/month: a PC you already own + Cloudflare Tunnel (you pay only electricity and the domain). Fast, but you are the ops team. I ran my production app this way for 12 days (full setup here).
$0/month, always on: Google Cloud's free e2-micro, if 1 GB of RAM, a shared CPU and a U.S. region are acceptable. My app runs there now.
About $6/month: one small VPS running both Node.js and Postgres. The cheapest always-on option if you can do basic Linux admin.
About $13/month: Render with a paid web service and database. No servers to manage, predictable bill.
$5 and up: Railway, billed by usage. Great for small, spiky apps; watch the meter.
Free database: Neon's permanent free Postgres pairs well with any of the above.

Quick comparison

Prices checked on November 8, 2026 on each provider's official pricing page. Taxes not included.

Option	Monthly cost	Always on?	You manage	Best for
Home PC + Cloudflare Tunnel	~$3 (electricity + domain)	Only while your PC and internet are up	Everything	Side projects, pilots
Google Cloud e2-micro (Always Free)	$0 within free limits	Yes	OS, Postgres, backups	Low-traffic apps, U.S. regions only
DigitalOcean Droplet 1 GiB	$6	Yes	OS, Postgres, backups	Cheapest reliable always-on
Hetzner CPX02 (EU only)	€6.49 + VAT	Yes	OS, Postgres, backups	EU users
Hostinger KVM 1 (4 GB RAM)	$6.49 intro (24-month prepay), $11.99 renewal	Yes	OS, Postgres, backups	Most RAM per dollar up front
Render web + Postgres	$7 + $6 = $13	Yes	Nothing	No-ops, fixed bill
Railway Hobby	$5 incl. $5 usage, then metered	Yes	Nothing	Small or spiky apps
Neon Free (database only)	$0	Scales to zero after 5 min idle	Nothing	Free Postgres that does not expire

Where these numbers come from

Prices come from each provider's official pricing page and documentation on November 8, 2026; I did not open a paid account on every platform just to collect invoices. The home-PC and small-VM numbers come from my own production app, a multi-school exam platform built with Node.js, Express and PostgreSQL: it ran for 12 days on a laptop at home, and now runs on a 1 GB cloud VM. Where I estimate a bill, I show the math so you can plug in your own usage.

There is also one more $0 option that stays always on: Google Cloud's Always Free e2-micro (2 shared vCPUs, 1 GB RAM, 30 GB standard disk, 1 GB of egress per month from North America) in us-west1, us-central1 or us-east1. That is where my app runs today; the catches are a weak shared CPU and U.S.-only regions.

Option 1: A PC you already own + Cloudflare Tunnel (~$3)

If you have a spare PC or laptop, Cloudflare Tunnel publishes a local app on your domain without opening router ports, and the tunnel is free. My production exam platform ran this way on a laptop CPU from 2016 and handled 1,000 simulated users with zero errors and p95 around 100 ms. Electricity and the domain came to about $3 a month.

The catch is uptime: sleep, Windows Update reboots, power cuts and ISP outages all take your app down, and backups are entirely on you. In 12 days my laptop went to sleep twice and the app was offline for about 12 hours in total. I wrote up the whole setup, the load test and the risks in Hosting a Node.js + Postgres App From a Home PC.

Option 2: One small VPS for both Node.js and Postgres (~$6)

This is the cheapest option that stays online when your laptop is closed. You rent a small Linux server, install Node.js and PostgreSQL on it, and run your app with a process manager like PM2 or systemd.

What you get for about $6 a month:

Provider	Plan	vCPU	RAM	Disk	Traffic	Price
DigitalOcean	Basic Droplet	1	1 GiB	25 GiB SSD	1,000 GiB	$6
Hetzner	CPX02 (Germany/Finland)	1	1 GB	20 GB NVMe	20 TB	€6.49 + VAT
Hostinger	KVM 1	1	4 GB	50 GB NVMe	4 TB	$6.49 intro, $11.99 renewal

Things the price tables do not tell you:

Hetzner's US locations cost much more. The cheapest cloud plan in Ashburn or Hillsboro was CPX11 at €17.99/month when I checked, versus €6.49 for CPX02 in Europe. If your users are in the U.S., latency to Germany matters.
Hostinger's $6.49 requires paying 24 months up front, and the plan renews at $11.99/month.
1 GB of RAM is tight for Node.js plus Postgres. It works for small apps if you lower Postgres memory settings and add a swap file; 2 GB is more comfortable (DigitalOcean's 2 GiB Droplet is $12).

How tight is 1 GB in practice? My app runs on a 1 GB VM (Google Cloud's free e2-micro) with Node.js in cluster mode (2 workers), PostgreSQL 16 and cloudflared. With Postgres set to shared_buffers = 128MB and max_connections = 40, plus a 2 GB swap file, free -m shows:

               total        used        free      shared  buff/cache   available
Mem:             969         519         373          26         239         450
Swap:           2047          32        2015

About half the RAM is used and swap is barely touched, so 1 GB is enough for a small app if you tune Postgres down. It will not be enough if you add Redis, a search engine or a big in-memory cache.

Do not skip backups on a VPS. A cron job running pg_dump to another machine or cloud storage every night is the minimum. Most providers also sell automatic server snapshots for a small extra fee.

Option 3: Render (~$13, fully managed)

Render runs your app from a Git repo and handles TLS, deploys and restarts. The Hobby workspace itself is free; you pay per service:

Render service	Specs	Price
Web service (free)	512 MB	$0, spins down after 15 min idle
Web service	0.5 CPU, 512 MB	$7/month
Postgres (free)	256 MB, 1 GB storage	$0, expires after 30 days
Postgres	0.1 CPU, 256 MB	$6/month + $0.30 per GB storage

So the realistic floor for an always-on app with a database you keep is $13/month. The free tier is fine for demos, but two details bite people:

A free web service sleeps after 15 minutes without traffic and takes about a minute to wake up.
A free Postgres database expires 30 days after creation. You get a 14-day grace period to upgrade; after that Render deletes it, data included.

Render's docs put the wake-up at about a minute, and community reports go higher for bigger apps. Since February 2026, a free service also stays awake while it receives WebSocket messages, not only HTTP requests. Free services lose any files written to local disk when they spin down, so keep uploads in a database or object storage.

Option 4: Railway (from $5, usage-based)

Railway bills by the second for the resources your services actually use. The Hobby plan costs $5/month and includes $5 of usage. Beyond that:

Memory: about $10 per GB per month
CPU: about $20 per vCPU per month
Volume storage (for Postgres data): about $0.15 per GB per month
Egress: $0.05 per GB

You can estimate your bill as average RAM (GB) × $10 + average CPU (vCPU) × $20 + storage. An app and database that together average a few hundred MB of RAM and little CPU can stay close to the $5 included credit. A busy app, or one with a memory leak, will not.

A worked example using my own app's real footprint: Node.js plus Postgres use about 0.5 GB of RAM together and almost no CPU when idle. On Railway that is roughly 0.5 GB × $10 = $5 for memory, plus perhaps 0.05 vCPU × $20 = $1 for CPU, plus 1 GB of Postgres volume at $0.15. That is about $6.15 a month, or $1.15 above the included $5. An exam with 1,000 students logging in at once would push CPU, and the bill, up for that hour.

There is also a free plan with $1 of usage per month and a one-time $5 trial credit, which is enough to try it but not to run anything permanent.

Option 5: A free managed database with Neon

If the database is what pushes you onto a paid plan, Neon offers serverless Postgres with a permanent free plan:

100 compute-hours per project per month (autoscaling up to 2 compute units)
1 GB storage per project (20 GB across up to 100 projects)
Scales to zero after 5 minutes idle, which adds a short delay on the first query after a pause

The paid Launch plan has no monthly minimum: $0.106 per compute-hour and $0.35 per GB-month of storage. Neon's own estimate for a small database with intermittent load is about $15/month.

A common cheap combination: Node.js on Render's free web service or a small VPS, with the database on Neon's free plan. Just remember both the free web service and the free database go to sleep, so the first request after a quiet period is slow.

How slow is slow? Neon describes its cold starts as subsecond, around 500 ms on average, which is far less painful than Render's one-minute wake-up. Still, set your Postgres client's connection timeout to a few seconds (the pg default is no timeout, but many ORMs use shorter ones) so the first query after a pause does not fail.

Which one should you choose?

Learning, demo or early pilot: home PC + Cloudflare Tunnel, or Render free + Neon free. Accept the sleeps and the downtime.
First paying users, and you know some Linux: a $6 VPS (DigitalOcean for U.S. users, Hetzner for Europe) with nightly pg_dump backups. Cheapest always-on option by far.
You never want to SSH into a server: Render at about $13/month for a fixed, predictable bill.
Small app with uneven traffic: Railway, as long as you check the usage graph in the first weeks.
Database is the expensive part: move it to Neon's free plan first and see if that is enough.

My own path: I started on a home laptop at about $3 a month, then moved to Google Cloud's free e2-micro once sleep-related outages started to matter. When my exams outgrow it, I will pay for a VPS with 2–4 vCPUs rather than a managed platform, because my bottleneck is password hashing, and that needs cores, not convenience.

Common problems

"My free database disappeared." Render free Postgres expires after 30 days. Export it with pg_dump before then or move to a paid plan.
"The first request takes 30–60 seconds." That is a sleeping free web service waking up. Pay for an always-on instance, or use a VPS.
"My VPS bill went up." Many providers repriced in 2026, and intro prices like Hostinger's renew higher. Check the renewal price before you prepay.
"Out of memory on a 1 GB VPS." Lower Postgres shared_buffers and max_connections, add a 1–2 GB swap file, or move up to 2 GB RAM.

Some links are affiliate links; see the disclosure.

Hosting a Node.js + Postgres App From a Home PC (Real Costs)

devstack-blog — Sun, 08 Nov 2026 04:53:00 +0000

Originally published at LeanStack.

Hosting a small web app does not have to start with a monthly bill. For 12 days, from October 26 to November 8, 2026, my production app – a multi-school online exam platform built with Node.js, PostgreSQL and Vue – ran on a Windows laptop at home, reachable on its own domain through Cloudflare Tunnel. Then I moved it to a free cloud VM.

Short answer: if your app is small, your users can tolerate the occasional outage, and you are comfortable doing your own backups, a home PC plus Cloudflare Tunnel costs about $3 a month and performs better than you would expect. Once real money or fixed-schedule exams depend on uptime, move to a server that never sleeps.

This guide shows exactly how my setup worked, the load numbers I measured, what it really cost, the two outages I had, and what I moved to.

Why I ended up hosting at home

I planned to use a free cloud VM, but my sign-up for Oracle Cloud's free tier was rejected. Paid VPS prices also went up across the market in 2026 (Hetzner alone changed prices several times), so I tried the cheapest option I had: the laptop I already owned.

The app was already running on that laptop for development, with portable Node.js and PostgreSQL. Going live meant installing one more program, cloudflared, and pointing the domain at it. It took an evening.

The setup at a glance

Part	What I used	Cost
Server	Dell Inspiron 7460 laptop, Windows 10, Intel Core i7-7500U (2 cores / 4 threads), 8 GB RAM	Already owned
Runtime	Portable Node.js 22 and portable PostgreSQL (no Docker, no WSL)	Free
Public access	Cloudflare Tunnel (`cloudflared`), domain on Cloudflare DNS	Free tunnel; a `.vn` domain renews at about 470,000 VND (~$18) a year
Multi-tenant subdomains	Wildcard DNS `*.yourdomain` routed through the same tunnel	Free
Email	Gmail SMTP with an App Password	Free (daily sending limit)
Backups	`pg_dump` before every database migration	Free

How Cloudflare Tunnel works (and why it beats port forwarding)

A tunnel flips the usual model. Instead of opening a port on your router and pointing DNS at your home IP, a small program called cloudflared runs on your PC and opens an outbound connection to Cloudflare. Visitors hit Cloudflare, and Cloudflare sends the request down that connection to your local app.

That gives you three things for free:

No open ports. Your router stays closed; nothing scans your home IP.
HTTPS handled for you. Cloudflare terminates TLS with its own certificate.
A stable address. It does not matter if your ISP changes your home IP.

I created the tunnel in the dashboard (Zero Trust → Networks → Tunnels), copied its token, and installed cloudflared as a Windows service from an Administrator prompt, so it starts with Windows even before anyone logs in:

cloudflared.exe service install <YOUR_TUNNEL_TOKEN>

In the tunnel's Public Hostname settings, both yourdomain.com and *.yourdomain.com point to http://localhost:3000. The wildcard is what lets every school get its own subdomain without touching DNS again.

Making Node.js use the whole CPU

A single Node.js process uses one CPU core. On a 4-thread laptop CPU that leaves most of the machine idle, so the app starts through Node's built-in cluster module with one worker per CPU thread:

import cluster from 'node:cluster';
import os from 'node:os';

if (cluster.isPrimary) {
  for (let i = 0; i < os.availableParallelism(); i++) cluster.fork();
  cluster.on('exit', () => cluster.fork()); // restart a crashed worker
} else {
  await import('./index.js'); // the normal Express server
}

One catch: each worker has its own in-memory cache. When an admin changes something, the other workers do not know. I solved it with PostgreSQL's built-in LISTEN/NOTIFY: the worker that writes sends a notification, and every worker clears that cache key. No Redis needed.

Two more settings mattered behind Cloudflare:

Turn off gzip in Node. Cloudflare already compresses responses, and compressing in Node competes with password hashing for the same thread pool.
Trust the proxy. Set Express trust proxy so rate limits and logs see the visitor's IP, not Cloudflare's.

Real load test: 1,000 users on a 2016 laptop CPU

Exams are the worst case for my app: hundreds of students arrive in the same minute, then save answers every few seconds. My load-test script simulates exactly that: each virtual user opens the exam, saves a draft three times, submits, and opens the results and the leaderboard. The database and the load generator ran on the same laptop as the app, so the numbers are on the pessimistic side.

First run, a single Node.js process, 1,000 users arriving over 30 seconds:

Scenario	Result
1,000 guests taking a password-protected exam	1,000/1,000 completed, 0 errors. p95: open exam 92 ms, save draft 100 ms, submit 95 ms
1,000 students registering, then taking the exam	1,000/1,000 completed, 0 errors, but median registration took about 9 seconds

The surprise was where the limit sits. It is not the database or Express; it is password hashing. Each scrypt hash takes around 80–100 ms of CPU on purpose (that is what makes stolen hashes expensive to crack). On two physical cores that caps the machine at roughly 20–25 logins per second, so a burst of 1,000 logins queues up no matter how fast the rest of the app is.

Switching to cluster mode (4 workers) and replaying 1,000 student logins over 20 seconds showed the trade-off clearly:

Hashes per worker at once	Median login	Median for every other page
1	17 s	60 ms
2	13 s	300 ms

I kept one hash per worker: logins wait a bit longer, but students already in the exam stay fast. The practical fix is operational, not technical: ask students to log in 5–10 minutes before the exam (sessions last 7 days), and if you expect bigger spikes, you need more cores, not a faster database.

PostgreSQL itself needed only light tuning: I raised shared_buffers to 512 MB with ALTER SYSTEM (a restart is required) and pointed the app at 127.0.0.1 instead of localhost to skip a DNS lookup on Windows.

What it really costs per month

Item	Monthly cost
Hardware	$0 (already owned)
Electricity	About 11 kWh (a laptop averaging ~15 W × 24 h × 30 days). At Vietnam's household rates from November 2026 (1,901–3,844 VND/kWh plus 10% VAT), that is 23,000–46,000 VND, roughly $1–2
Internet	$0 extra (existing home plan; I measured about 30 Mbit/s upload, plenty for an API)
Cloudflare Tunnel + DNS	$0
Domain	About $1.50 (~$18 a year for a `.vn`; a `.com` at Cloudflare Registrar is cheaper)
Total	About $3 a month

For comparison, the cheapest VPS options I checked on November 8, 2026:

Provider	Plan	Specs	Price/month
DigitalOcean	Basic Droplet	1 vCPU, 1 GiB RAM, 25 GiB SSD	$6
Hetzner	CPX02 (EU)	1 vCPU, 1 GB RAM, 20 GB NVMe	€6.49 (+VAT)
Hostinger	KVM 1	1 vCPU, 4 GB RAM, 50 GB NVMe	$6.49 intro with 24-month prepay, renews at $11.99

None of those 1-vCPU plans would match the 4 threads of an old laptop CPU for the login-heavy workload above.

The risks nobody mentions (and the ones that hit me)

Home hosting is cheap because you are the operations team. These are the risks to plan for:

Sleep, not power cuts, took my app down. A laptop battery is a built-in UPS, and cloudflared ran as a Windows service while the app started from a shortcut in the Startup folder. But the laptop's power plan still allowed sleep, and it went to sleep twice: 43 minutes on the morning of October 28 and about 11 hours overnight on November 7. That is roughly 12 hours of downtime in 12 days, or about 96% uptime. Set sleep to Never on both battery and AC on day one (powercfg /change standby-timeout-ac 0 and standby-timeout-dc 0), and set Windows Update active hours so it does not reboot during exams.
Startup folder is not a service. A shortcut in the Startup folder only runs after a user logs in. After an unattended reboot, the tunnel service would come back on its own but the app would not until someone signed in. Use Task Scheduler ("At startup") or a service wrapper instead.
Internet outages. Your uptime equals your ISP's uptime. My connection did not drop once in those 12 days, but I had no plan B if it had.
Backups are your job. I took a pg_dump -Fc before every migration and kept copies in a separate folder. A dead disk with no off-site copy means lost data.
Deploys without downtime. Building the frontend straight into the live folder causes a few seconds of 404s. I build into a new folder and swap it in.
Terms of service. Some residential ISPs forbid running servers, and Cloudflare's terms limit serving large media through the free plan. Check both before you rely on this.
Security. Only the app is published through the tunnel, never Remote Desktop or the database port. If you add an admin tool, protect it with Cloudflare Access.

When to move to a VPS (or a managed platform)

Stay on the home PC while the app is a side project or an early pilot. Move when any of these become true:

People pay you, or exams run on a fixed schedule. An hour of downtime now costs money or trust.
You travel or cannot reach the PC quickly to wake it up or fix a crash.
You need more than one machine, for example a separate database server.

The simplest next step is a small VPS: copy the same Node + Postgres setup, keep Cloudflare Tunnel (it works the same on Linux), and nothing changes for your users. A DigitalOcean Droplet or a Hetzner server is enough for an app of this size; check the CPU count if logins are your bottleneck like mine.

If you would rather not manage a server at all, platforms like Railway or Render run the app for you, and Neon offers managed Postgres with a free tier. You trade a higher monthly bill for no maintenance. I compare these options with real prices in Cheapest Way to Host a Node.js + Postgres App in 2026.

What I moved to: Google Cloud's free e2-micro

After the 11-hour outage I moved the app to Google Cloud's Always Free e2-micro VM in Oregon (us-west1): 2 shared vCPUs, 1 GB RAM and a 30 GB standard persistent disk, all inside the free allowance. Moving took a few hours, one night:

Debian 12 with PostgreSQL 16 and Node.js 22, plus a 2 GB swap file because 1 GB of RAM is tight.
Postgres scaled down for the small machine: shared_buffers = 128MB, max_connections = 40.
The same Cloudflare Tunnel, so the VM has no open web ports either. Switching over was: uninstall the tunnel service on the laptop, restore the last pg_dump on the VM, start the tunnel there.

With the app, Postgres and cloudflared running, free -m on the VM shows 519 MB used of 969 MB, with 32 MB of swap in use and 4.8 GB of the 30 GB disk used. The trade-offs: the e2-micro's CPU is shared and much weaker than the laptop for a burst of logins, Oregon is far from my users in Vietnam, and only 1 GB of egress per month is free, so Cloudflare's caching matters. For now, an app that never sleeps beats an app that is fast but sometimes offline.

My verdict

For a small Node.js + PostgreSQL app, a home PC with Cloudflare Tunnel is a legitimate way to start, not just a toy: about $3 a month, secure by default, and fast enough for 1,000 simulated students on a laptop CPU from 2016. The trade-off is that uptime and backups are entirely on you. Start here, measure, and move the day an outage would cost more than the server.

Would I do it again? Yes: 12 days at home showed me my real bottleneck (password hashing, not the database) before I paid for anything. The first thing I would change is disabling sleep on day one; it caused all of my downtime.

Some links are affiliate links; see the disclosure.