How to deploy a Node.js app on Vultr in 2026: plan, setup, SSL

You've got a Node.js app that runs on your laptop and you want it on the internet, on a server you control, without paying platform prices. Here's the whole path on Vultr: pick the plan, lock the server down, run Node under a process manager, put Nginx in front and add free SSL.

Prices as of 2026-09-22.

The short answer

Start on Vultr's High Frequency 1GB at $6/mo (1 vCPU, 1 GB RAM, 32 GB NVMe, 1 TB transfer). Install Ubuntu LTS, create a non-root user, turn on a firewall, install Node through a version manager, run the app with PM2, put Nginx in front as a reverse proxy and get a Let's Encrypt certificate. Move up to Regular 2GB ($10) or Regular 4GB ($20) when memory, not CPU, starts running out.

Which Vultr plan for a Node app

Plan	Price	vCPU	RAM	Storage	Good for
High Frequency 1GB	$6/mo	1	1 GB	32 GB NVMe	Most new apps and APIs
Regular 2GB	$10/mo	1	2 GB	55 GB SSD	App plus Postgres on one box
Regular 4GB	$20/mo	2	4 GB	80 GB SSD	Real traffic, clustered Node
Regular 8GB	$40/mo	4	8 GB	160 GB SSD	Several services, busy database

Node runs your JavaScript on a single thread, so one process uses one core. Extra cores only help if you run several processes, which PM2's cluster mode makes easy. For most early apps, memory is what runs out first, especially once a database sits on the same server. That's why the jump we'd usually make is from 1 GB to 2 GB, not to more cores.

If you're choosing a region, pick the one closest to your users. Vultr's 32 regions are the main reason to use it over cheaper options. If your users are in Europe and price matters more than location, compare Hetzner vs Vultr first.

Step 1: create the server

In the Vultr console, deploy a new instance:

• Type: Cloud Compute, High Frequency (or Regular if you prefer the $5 plan).
• Location: nearest to your users. Check that the plan includes IPv4 in that region if you need it; some of the cheapest plans are IPv6-only in certain locations.
• Image: Ubuntu LTS.
• SSH key: add your public key now. Don't rely on a root password.

Note the server's IP address once it's running.

Step 2: lock the server down

Log in as root once, create a normal user and give it sudo:

```

ssh root@YOUR_SERVER_IP

adduser deploy

usermod -aG sudo deploy

rsync --archive --chown=deploy:deploy ~/.ssh /home/deploy

```

Then turn off root and password logins. Edit /etc/ssh/sshd_config and set:

```

PermitRootLogin no

PasswordAuthentication no

```

Restart SSH with systemctl restart ssh, and before closing your current session, check you can log in as deploy from a second terminal.

Turn on the firewall, allowing only SSH and web traffic:

```

sudo ufw allow OpenSSH

sudo ufw allow 'Nginx Full'

sudo ufw enable

```

(The Nginx rule will exist once Nginx is installed in step 4. If ufw complains, allow ports 80 and 443 directly.)

Finally, install updates: sudo apt update && sudo apt upgrade -y.

Step 3: install Node and run your app with PM2

Install Node through nvm, so upgrading later is one command:

```

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash

source ~/.bashrc

nvm install --lts

```

Get your code onto the server. The simplest way is to clone from Git:

```

git clone https://github.com/you/your-app.git

cd your-app

npm ci --omit=dev

```

Put secrets in environment variables, not in the repo. A .env file readable only by deploy is fine at this size.

Now install PM2 and start the app. PM2 restarts it if it crashes and brings it back after a reboot:

```

npm install -g pm2

pm2 start server.js --name my-app

pm2 save

pm2 startup

```

pm2 startup prints a command; run it, and the app now survives reboots. On a plan with more than one core, start in cluster mode instead: pm2 start server.js -i max --name my-app.

Check it's listening locally, for example with curl http://localhost:3000.

Step 4: put Nginx in front

Your app listens on a local port. Nginx takes public traffic on ports 80 and 443 and passes it to Node. It also handles SSL and serves static files better than Node does.

```

sudo apt install nginx -y

```

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

```

server {

listen 80;

server_name example.com www.example.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_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

proxy_set_header X-Forwarded-Proto $scheme;

}

}

```

Enable it and reload:

```

sudo ln -s /etc/nginx/sites-available/my-app /etc/nginx/sites-enabled/

sudo nginx -t

sudo systemctl reload nginx

```

Point your domain's A record (and AAAA, if you use IPv6) at the server. Our Nginx install guide covers more configuration if you need it.

Step 5: free SSL with Let's Encrypt

```

sudo apt install certbot python3-certbot-nginx -y

sudo certbot --nginx -d example.com -d www.example.com

```

Certbot edits your Nginx config, gets the certificate and sets up automatic renewal. Test renewal with sudo certbot renew --dry-run. The Let's Encrypt guide explains what's happening under the hood.

Step 6: deploys, backups and monitoring

Deploying updates. At this size, a short script is enough: git pull, npm ci --omit=dev, pm2 reload my-app. pm2 reload restarts without dropping connections in cluster mode.

Backups. Vultr's automatic backups are a paid add-on priced relative to the instance; check the current rate on Vultr's pricing page. If your database lives on this server, either turn backups on or set up your own off-site copies. See automated backups on any VPS.

Monitoring. Watch memory first. If pm2 monit or free -m shows you regularly near the limit, resize up a plan. Our VPS monitoring guide covers free uptime and resource alerts.

When to resize, and when to look elsewhere

Resize to Regular 2GB when memory pressure shows up, which usually happens when you add Postgres or Redis to the same box. Go to Regular 4GB when you have enough traffic to want two Node processes and room for the database.

If you outgrow one server, split the database onto its own instance before buying a much bigger one. And if you find you don't need Vultr's region coverage, it's worth knowing that Hetzner's CX22 gives you 2 vCPU and 4 GB of RAM for $4.60, against $20 for the Vultr Regular 4GB. Our general Node.js API hosting guide compares the options across providers.

Related guides

• Vultr pricing explained: plan-by-plan costs and add-ons.
• The Vultr $300 credit explained: test this whole setup free for a month.
• How to install Docker on any Linux VPS: if you'd rather containerise.
• DigitalOcean vs Vultr: the closest alternative.

Prices as of 2026-09-22.