🛠️ Setting Up an Express Application

Before You Start

You need Node.js installed (which includes npm, the Node package manager). Use a current LTS release. Confirm both are present:

node --version   # e.g. v20.x or v22.x
npm --version    # e.g. 10.x

The whole setup is five short steps. Here's the map before we walk it:

Step 1 — Initialize the Project

Create a folder for the app and turn it into a Node project. The -y flag accepts all defaults so npm doesn't ask questions.

mkdir my-express-app
cd my-express-app
npm init -y

This creates a package.json. Open it and you'll see something like this. Add "type": "module" only if you plan to use modern import syntax — this course uses CommonJS require, so we'll leave it out here.

{
  "name": "my-express-app",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Step 2 — Install Express

Install Express and save it as a dependency (npm does this automatically now):

npm install express

Two things change. First, package.json gains a dependencies entry:

"dependencies": {
  "express": "^4.19.2"
}

Second, a node_modules/ folder and a package-lock.json appear. You never commit node_modules to Git — it's huge and reproducible. Create a .gitignore:

node_modules/
.env

Step 3 — Write the Server

Create app.js. This is the smallest useful Express server — it creates an app, defines one route, and starts listening.

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

// Create the application object
const app = express();

// Read the port from the environment, or default to 3000
const PORT = process.env.PORT || 3000;

// A single route: respond to GET / with some text
app.get('/', (req, res) => {
  res.send('Hello from Express!');
});

// A JSON route to prove the server is alive
app.get('/api/health', (req, res) => {
  res.json({ status: 'ok', uptime: process.uptime() });
});

// Start listening for requests
app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
});

Run it:

node app.js

Server running at http://localhost:3000

Open http://localhost:3000 to see the text, and /api/health to see JSON. Press Ctrl+C in the terminal to stop the server.

Step 4 — Scripts & nodemon

Restarting the server by hand after every edit gets old fast. nodemon watches your files and restarts automatically. Install it as a dev dependency (it isn't needed in production):

npm install --save-dev nodemon

Add scripts to package.json so you can type short commands instead of remembering full ones:

"scripts": {
  "start": "node app.js",
  "dev": "nodemon app.js"
}

Now use:

npm run dev     # development: auto-restarts on save
npm start       # production-style: plain node

Step 5 — Environment Config

Hard-coding values like ports, database URLs, and secret keys is a mistake — they differ between your laptop and the production server, and secrets must never live in source control. The standard fix is environment variables, loaded from a .env file in development.

Recent Node versions (20.6+) can load a .env file natively with a flag, but the widely-used dotenv package works everywhere:

npm install dotenv

Create a .env file (already in .gitignore from Step 2):

PORT=4000
APP_NAME=My Express App

Load it at the very top of app.js, before you read any variable:

// app.js
require('dotenv').config();   // must run first
const express = require('express');

const app = express();
const PORT = process.env.PORT || 3000;
const APP_NAME = process.env.APP_NAME || 'Express App';

app.get('/', (req, res) => {
  res.send(`Hello from ${APP_NAME}!`);
});

app.listen(PORT, () => {
  console.log(`${APP_NAME} running at http://localhost:${PORT}`);
});

Project Structure

A one-file app.js is fine to start, but real apps split responsibilities into folders. Here's a sensible starter layout you'll grow into over this module:

my-express-app/
├── node_modules/        # installed packages (git-ignored)
├── src/
│   ├── routes/          # route definitions (users.js, products.js)
│   ├── controllers/     # request-handling logic
│   ├── middleware/      # custom middleware
│   └── app.js           # creates and configures the Express app
├── public/              # static files (css, images)
├── .env                 # local secrets (git-ignored)
├── .env.example         # documented, safe-to-commit template
├── .gitignore
├── package.json
└── package-lock.json

// src/app.js
const express = require('express');
const app = express();
app.get('/', (req, res) => res.send('Hello!'));
module.exports = app;

// server.js
require('dotenv').config();
const app = require('./src/app');
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`On http://localhost:${PORT}`));

Hands-on Exercise

// app.js
require('dotenv').config();
const express = require('express');
const app = express();

const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Setup complete!');
});

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

app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
});

// package.json (scripts)
"scripts": {
  "start": "node app.js",
  "dev": "nodemon app.js"
}

Quiz

Summary

📚 Further Reading

• Express — Installing
• npm — the package.json reference
• dotenv — loading environment variables

🚀 What's Next?

Your server is running but only answers a couple of URLs. Next up, Basic Routing and Request Handling teaches you to map many methods and paths to handlers, capture route and query parameters, and shape responses properly.