Node.js Deploying Applications

Deployment is the process of making a Node.js application available to real users over the internet. Building an application locally is only the first step — deployment moves it to a server or cloud platform where it runs continuously and can handle real-world traffic. This topic covers the key steps, best practices, and common deployment platforms for Node.js applications.

Pre-Deployment Checklist

Before deploying, the following should be in order:

• Environment variables: All secrets are in environment variables, not hardcoded in the source code.
• Error handling: All routes and async operations have proper error handling.
• Security headers: Middleware like helmet is used to set important HTTP security headers.
• .gitignore: The .env file and node_modules/ are excluded from version control.
• package.json start script: A "start" script is defined that runs the main entry file.
• PORT from environment: The server listens on process.env.PORT, not a hardcoded number.
• Production dependencies only: Dev dependencies are separated with --save-dev.

Preparing the Application for Production

Installing the helmet Package

npm install helmet

const express = require('express');
const helmet = require('helmet');

const app = express();

// Add important security headers automatically
app.use(helmet());

// ... rest of your routes

Setting NODE_ENV to Production

// Set in the hosting platform's config, or start script:
NODE_ENV=production node app.js

Express automatically enables performance optimizations (like caching view templates) when NODE_ENV is set to 'production'.

A Production-Ready app.js Template

require('dotenv').config();
const express = require('express');
const helmet = require('helmet');

const app = express();

// Security
app.use(helmet());

// Body parsing
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.use('/api/users', require('./routes/users'));
app.use('/api/products', require('./routes/products'));

// Global error handler
app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(err.statusCode || 500).json({
    error: process.env.NODE_ENV === 'production'
      ? 'Internal Server Error'
      : err.message
  });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running in ${process.env.NODE_ENV} mode on port ${PORT}`);
});

Deployment Option 1 – Railway (Beginner-Friendly)

Railway is one of the easiest platforms to deploy Node.js apps. It detects the project automatically and manages the infrastructure.

1. Push the code to a GitHub repository.
2. Go to https://railway.app and sign in with GitHub.
3. Click New Project → Deploy from GitHub Repo.
4. Select the repository. Railway detects it is a Node.js app.
5. Add environment variables under the Variables tab.
6. Railway automatically runs npm install and then npm start.
7. A live URL is provided (e.g., https://my-app.railway.app).

Deployment Option 2 – Render

Render is a cloud platform with a generous free tier for Node.js web services.

1. Push the code to GitHub.
2. Go to https://render.com and sign up.
3. Click New → Web Service and connect the GitHub repository.
4. Set the build command: npm install
5. Set the start command: node app.js or npm start
6. Add environment variables in the Environment section.
7. Click Create Web Service. Render builds and deploys the app.

Deployment Option 3 – Heroku

Steps to Deploy on Heroku

# Install Heroku CLI, then:
heroku login

# Create a new Heroku app
heroku create my-node-app

# Set environment variables
heroku config:set NODE_ENV=production
heroku config:set JWT_SECRET=mySuperSecretKey
heroku config:set DB_URI=mongodb+srv://...

# Deploy via Git
git push heroku main

# Open the app in the browser
heroku open

Heroku reads the "start" script from package.json to start the application. A Procfile (optional) can also specify the startup command:

# Procfile (no file extension)
web: node app.js

Deployment Option 4 – VPS (Virtual Private Server)

For full control, a VPS (like a DigitalOcean Droplet or AWS EC2 instance) can host the application.

Basic VPS Deployment Steps

# On the VPS, install Node.js
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs

# Clone the project
git clone https://github.com/username/my-app.git
cd my-app

# Install dependencies
npm install --omit=dev

# Set environment variables
export PORT=3000
export NODE_ENV=production
export DB_URI=...

# Start the app
node app.js

Keeping the App Running with PM2

Without a process manager, the Node.js app stops when the terminal session ends. PM2 keeps it running:

npm install -g pm2

# Start the application
pm2 start app.js --name "my-app"

# Make it restart automatically after a server reboot
pm2 startup
pm2 save

# Monitor the app
pm2 monit

# View logs
pm2 logs my-app

Setting Up Nginx as a Reverse Proxy

Nginx sits in front of Node.js and forwards traffic to it, enabling HTTPS, load balancing, and better security:

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

server {
    listen 80;
    server_name my-domain.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;
    }
}

Adding HTTPS with Let's Encrypt (Free SSL)

sudo apt install certbot python3-certbot-nginx

# Issue a free SSL certificate
sudo certbot --nginx -d my-domain.com

# Certbot automatically updates the Nginx config for HTTPS

Continuous Deployment with GitHub Actions

Automated deployment on every push to the main branch can be set up using GitHub Actions:

# .github/workflows/deploy.yml

name: Deploy to Server

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Deploy via SSH
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /var/www/my-app
            git pull origin main
            npm install --omit=dev
            pm2 restart my-app

Platform Comparison

Key Points

• Before deploying, ensure environment variables are set correctly, error handling is in place, and security headers are applied using helmet.
• Always listen on process.env.PORT — hosting platforms set this automatically.
• Railway and Render are the easiest platforms for deploying Node.js applications with minimal setup.
• For VPS deployment, PM2 keeps the application running persistently and restarts it after server reboots.
• Nginx acts as a reverse proxy in front of Node.js, enabling HTTPS, static file serving, and better security.
• Let's Encrypt provides free SSL certificates for enabling HTTPS on custom domains.
• GitHub Actions can automate deployment so every push to the main branch triggers a new deployment.
• Deploying an application is the final step — but maintaining it (monitoring, logging, updating dependencies) is an ongoing responsibility.