1. Introduction 👋

Writing a working Node.js application is only half the job — getting it running reliably in production is the other half. This tutorial covers the full deployment lifecycle: build processes, containerization, orchestration, CI/CD, monitoring, and zero-downtime deployment strategies.

2. Preparing for Production 🧳

Before deploying, an application should be audited against a production readiness checklist.

3. Production Build 🔨

For TypeScript projects, compile source into plain JavaScript before deploying — never ship ts-node or run .ts files directly in production.

npm run build
node dist/index.js

{
  "scripts": {
    "build": "tsc -p tsconfig.build.json",
    "start": "node dist/index.js"
  }
}

4. Environment Configuration ⚙️

Configuration should vary only through environment variables, never through code branches per environment.

interface Config {
  port: number;
  env: "development" | "staging" | "production";
  databaseUrl: string;
}

export const config: Config = {
  port: Number(process.env.PORT ?? 3000),
  env: (process.env.NODE_ENV as Config["env"]) ?? "development",
  databaseUrl: process.env.DATABASE_URL as string,
};

5. Process Managers 🧑‍✈️

Process managers keep a Node.js application running, automatically restarting it on crashes and managing logs.

6. PM2 🔄

PM2 is a popular process manager for Node.js, offering clustering, auto-restart, and built-in log management.

npm install pm2 -g
pm2 start dist/index.js --name my-app -i max
pm2 save
pm2 startup

{
  "apps": [
    {
      "name": "my-app",
      "script": "dist/index.js",
      "instances": "max",
      "exec_mode": "cluster",
      "env": { "NODE_ENV": "production" }
    }
  ]
}

7. Docker 🐳

Docker packages an application with its runtime and dependencies into a portable, reproducible container image.

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
ENV NODE_ENV=production
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=builder /app/dist ./dist
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

8. Docker Compose 🧱

Docker Compose defines multi-container applications (app, database, cache) declaratively for local development or simple deployments.

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db
  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_PASSWORD=pass
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:

docker compose up -d

9. Kubernetes ☸️

Kubernetes orchestrates containers at scale, handling scheduling, scaling, self-healing, and rolling updates automatically.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: myregistry/my-app:1.0.0
          ports:
            - containerPort: 3000
          readinessProbe:
            httpGet: { path: /health, port: 3000 }
          resources:
            limits: { memory: "256Mi", cpu: "500m" }

10. Nginx 🌐

Nginx is commonly placed in front of Node.js applications to handle TLS termination, static file serving, and request routing.

server {
    listen 443 ssl;
    server_name example.com;

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

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

11. Reverse Proxy 🔀

A reverse proxy sits between clients and your Node.js application, handling concerns that don't belong in application code.

12. HTTPS & SSL 🔏

Production traffic must always be encrypted. Let's Encrypt provides free, automatically renewable TLS certificates.

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

13. Domains & DNS 🌍

DNS records map human-readable domain names to server IP addresses or other resource records.

14. Load Balancing ⚖️

Load balancers distribute incoming traffic across multiple application instances to improve throughput and resilience.

upstream node_app {
    least_conn;
    server 10.0.0.1:3000;
    server 10.0.0.2:3000;
    server 10.0.0.3:3000;
}

server {
    location / {
        proxy_pass http://node_app;
    }
}

15. Horizontal Scaling ↔️

Horizontal scaling adds more instances of your application rather than making a single instance bigger.

16. Vertical Scaling ↕️

Vertical scaling increases the resources (CPU, memory) of a single instance rather than adding more of them.

17. CI/CD Pipelines 🔁

Continuous Integration and Continuous Deployment automate testing, building, and releasing code on every change.

18. GitHub Actions ⚙️

GitHub Actions is a widely used CI/CD platform integrated directly into GitHub repositories.

name: Deploy
on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm test
      - run: npm run build
      - name: Build & push Docker image
        run: |
          docker build -t myregistry/my-app:${{ github.sha }} .
          docker push myregistry/my-app:${{ github.sha }}

19. Monitoring 📡

Monitoring provides visibility into an application's health and performance after deployment, catching problems before users report them.

20. Logging 📝

Centralized, structured logging is essential once you have more than one instance — you can't ssh into every server to check logs individually.

import pino from "pino";

const logger = pino({
  level: process.env.LOG_LEVEL ?? "info",
  formatters: { level: (label) => ({ level: label }) },
});

logger.info({ requestId: "abc123", path: "/api/users" }, "Request handled");

21. Health Checks ❤️‍🩹

Health check endpoints let load balancers and orchestrators know whether an instance is ready to serve traffic.

router.get("/health", async (req, res) => {
  try {
    await db.query("SELECT 1");
    res.status(200).json({ status: "ok" });
  } catch {
    res.status(503).json({ status: "unavailable" });
  }
});

22. Graceful Shutdown 🛑

On shutdown, an application should stop accepting new requests but finish in-flight ones before exiting — abruptly killing the process can drop active connections.

const server = app.listen(3000);

process.on("SIGTERM", () => {
  console.log("SIGTERM received, shutting down gracefully...");
  server.close(() => {
    console.log("Closed remaining connections.");
    process.exit(0);
  });

  setTimeout(() => process.exit(1), 10_000);
});

23. Zero-Downtime Deployment 🔄

Zero-downtime deployment ensures users never see errors or interruptions while a new version is being rolled out.

24. Backup & Recovery 💾

Regular, tested backups are a critical safety net — a backup that has never been restored isn't a real backup.

25. Cloud Deployment ☁️

Major cloud providers offer managed compute options that abstract away much of the underlying infrastructure.

26. Serverless Deployment 🌩️

Serverless platforms run your code on-demand without managing servers, scaling automatically and billing per invocation.

import type { APIGatewayProxyHandler } from "aws-lambda";

export const handler: APIGatewayProxyHandler = async (event) => {
  return {
    statusCode: 200,
    body: JSON.stringify({ message: "Hello from Lambda!" }),
  };
};

27. Performance Monitoring 📊

Post-deployment, track key performance indicators continuously to catch regressions before they affect many users.

28. Best Practices ✅

29. Common Mistakes ⚠️

30. Frequently Asked Questions ❓

31. Summary 📋

Deploying Node.js applications reliably involves far more than running node index.js on a server. From containerization and CI/CD pipelines to load balancing, health checks, and zero-downtime deployment, each piece contributes to an application that stays available and recoverable under real-world conditions.