Introduction to Node.js

Reviewed & published by Brayan K

Node.js is a runtime that lets you run JavaScript outside the browser to build servers, command-line tools, and back-end applications.

Part of the free Node.js course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

By the end of this lesson you'll understand what Node.js is and why it exists, how it runs JavaScript without a browser, and you'll have written and run your own first Node script that prints to the terminal.

What You'll Learn in This Lesson

• What Node.js is and why it runs JavaScript outside the browser
• How Node is built on the V8 engine that powers Chrome
• Why Node is non-blocking and good for servers and tools
• How to print output to the terminal with console.log
• How to read runtime info from the global process object
• How to run a .js file with the node command and check your version

1️⃣ What is Node.js?

For years JavaScript could only run inside a web browser. In 2009 Node.js changed that by taking Chrome's JavaScript engine (called V8) and wrapping it so JavaScript could run anywhere — on servers, on your laptop, in scripts. It rests on a few key ideas:

• • A runtime, not a language — you still write JavaScript. Node is just the environment that runs it outside the browser.
• • Built on V8 — the same fast engine that runs JavaScript in Google Chrome compiles your code to native speed.
• • Non-blocking — while one task waits (a file, a network call), the rest of your program keeps running, so a single process can serve many users at once.
• • Batteries included — built-in modules let you read files, build web servers, and handle data without installing anything extra.

Because of this, Node powers a huge amount of the modern web — APIs, build tools, and command-line apps. You'll start where every Node developer starts: a tiny script that prints text to the terminal. Read the worked example below first — every line is explained — then run it yourself.

// This is a Node.js script — plain JavaScript that runs OUTSIDE the browser.
// There is no <html> page and no window here; Node gives JS its own runtime.

// console.log writes a line of text to the terminal (standard output).
console.log("Hello from Node.js!");      // -> Hello from Node.js!
console.log("No browser required.");     // -> No browser required.

// You can do real work too — JavaScript math runs exactly as you'd expect.
const total = 2 + 2;
console.log("2 + 2 =", total);           // -> 2 + 2 = 4

2️⃣ Why Node.js? Runtime Info and Non-Blocking Code

Two things make Node feel different from browser JavaScript. First, Node gives you a global process object full of information about the running program — like the Node version and the operating system. Second, Node is non-blocking: code that has to wait gets scheduled and runs later, so your program never freezes while it waits. Read the comments, predict the order of the lines, then check.

// Node runs on Google's V8 engine — the same engine inside Chrome.
// "process" is a global object Node gives you with info about the runtime.

// Two things process can tell you about the machine you are on. They are
// left as comments here because their answers are different on every
// computer — including this page's, which is why no output panel could
// honestly show them. Uncomment them when you run the file yourself:
//   console.log("Node version:", process.version);   // e.g. v22.11.0
//   console.log("Running on:", process.platform);    // linux | darwin | win32

// Node is NON-BLOCKING: slow work (timers, files, network) runs in the
// background while the rest of your code keeps going. Watch the order:
console.log("1. Start");

setTimeout(() => {
  console.log("3. This runs LAST, after 0 ms — it was scheduled, not blocking.");
}, 0);

console.log("2. End of the script body");

Notice the surprise: even with a 0 ms delay, the setTimeout line printed last. Node didn't stop and wait — it scheduled that work and finished the rest of the script first. That scheduling-instead-of-waiting behavior is the heart of why Node handles so many connections efficiently.

Your turn. The script below works once you fill in the two blanks marked ___. Follow the 👉 hints, then run it and compare with the expected output.

// 🎯 YOUR TURN — replace each ___ then run it with: node greet.js

// 1) Store your name in a variable
const name = ___;          // 👉 your name in "double quotes", e.g. "Sam"

// 2) Print a greeting that includes the variable.
//    Template literals use backticks and ${...} to drop a value in.
console.log(`Hello, ${name}! Welcome to Node.js.`);

// 3) Print which version of Node you are running
console.log("You are on Node", ___);   // 👉 the runtime object's .version property
// (hint: it lives on the global "process" object)

// ✅ Expected output (example):
//    Hello, Sam! Welcome to Node.js.
//    You are on Node v20.11.0

3️⃣ Running a File with the node Command

To run a Node script on your own machine, save it in a file ending in .js (for example hello.js) and type node hello.js in your terminal. Node reads the file top to bottom and prints anything you console.log to the screen.

