We already know what Node.js is and why it suits a platform like Escena Viva. Now let's install it. This might look like a formality — download an installer and click next, next, next — but the way you install Node.js shapes the rest of your life as a developer: what happens when one client demands version 22 tomorrow and another version 24, when your team has to reproduce your environment exactly, or when you run into the classic permissions error while installing a global tool.

In this lesson we will install Node.js the right way (with a version manager), verify that everything works, configure the editor and create the initial structure of the escena-viva/ folder, which will be with us until the end of the course.

1. The three ways to install Node.js
2. Installing with nvm on Linux and macOS
3. Installing on Windows: nvm-windows and fnm
4. Verification: what gets installed alongside Node
5. Choosing a version for a real project: LTS vs Current
6. The project's .nvmrc file
7. Configuring the editor and the terminal
8. Creating the Escena Viva project folder
9. Permissions: why you must never use sudo npm install -g

The underlying reason to prefer a version manager is simple: real projects have different life cycles. Escena Viva's legacy API may be on Node 22 while the new organizer dashboard is being built on Node 24. Without a version manager, that forces you to uninstall and reinstall constantly.

A comparison of the most common managers:

In this course we will use nvm as our reference (and fnm or nvm-windows on Windows), because .nvmrc is a file all of them understand.

The script adds a few lines to your shell configuration file (~/.bashrc, ~/.zshrc or ~/.profile) that load nvm whenever you open a terminal. Close the terminal and open it again, or reload it:

Check that nvm responds:

If it prints nothing, the script has not been loaded. Check that the nvm lines are in the configuration file your terminal actually reads (on macOS with zsh that is ~/.zshrc).

nvm downloads the binary, places it in ~/.nvm/versions/node/ and activates it in the current session.

Sample output:

Without this step, every new terminal will open with no version active.

Summary of nvm commands:

On Windows, the Linux nvm does not work (it is a shell script). You have two good options.

Download nvm-setup.exe from the coreybutler/nvm-windows project and run it. Then, in PowerShell as administrator the first time (nvm-windows creates a symbolic link in C:\Program Files\nodejs):

Differences from Linux nvm that are worth knowing:

• It does not support nvm alias default; the active version is global, not per terminal.
• nvm use does not read .nvmrc automatically.
• It requires administrator permissions to switch.

fnm works the same on Windows, Linux and macOS, it is very fast, and it does read .nvmrc.

To have fnm switch versions automatically when you enter a folder containing .nvmrc, add this to your PowerShell profile (notepad $PROFILE):

If you develop for Linux servers, the most faithful experience is to use WSL 2 (Windows Subsystem for Linux) and install nvm inside it following section 2. It avoids a lot of trouble with paths, permissions and line endings.

Warning: do not mix installations. If you already had Node installed through the official installer or through Chocolatey, uninstall it first before using a version manager. Two installations competing in the PATH produce baffling errors ("I have 24 but node -v says 18").

Open a new terminal and run:

If all three answer, the installation is correct. Here is what you got:

About corepack: it ships with Node but comes disabled. Its purpose is that, if a project declares it uses [email protected], you do not have to install it by hand. You enable it like this:

In this course we will use npm, which is what Node brings by default. The details of npm and package.json are the subject of Module 5; here we only check that it exists.

One more useful check: running code straight from the terminal.

Let's recall the rule we saw in the previous lesson and turn it into a concrete decision:

For Escena Viva we choose the 24.x (Active LTS) line. And, very importantly, we write it down in the repository so it does not depend on anyone's memory.

.nvmrc is a plain text file at the root of the project containing a single line: the Node version the project needs. nvm, fnm, Volta and most continuous integration systems understand it.

Resulting content:

It is also valid — and more flexible — to write it by hand with just the major line, so you get patch updates without touching the file:

or simply:

From now on, anyone cloning the Escena Viva repository only has to run:

A highly recommended trick: configure your shell to run nvm use automatically when you enter a folder containing .nvmrc. With fnm the --use-on-cd line we saw earlier is enough; with nvm, the official documentation includes a cd function for bash and zsh that does the same thing.

VS Code is the most common editor in the Node ecosystem, and it works with no configuration at all. These extensions make a real difference:

Recommended settings for the project. Create escena-viva/.vscode/settings.json:

"files.eol": "\n" deserves an explanation: it forces Unix-style line endings. If you work on Windows and deploy on Linux (the usual case), this avoids absurd differences in version control and broken scripts.

You have three ways to run a script from VS Code:

1. Integrated terminal (Ctrl+`): type node src/catalog.js. This is the approach we will use throughout the course.
2. The "Run" button: with a .js file open, F5 launches Node's built-in debugger.
3. launch.json: a reusable configuration. We will look at it in detail in Debugging Node.js Applications.

Practical recommendations:

• Linux/macOS: bash or zsh, either is fine. Add automatic version switching with .nvmrc.
• Windows: use Windows Terminal with PowerShell 7, or WSL directly. Avoid cmd.exe.
• Learn two shortcuts you will use every day: Ctrl+C to stop a running process (a server, for instance) and the up arrow to repeat the previous command.

Let's create the project skeleton. Choose a working folder (~/projects, for example) and run:

On Windows with PowerShell:

We pin the project's Node version and start version control:

We also create a minimal .gitignore. Even though we will not install dependencies yet, better safe than sorry:

Resulting structure:

Check that everything is in place:

About package.json: when you run npm init -y you will get a package.json file describing the project and its dependencies. We do not need it yet: the first programs in the course run with nothing but what Node ships with. We will study it in depth in Module 5.

This is the most common configuration mistake among beginners, and it deserves a section of its own.

You install Node with the official installer or with apt. Node ends up in /usr/local or /usr, which belongs to root. You try to install a global tool:

The instinctive reaction is to prefix it with sudo. Don't.

Use a version manager. With nvm or fnm, Node and its global packages live in your home folder (~/.nvm/versions/node/v24.5.0/lib/node_modules), where you already have permissions. The EACCES error simply stops existing:

If for some reason you must keep a system-wide installation, the official alternative is to change the global prefix to your home folder:

If you have already made the mess and have root-owned files in your cache, this is the repair:

Golden rule: on your development machine, npm should never need sudo. If it does, the problem is in how you installed Node, not in npm.

Mistake 1: command not found: nvm after installing it. The nvm script is loaded from the shell's configuration file. If you use zsh but the installer wrote to ~/.bashrc, it will not be loaded. Open the right file and check that it contains the export NVM_DIR=... lines and the source of nvm.sh. Then open a new terminal.

Mistake 2: node -v reports a different version from the one you just activated. There are almost always two installations competing. Diagnose it with:

If /usr/bin/node appears before the ~/.nvm path, uninstall the system version.

Mistake 3: new terminals have no Node at all. nvm alias default 'lts/*' is missing.

Mistake 4: nvm use says it cannot find .nvmrc. You are in a directory that is not the project root. nvm use looks for .nvmrc in the current directory and its parents, not in sibling subfolders.

Mistake 5: installing Node from the system package manager on Ubuntu and ending up with an ancient version. The repositories of stable distributions usually lag a long way behind. Always check with node -v which version actually landed.

Tip 1: pin the version on the server too. .nvmrc is not just for local use; CI systems and many PaaS platforms read it (Module 11).

Tip 2: document the start-up. Even though we have no README yet, write down somewhere the three commands needed to work on the project: nvm use, npm install, npm start. Your future self will thank you.

Tip 3: do not hoard versions. Run nvm ls from time to time and uninstall the ones no project uses any more; each takes up tens of megabytes.

1. Install Node.js with nvm (or fnm/nvm-windows if you are on Windows).
2. Install two versions: the latest LTS and the 22 line.
3. Set the LTS as the default version.
4. Write the commands you would use to check, from scratch in a new terminal, that everything is fine: the Node version, the npm version, the npx version, and the list of installed versions.

Create the escena-viva/ folder with:

• The subfolders src/, data/ and reports/.
• An .nvmrc file with the LTS version you installed.
• A .gitignore excluding node_modules/, .env and .log files.

Then write the sequence of commands a newly arrived colleague would run to get set up on the project with the right Node version, and check that nvm use (or fnm use) responds by reading the .nvmrc.

A colleague on the Escena Viva team writes to you: "I installed nvm and ran nvm install --lts, but when I open a new terminal node -v tells me v18.19.0. On top of that, if I try npm install -g nodemon I get EACCES and it only works with sudo."

1. What is the most likely diagnosis?
2. Which command would you ask them to run to confirm it?
3. Write out the steps of the fix.

Solution 1

An extra check that switching works:

Solution 2

Sequence for the newly arrived colleague:

Note: nvm use fails if the .nvmrc version is not installed; hence the nvm install beforehand (with no arguments, it also reads .nvmrc).

Solution 3

1. Diagnosis: there is a previous Node installation (from the official installer or from the system package manager) in a system directory, and it comes before nvm in the PATH. That installation belongs to root, which explains both the unexpected version (v18) and the EACCES error when installing global packages.

2. Confirmation command:

npm config get prefix also helps: if it returns /usr or /usr/local, that confirms the diagnosis.

3. The fix:

If company policy prevents them from uninstalling the system version, the alternative is to make sure the nvm line in ~/.bashrc runs at the end of the file, so that its path comes first in the PATH.

You now have a professional development environment. We have seen that there are three ways to install Node.js and why a version manager (nvm, fnm or nvm-windows) is the only one that copes well with the reality of working on several projects: it lets you install several versions, switch between them instantly and — no small detail — it eliminates at the root the permission problems that lead to the bad practice of sudo npm install -g.

You have installed the latest Active LTS, checked that node, npm, npx and corepack respond, configured the editor with the extensions you will use throughout the course, and created the escena-viva/ folder with its src/, data/ and reports/ directories, a .gitignore and an .nvmrc that documents the project version for the whole team.

The folder exists but it is empty. In the next lesson, Your First Node.js Program, we will write src/catalog.js: Escena Viva's first real program, which defines the event catalog for the Teatro Almendra, the Sala Bóveda and the Auditorio Ribera, prints it nicely formatted to the console, and learns to receive arguments from the command line.