Node.js Part 1: What Is Node.js and How to Build Your First Node.js App

What you should know first: this is the first part, so no earlier part is needed. You should know basic JavaScript (variables, functions, arrays, objects and arrow functions). If promises still feel new, keep our JavaScript Promises guide open for later parts.

If you have written JavaScript for the browser, you already know half of backend development. Node.js lets the same language run outside the browser: on your laptop, on a server, inside build tools and in the cloud. In this first part of the Node.js series you will learn, in simple words, what is Node.js, how it is different from browser JavaScript, and why its “never wait” design makes it so good for web servers and APIs. Then you will install it, write your first scripts, and build a small web server with zero packages.

What is Node.js? (simple definition)

Node.js is a JavaScript runtime. A runtime is the environment that actually runs your code. Before Node.js, the only place JavaScript could run was inside a web browser. In 2009 Ryan Dahl took V8, the very fast JavaScript engine from Google Chrome, and wrapped it in a program that can run on any computer and talk to the file system and the network. That program is Node.js.

Three words help you understand it:

Node.js is used by companies such as Netflix, PayPal, LinkedIn, Uber, Walmart and many Indian startups and product companies for APIs and web servers. It also powers almost every modern frontend tool: Vite, Next.js, ESLint and TypeScript all run on Node.js. So even frontend developers use it every day. The official site nodejs.org/learn has a good free introduction too.

Browser JavaScript vs Node.js

The language is the same: let, const, functions, arrays, objects, promises and async/await all work exactly as you know them. What changes is the toolbox around the language.

How Node.js works: the event loop in simple words

Think of a busy restaurant with one very fast waiter. The waiter takes your order, gives it to the kitchen, and immediately goes to the next table. They do not stand in the kitchen waiting for your food. When a dish is ready, the kitchen rings a bell and the waiter delivers it.

Node.js works the same way:

• Your JavaScript runs on one main thread (the waiter). It runs one piece of code at a time.
• Slow work is handed off (to the kitchen). Reading a file, calling another API or querying a database is done by the operating system and a C library called libuv, in the background.
• Finished work waits in a queue (the bell). Each finished job has a callback, a function you gave Node.js to run “when it is done”.
• The event loop delivers results. Whenever the main thread is free, the event loop takes the next callback from the queue and runs it.

This style is called non-blocking I/O (I/O means input/output: files, network, databases). Because the main thread never waits, a single Node.js process can handle thousands of users at the same time, as long as each request does mostly I/O and not heavy number crunching.

We will study the event loop deeply in Part 6. For now, the restaurant picture is all you need.

What can you build with Node.js?

Install Node.js (choose the LTS version)

On nodejs.org/download you will see two kinds of versions. LTS (Long Term Support) gets bug and security fixes for about 30 months, which is why companies use it in production. Current has the newest features but changes faster. As a beginner, always pick LTS. Everything in this series works on Node.js 22, 24 and 26.

# Option 1: download the LTS installer from nodejs.org and click Next
# Option 2: use winget (built into Windows 10 and 11)
$ winget install OpenJS.NodeJS.LTS
# Close and reopen the terminal, then check:
$ node -v
$ npm -v

# Install nvm (check github.com/nvm-sh/nvm for the newest version)
$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
# Restart the terminal, then install the latest LTS version
$ nvm install --lts
$ nvm use --lts
$ node -v

# Same nvm steps work on Linux and WSL
$ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
$ source ~/.bashrc
$ nvm install --lts
$ node -v
# Switch versions any time, per project
$ nvm install 24
$ nvm use 24

Pick your operating system above to see the right install steps.

Now open a new terminal and check that both node and npm (the package manager that comes with Node.js) are ready. Your version numbers may be newer; that is fine.

# Check that Node.js and npm are installed
$ node -v
v22.22.0
$ npm -v
10.9.4

Try the Node.js REPL (a JavaScript playground)

Type node with no file name and you enter the REPL (Read, Evaluate, Print, Loop). It reads a line of JavaScript, runs it, prints the result and waits for the next line. It is perfect for quick experiments.

$ node
Welcome to Node.js v22.22.0.
Type ".help" for more information.
> 2 + 3
5
> "devdojo".toUpperCase()
'DEVDOJO'
> [1, 2, 3].map(n => n * 2)
[ 2, 4, 6 ]
> .exit

Press Ctrl + C twice or type .exit to leave. Use the REPL to test small ideas; use files for real programs.

Your first Node.js script

Create a folder called node-part1, open it in VS Code, and create a file named hello.js. This script greets you and prints some facts about your machine, things a browser is not allowed to tell a web page.

// hello.js – your first Node.js program
import os from "node:os";

const name = process.argv[2] ?? "DevDojo reader";

console.log(`Hello, ${name}!`);
console.log("Node.js version:", process.version);
console.log("Operating system:", os.platform());
console.log("CPU cores:", os.cpus().length);

$ node hello.js Lokendra
Hello, Lokendra!
Node.js version: v22.22.0
Operating system: linux
CPU cores: 2

Click ▶ Run to see the real output in the terminal panel.

Let’s read it line by line:

• import os from "node:os" loads a built-in module. The node: prefix makes it clear this is part of Node.js itself, not an npm package. (To use import in a .js file, add "type": "module" to package.json; we do that below. Recent Node.js versions also detect it automatically.)
• process is a global object about the running program. process.argv is the list of words you typed in the terminal, so process.argv[2] is the first extra word (Lokendra).
• ?? gives a default value when nothing was typed.
• process.version, os.platform() and os.cpus() read details from the computer.

Run it with node hello.js, then with node hello.js YourName. Congratulations, you have just run JavaScript outside the browser.

