From Zero to Live: How I Deploy 5 Apps on a Single VPS

From Zero to Live: How I Deploy 5 Apps on a Single $5 VPS

Yes, you read that right. Five separate applications running on one cheap server. Here's my exact setup.

Why One Server?

When I started building side projects, I made the mistake every beginner makes:

One Heroku app per project = $7-14/month each

After 4 projects, I was paying $56/month for apps that had zero users. That's when I discovered the magic of a single VPS:

$5/month total (not per app)
Full control over everything
Skills you'll use forever (Linux, Nginx, systemd)
Unlimited apps (within resource limits)

Here's how I run 5 applications on one server.

The Hardware

I'm using a Tencent Cloud Lighthouse instance (similar to DigitalOcean Droplet):

CPU:    2 cores
RAM:    4GB
Disk:   60GB SSD
Bandwidth: 1TB/month
Cost:   ~$5/month

Any provider works: DigitalOcean, Linode, Hetzner, Vultr — pick whatever has a data center close to your users.

If you don't have a server yet, DigitalOcean gives you $200 in credits for new accounts. That's 40 months free.

The Architecture

                    ┌─────────────────┐
                    │   Cloudflare    │
                    │  (CDN + HTTPS)  │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │     Nginx       │
                    │  (Reverse Proxy)│
                    └───────┬┬───────┘
                            │ │
         ┌──────────────────┘ └──────────────────┐
         │                                         │
  ┌──────▼──────┐                        ┌────────▼────────┐
  │  App 1      │                        │  App 2          │
  │  (:3000)    │                        │  (:3001)        │
  │  Main site  │                        │  Signal service │
  └─────────────┘                        └─────────────────┘
  ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼──────┐
  │  App 3      │  │  App 4      │  │  App 5      │
  │  (:3099)    │  │  Static     │  │  Room UI    │
  │  Formatter  │  │  Blog/Hugo  │  │  Dashboard  │
  └─────────────┘  └─────────────┘  └─────────────┘

The secret sauce: Nginx routes traffic by URL path to different backend ports. Each app thinks it has its own server.

Step 1: Install the Basics

# Update system
sudo apt update && sudo apt upgrade -y

# Install Nginx
sudo apt install nginx -y

# Install Node.js (via nvm)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install --lts

# Install Git
sudo apt install git -y

That's it. That's your entire stack.

Step 2: SSL Certificate (Free)

Every app needs HTTPS. Here's the easiest way:

# Install Certbot
sudo apt install certbot python3-certbot-nginx -y

# Get certificate (replace with your domain)
sudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Certbot auto-configures Nginx for HTTPS and sets up auto-renewal. Your certificates will never expire.

Pro tip: Put Cloudflare in front of your domain for extra DDoS protection and a free CDN. Set SSL mode to "Full (Strict)" in Cloudflare dashboard.

Step 3: App #1 — Node.js Web App

Let's say you have a simple Express app:

// server.js
const express = require('express');
const app = express();
const PORT = 3000;

app.get('/api/health', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

app.listen(PORT, '127.0.0.1', () => {
  console.log(`App running on port ${PORT}`);
});

Keep It Alive with systemd

Create /etc/systemd/system/yourapp.service:

[Unit]
Description=Your Application
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/your-app
ExecStart=/home/ubuntu/.nvm/versions/node/v22.22.1/bin/node server.js
Restart=always
RestartSec=10
Environment=NODE_ENV=production

[Install]
WantedBy=multi-user.target

Critical detail: Use the FULL path to node from nvm (which node gives you this). Systemd doesn't load your shell profile.

sudo systemctl enable yourapp
sudo systemctl start yourapp
sudo systemctl status yourapp  # Should show "active (running)"

Step 4: Nginx Reverse Proxy

This is where the magic happens. Edit your Nginx config:

server {
    listen 443 ssl http2;
    server_name yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    # Main app → port 3000
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Second app → port 3001
    location /signal/ {
        proxy_pass http://127.0.0.1:3001/;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Test and reload:

sudo nginx -t            # Check syntax
sudo systemctl reload nginx

Result: yourdomain.com/ serves App 1, yourdomain.com/signal/ serves App 2. Both on HTTPS, both on one server.

Step 5: Add a Static Site (Hugo Blog)

For static sites (blog, docs, landing pages), no need for a Node.js process:

# Install Hugo
hugo_version="0.146.0"
curl -L -o hugo.tar.gz \
  "https://github.com/gohugoio/hugo/releases/download/v${hugo_version}/hugo_${hugo_version}_linux-amd64.tar.gz"
tar -xzf hugo.tar.gz && sudo mv hugo /usr/local/bin/

# Create site
hugo new site my-blog && cd my-blog
git submodule add https://github.com/adityatelange/hugo-PaperMod themes/PaperMod

# Configure (hugo.toml):
# baseURL = "https://yourdomain.com/blog/"
# theme = 'PaperMod'

# Write a post
hugo new content posts/my-first-post.md

# Build
hugo --minify
# Output is in public/

Add to Nginx:

    location /blog {
        alias /path/to/my-blog/public;
        index index.html;
        try_files $uri $uri/ /blog/index.html;
    }

Static sites consume almost zero RAM. You could host 50 of them and not notice.

Step 6: Security Basics

You're exposed to the internet now. Lock it down:

Firewall

sudo ufw allow 22/tcp    # SSH
sudo ufw allow 80/tcp    # HTTP
sudo ufw allow 443/tcp   # HTTPS
sudo ufw enable

Fail2Ban

sudo apt install fail2ban -y
sudo systemctl enable fail2ban

Automatically bans IPs after too many failed login attempts.

Rate Limiting in Nginx

# In http block:
limit_req_zone $binary_remote_addr zone=general rate=10r/s;
limit_req_zone $binary_remote_addr zone=login rate=5r/m;

# In location block:
location /api/auth/ {
    limit_req zone=login burst=5 nodelay;
    proxy_pass http://127.0.0.1:3000;
}

Security Headers

add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;

My Actual Resource Usage

After running all 5 apps for 6 months:

Total RAM:  4GB
Used:       ~2.2GB (55%)
Free:       ~1.8GB

Total Disk: 60GB  
Used:       ~37GB (62%)
Free:       ~23GB

CPU Load:   0.05-0.15 (basically idle)

I'm using half my resources. Room for plenty more apps.

Cost Breakdown

Item	Cost/Month
VPS (2C/4G/60G)	$5
Domain (.cc TLD)	$8/year ≈ $0.67
SSL	$0 (Let's Encrypt)
CDN	$0 (Cloudflare Free)
Total	~$5.67/month

Compare that to running 5 separate Heroku dynamos ($7 × 5 = $35/month), and you're saving 85%.

What I'd Do Differently

Set up monitoring from day one. I didn't learn about UptimeRobot until an app was down for 3 days without me noticing.
Use Docker from the start. Makes deploying new apps much easier (though raw Node.js works fine for simple cases).
Automate deployments. Right now I SSH in and pull manually. A simple CI/CD pipeline would save time.
Back up automatically. I learned this the hard way after losing a database. Now I have daily automated backups to object storage.

Go Forth and Deploy

You don't need Kubernetes. You don't need AWS. You don't need a DevOps team.

You need:

One $5 VPS
Nginx
Basic Linux knowledge
A willingness to Google error messages

Everything I run today started exactly like this. Small, cheap, imperfect — but live and learning.

What are you building? Drop a comment — I'd love to hear what you're working on.

New here? Follow @armorbreak for more practical guides like this.

推荐订阅源

DEV Community