# First, check Node is installed (prints the version number):
node -v

# Save your code in a file called hello.js, then run it:
node hello.js

# Node runs the file and prints whatever you console.log:
# (the lines below are the program's output)

Mini-Challenge: A "Script Info" Report

No blanks this time — just a brief and an outline to keep you on track. Write it yourself, run it with node info.js, and check your output against the example in the comments. This is exactly the kind of tiny program that builds real fluency.

// 🎯 MINI-CHALLENGE: a tiny "about this script" report.
// Save it as info.js and run it with: node info.js
//
// 1. Print a friendly title line of your own.
// 2. Print the Node version using process.version.
// 3. Print the folder this file lives in using the __dirname global.
// 4. Print a small calculation, e.g. how many minutes are in a day.
//    (Use console.log for every line.)
//
// ✅ Example output:
//    === Script Info ===
//    Node version: v20.11.0
//    Folder: /home/sam/projects
//    Minutes in a day: 1440

// your code here

Common Errors (and the fix)

• "node: command not found" — Your terminal can't find Node, which usually means it isn't installed (or the terminal was opened before install). Install the LTS version from nodejs.org, then open a new terminal and try node -v again.
• "ReferenceError: window is not defined" — Browser-only objects like window, document, and alert do not exist in Node. Use console.log for output and Node's own globals like process and __dirname instead.
• "Error: Cannot find module './hello.js'" — Node looked for a file that isn't where you said. Check the filename and that your terminal is in the same folder as the file (run ls or dir to confirm it's there).
• Running the wrong filename — node hello (no extension) or a typo in the name produces a "Cannot find module" error. Type the full name including .js: node hello.js.
• "SyntaxError: Unexpected token" — A typo in your JavaScript (a missing quote, bracket, or comma). Read the line number Node prints, fix the punctuation there, and run it again.

Pro Tips

• 💡 Install the LTS version: nodejs.org offers "LTS" (long-term support) and "Current". Pick LTS — it's the stable, well-tested choice for learning and real projects.
• 💡 Try snippets instantly: use a free online runner like onecompiler.com/nodejs to test code without installing anything.
• 💡 Remember where you are: the most common beginner error is running node app.js from the wrong folder. cd into the folder that holds the file first.

📋 Quick Reference — Node.js Basics

🎉 Lesson Complete!

• ✅ Node.js is a runtime that runs JavaScript outside the browser
• ✅ It's built on the V8 engine that powers Google Chrome
• ✅ Node is non-blocking — it schedules slow work instead of freezing
• ✅ console.log prints to the terminal; process holds runtime info
• ✅ Run a file with node app.js and check your install with node -v
• ✅ Browser-only globals like window don't exist in Node

Practice quiz

Continue this course

• Next: Running Scripts & the REPL — Run .js files with node and experiment interactively in the REPL
• Quick reference: Node.js cheat sheet

Frequently asked questions

What exactly is Node.js — a language, a framework, or something else?

Node.js is none of those: it's a runtime. The language is still JavaScript. A web browser is one runtime that can execute JavaScript (and gives it the window and document objects); Node.js is a different runtime that runs the same JavaScript on a server or your own machine, and gives it server-style abilities instead — reading files, opening network connections, and reading command-line input. It's built on Chrome's V8 engine, which is what actually compiles and runs your JavaScript.

Do I need to know front-end JavaScript before learning Node.js?

Not deeply. You should be comfortable with core JavaScript — variables, functions, objects, arrays, and async basics like callbacks or promises — but you do not need React, the DOM, or any browser knowledge. In fact, browser-only things such as window, document, and alert do not exist in Node and will throw a ReferenceError if you use them. Node focuses on the language itself plus its own built-in modules.

Why is Node.js described as non-blocking or asynchronous?

Most slow operations in a program involve waiting — for a file to load, a database to answer, or a network request to return. Node is designed so that while one piece of code is waiting, the rest of your program keeps running instead of freezing. It does this with an event loop and callbacks (or promises and async/await). That's why a single Node process can handle thousands of simultaneous connections efficiently, which makes it popular for servers and APIs.

How do I actually run a Node.js file?

Install Node.js from nodejs.org (the LTS version is the safe choice), then save your code in a file ending in .js — for example app.js. Open a terminal in that folder and type node app.js. Node executes the file top to bottom and prints anything you console.log to the terminal. You can check your install worked by running node -v, which prints the version number.