See non-blocking code in action

Now let’s prove the restaurant idea with real code. Before you click Run, guess the order in which the five lines will print.

// async-demo.js – Node.js does not wait for slow work
import { readFile } from "node:fs/promises";

console.log("1. Start");

setTimeout(() => {
  console.log("4. Timer finished (after 0 ms)");
}, 0);

readFile("package.json", "utf8").then((text) => {
  const pkg = JSON.parse(text);
  console.log(`5. File read: project name is "${pkg.name}"`);
});

console.log("2. Asked for the timer and the file");
console.log("3. Still running other code...");

$ node async-demo.js
1. Start
2. Asked for the timer and the file
3. Still running other code...
4. Timer finished (after 0 ms)
5. File read: project name is "node-part1"

Make your guess, then click ▶ Run.

Even with a delay of 0 ms, the timer message prints after lines 2 and 3. Here is why:

1. Node.js runs all the normal code from top to bottom first (lines 1, 2, 3).
2. setTimeout and readFile do not stop the program. They hand the work to the background and register a callback.
3. Only when the main code is finished does the event loop run the waiting callbacks: first the timer, then the file result once the disk has answered.

Build your first web server with Node.js

This is where Node.js shines. With the built-in node:http module you can build a working web server in about 20 lines, with no npm packages at all. Our server answers three kinds of requests: the home page /, a small JSON API at /api/time, and a 404 page for everything else.

// server.js – a tiny web server with no packages at all
import { createServer } from "node:http";

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

const server = createServer((req, res) => {
  if (req.url === "/") {
    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
    res.end("Hello from Node.js!\n");
  } else if (req.url === "/api/time") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ time: new Date().toISOString() }));
  } else {
    res.writeHead(404, { "Content-Type": "text/plain" });
    res.end("Page not found\n");
  }
});

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

$ node server.js
Server running at http://localhost:3000/

// client.js – call our server with the built-in fetch()
const base = "http://localhost:3000";

const home = await fetch(base + "/");
console.log(home.status, (await home.text()).trim());

const api = await fetch(base + "/api/time");
const data = await api.json();
console.log(api.status, data);

const missing = await fetch(base + "/nope");
console.log(missing.status, (await missing.text()).trim());

$ node client.js
200 Hello from Node.js!
200 { time: '2026-10-23T13:54:05.642Z' }
404 Page not found

Click the server.js and client.js tabs, then ▶ Run on each. Start the server first and keep it running; run the client in a second terminal.

How the server works:

• createServer() takes a function that runs for every request. It receives req (the request: URL, method, headers) and res (the response you send back).
• res.writeHead(200, ...) sets the status code and headers. 200 means OK, 404 means not found. The Content-Type header tells the browser what kind of data is coming.
• res.end(...) sends the body and finishes the response. For JSON we turn an object into text with JSON.stringify.
• server.listen(PORT) starts listening. process.env.PORT lets a hosting platform choose the port, with 3000 as the local default.

Open http://localhost:3000/ and http://localhost:3000/api/time in your browser too. In client.js we used the built-in fetch() and top-level await (allowed in ES modules) to test the server from code. You can also test with curl http://localhost:3000/.

package.json, npm scripts and –watch

Every Node.js project has a package.json file in its root folder. It stores the project name, version, the packages it needs and handy scripts. Create one with npm init -y (-y means “yes to all defaults”):

# Create a folder and a package.json in one go
$ mkdir node-part1
$ cd node-part1
$ npm init -y
Wrote to /home/you/node-part1/package.json:

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

Now edit it to look like this. We add "type": "module" so import works in every .js file, and two scripts: start for normal runs and dev for development.

{
  "name": "node-part1",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "node server.js",
    "dev": "node --watch server.js"
  }
}

Run the scripts from the terminal:

# Run a script from package.json
$ npm run dev
# Or use Node's own faster script runner (Node.js 22+)
$ node --run dev
# Restart automatically when you save a file (no nodemon needed)
$ node --watch server.js
# Stop the server
# press Ctrl + C

• npm run dev runs the dev script. npm start is a short form for the start script.
• node --run dev does the same but starts faster because it skips npm (available in Node.js 22 and newer).
• node --watch restarts the server every time you save a file. You no longer need the old nodemon package for this.

Common Node.js errors and fixes

Every beginner hits these. Bookmark this table; you will see these messages again.

Best practices from day one

• Use the LTS version and a version manager (nvm, fnm or Volta) so each project can use the version it needs.
• Use ES modules (import/export with "type": "module"). This is the modern standard and matches browser JavaScript.
• Write the node: prefix for built-in modules (node:fs, node:http). It is clearer and avoids confusion with npm packages.
• Never block the event loop. Prefer the async versions of APIs (fs/promises instead of readFileSync) inside servers.
• Read config from environment variables (like process.env.PORT) instead of hard-coding ports, passwords or API keys.
• Use node --watch in development and a plain node command in production.
• Keep secrets out of Git. No API keys in code files. We will set up .env files properly in Part 15.

Practice task

Frequently asked questions

Conclusion

You now know what Node.js is: a JavaScript runtime built on V8 that runs your code outside the browser and adds files, servers and operating-system access. You learned how it differs from browser JavaScript, how the event loop lets one thread serve many users without waiting, and what you can build with it. You installed Node.js, tried the REPL, wrote your first scripts, saw non-blocking code with your own eyes, built a web server with zero packages, and set up package.json with scripts and --watch.

Want to see where this road leads? Our Docker Compose tutorial runs a Node.js app with PostgreSQL and Redis, and the GitHub Actions CI/CD guide for Node.js shows how to test and deploy it automatically.