Chapter 2 — Environment Setup

The why

"It works on my machine" has ended more careers than any single bug. Set up your environment once, correctly, and skip months of weird tooling pain.

The minimum kit

Total install time: an hour. We'll do it once.

Step 1 — Install Node via nvm

Don't use the .pkg / .msi installer from nodejs.org. It's fine until you need a different Node version for one project. Use nvm (Node Version Manager) — switch versions per project.

macOS / Linux

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
# restart your shell, then:
nvm install --lts
nvm use --lts
node --version  # → v20.x.x or v22.x.x

Windows

Use nvm-windows (different project, same idea):

1. Download from https://github.com/coreybutler/nvm-windows/releases (latest nvm-setup.exe).
2. Run it. Open a new PowerShell.
3. nvm install lts
4. nvm use 20.18.0 (or whatever it printed)
5. node --version

Step 2 — VS Code + the essential extensions

Install VS Code (code.visualstudio.com). Then add these extensions — they save real time:

Open settings.json (Ctrl/Cmd + Shift + P → "Preferences: Open User Settings (JSON)") and add:

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
  "files.eol": "\n",
  "files.insertFinalNewline": true

These four lines will save you 100s of small annoyances.

Step 3 — A real terminal

The default Windows cmd and macOS Terminal both work, but they're ugly. Pick one:

• Windows — Windows Terminal (free from Microsoft Store) running PowerShell or WSL2. WSL2 gives you a real Linux inside Windows — strongly recommended.
• macOS — iTerm2 (iterm2.com) or Warp.
• Linux — whatever ships with your distro.

Optional but worth it: install Oh My Zsh (macOS/Linux) or PowerShell modules (Windows) for a prettier prompt with git status.

Step 4 — Git

If you've never used Git, install it (git-scm.com) and configure once:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main
git config --global pull.rebase false

We assume basic Git fluency throughout. If you don't have it, do the Git & DevOps module first.

Step 5 — Docker Desktop

Docker lets you run Postgres, Redis, etc. without "installing" them. Get Docker Desktop from docker.com. Start it. Verify:

docker run hello-world

If that prints a welcome message, you're set.

Step 6 — Postgres in 10 seconds (via Docker)

Don't install Postgres natively. Run it in a container.

docker run -d \
  --name local-postgres \
  -e POSTGRES_PASSWORD=secret \
  -p 5432:5432 \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16

This:

• Pulls Postgres 16 (first time only).
• Runs it in the background.
• Stores data in a named volume so a restart doesn't wipe it.
• Exposes port 5432 locally.

Verify:

docker exec -it local-postgres psql -U postgres
# At the psql prompt:
SELECT version();
\q

You now have a local Postgres. To stop it: docker stop local-postgres. To start it again: docker start local-postgres.

Step 7 — A DB client

Inspecting data via psql is slow. Get a real client:

• TablePlus (free tier, my pick for macOS/Windows)
• DBeaver (free, cross-platform, heavier)
• pgAdmin (free, official)
• DataGrip (paid, by JetBrains)

Connect with: host localhost, port 5432, user postgres, password secret.

Step 8 — An API client

Three good choices:

• Postman — the standard. Free for individuals.
• Insomnia — lighter.
• REST Client (VS Code extension) — write requests in .http files. Version-controllable.

We'll use REST Client throughout the course because requests live next to code.

@base = http://localhost:3000
 
### Create a user
POST {{base}}/users
Content-Type: application/json
 
{ "name": "Aditi", "email": "aditi@x.com" }
 
### List users
GET {{base}}/users

Click "Send Request" above each ### block.

Step 9 — Project template

Create a folder. Initialize:

mkdir hello-backend
cd hello-backend
npm init -y
npm install express
node -e "require('http').createServer((_,res)=>res.end('hi')).listen(3000,()=>console.log('hi on 3000'))"

Open another terminal:

curl http://localhost:3000
# → hi

Congratulations, you have a working Node + HTTP stack. Stop the server with Ctrl+C.

Common mistakes

Production · Performance · Security notes

Production. Pin your Node version. Commit a .nvmrc (echo "20" > .nvmrc) so anyone (and CI) runs the same version.

Performance. Don't run Postgres on your laptop and a heavy IDE and Slack and Chrome with 50 tabs. RAM is the bottleneck.

Security. Don't reuse production secrets locally. A local-postgres with password secret is fine. Production passwords stay in production.

Exercises

1. Beginner. Install nvm, install Node LTS, print process.versions.node.
2. Beginner. Run Postgres in Docker. Connect with psql and create a database.
3. Intermediate. Add .nvmrc to a project. Switch versions with nvm use.
4. Advanced. Set up a docker compose.yml that runs Postgres + Redis with one command.

Summary

You don't need to like configuring tools — you need to do it once. nvm for Node, VS Code with linting/formatting, a real terminal, Postgres in Docker, a DB client, a REST client. After this chapter you should never spend another 20 minutes installing a JS runtime.

Quick recall

• Node via nvm, not the website installer.
• Postgres in Docker, not natively.
• VS Code + ESLint + Prettier + REST Client = 80% of the speedup.
• .nvmrc in every project.

Quiz

1. Why use nvm instead of the Node installer?
2. What does -v pgdata:/var/lib/postgresql/data do in the Docker command?
3. Name two VS Code settings worth enabling.
4. Why run Postgres in Docker?