MERN Production Setup Guide: Node.js, MongoDB, PM2, and Nginx

A real MERN production setup is not just “run npm start on a server.” In production, the stack needs clear separation between frontend, backend, database, and web server responsibilities. That usually means the React frontend is built and served efficiently, the Express API runs as a managed background process, MongoDB is secured properly, and Nginx handles the public traffic.

For most teams hosting on Ubuntu, a strong baseline setup is: React frontend build, Node.js and Express API behind PM2, MongoDB running locally or through a managed service, and Nginx as the reverse proxy. This keeps the stack understandable and maintainable while still being production-safe.

This guide is written around that model so you can deploy a MERN application in a way that is actually usable after launch, not just technically online.

Before touching packages, decide how the app will be organized on the server. A clean convention is to keep the frontend and backend in separate directories under /var/www. This helps with logs, deployments, restarts, and environment files later.

A simple structure looks like frontend for the React app and backend for the Express API. MongoDB can run on the same server for smaller setups, but if the app is customer-facing and expected to grow, a managed MongoDB instance is often safer and easier to maintain.

The main thing is consistency. Production problems become much easier to debug when paths and responsibilities are obvious.

Start by updating Ubuntu, then install Node.js, Nginx, and the tools you need for backend process management. If you are running MongoDB on the same server, install that separately based on the MongoDB version and repository you approve for production.

The commands below set up the common runtime layer first. This is the foundation both frontend and backend will use.

The backend should be treated as the persistent application process in the MERN stack. Put it in a stable directory, install packages, define production environment variables, and verify it can boot before you introduce Nginx routing.

A typical backend environment file includes the port, MongoDB connection string, JWT secret, and any third-party API keys. Never hardcode these into production source files.

Once the API works, hand it over to PM2. This is the process manager that will keep the backend alive, restart it if it crashes, and allow it to come back after a server reboot.

You can start the app directly from the backend directory. If your backend uses a different production command, use that instead of the simple example below.

The frontend side of a MERN app is usually built into static assets. That means you do not normally keep the React development server running in production. Instead, you build the frontend and let Nginx serve the generated files.

This makes the public site faster and simpler. It also reduces the number of moving parts compared with keeping both the API and frontend running as separate long-lived Node processes.

Nginx should do two jobs here: serve the built React frontend and proxy API requests to the Express backend. This is one of the cleanest production patterns for a MERN stack because it keeps the frontend static and the backend isolated.

The example below assumes the frontend build output is in dist. If your React setup uses build instead, update the path accordingly.

Once the frontend and API routing work over HTTP, add HTTPS. This should be part of the default production setup, not a later cleanup task. If your app is public, it should be encrypted from the start.

It is also worth enabling UFW with basic rules for SSH and Nginx. That gives the server a safer default network posture.

Once the stack is live, updates should follow a repeatable flow. Pull backend changes, install dependencies if needed, restart the API with PM2, then pull frontend changes, rebuild, and reload Nginx if required. The goal is a deployment sequence your team can repeat without guessing.

The exact commands depend on how your repos are organized, but the pattern below is a practical baseline.

If the frontend loads but API requests fail, the first thing to check is whether the frontend is pointing to the correct production API base URL. Many MERN deployment bugs are simply environment mismatches between frontend and backend.

If Nginx returns 502, the Express API is either not running, not listening on the expected port, or crashing under PM2. If MongoDB connection errors appear in the API logs, focus on the MONGO_URI, database access rules, and whether MongoDB is reachable from the backend server.

The fastest debugging order is: PM2 logs, backend env values, MongoDB connectivity, then Nginx logs.

Once the app is running, the next improvements should be operational, not decorative. Add backups, uptime checks, log monitoring, and a rollback habit. If the app starts receiving meaningful traffic, move MongoDB to a managed environment or at least separate it from the web layer if possible.

If you want to keep building your deployment knowledge, the best related reads are your Next.js deployment guide, campaign analytics resources, and tracking workflow pages so infrastructure and product growth stay aligned.