DEV Community

Cover image for What Is Node.js? JavaScript on the Server Explained
Pratham
Pratham

Posted on

What Is Node.js? JavaScript on the Server Explained

#webdev #chaicode #javascript #node

How one runtime changed everything — and made JavaScript a full-stack language.

For the longest time, I thought JavaScript was a "browser language." You write it, the browser runs it, and it makes web pages interactive. Buttons, animations, form validation — that's JavaScript's job. The server? That was PHP, Java, Python territory. JavaScript wasn't invited.

Then I learned about Node.js, and that entire mental model shattered.

Node.js takes JavaScript — the same language I was writing for the browser — and lets it run on a server. The same console.log, the same const, the same functions and arrays — but now it's reading files, handling HTTP requests, connecting to databases, and building APIs.

When I first encountered this in the ChaiCode Web Dev Cohort 2026, the idea blew my mind: one language for everything. Frontend and backend. Browser and server. Let me explain how that became possible.

What Is Node.js?

Node.js is a JavaScript runtime built on Chrome's V8 engine that lets you run JavaScript outside the browser — primarily on servers.

Let's unpack that:

  • Runtime — not a language, not a framework, but an environment that executes JavaScript code
  • Built on V8 — uses the same engine that Chrome uses to run JavaScript, but without the browser
  • Outside the browser — on your computer, on a server, on a Raspberry Pi — anywhere 
JavaScript (the language)
    │
    ├── Runs in the browser → Chrome, Firefox, Safari
    │      (with DOM, window, document)
    │
    └── Runs on the server → Node.js
           (with file system, HTTP, databases)
Enter fullscreen mode Exit fullscreen mode

Runtime vs Language — An Important Distinction

This confused me at first. JavaScript is the language. Node.js is the runtime — the environment that knows how to execute that language.

Think of it like English. English is the language. A courtroom and a classroom are different environments where English is spoken. The language is the same, but what you can do with it depends on the environment.

Language:    JavaScript (same everywhere)
                │
Runtime:        ├── Browser runtime (Chrome, Firefox)
                │     → Can: manipulate DOM, handle clicks, show alerts
                │     → Can't: read files, start servers, access databases
                │
                └── Node.js runtime (server)
                      → Can: read files, start servers, access databases
                      → Can't: manipulate DOM, show alerts, access window
Enter fullscreen mode Exit fullscreen mode

Why Was JavaScript Originally Browser-Only?

JavaScript was created in 1995 by Brendan Eich at Netscape — specifically for the browser. Its original purpose was to make web pages interactive: validate forms, change content dynamically, respond to clicks.

Every browser came with its own JavaScript engine — a program that reads and executes JavaScript code:

Browser JavaScript Engine
Chrome V8
Firefox SpiderMonkey
Safari JavaScriptCore
Edge (old) Chakra
Edge (new) V8

These engines were embedded inside the browser. There was no way to run JavaScript without opening a browser. If you wanted to write server-side code, you had to learn a completely different language — PHP, Java, Ruby, Python.

This meant web developers needed to know at least two languages:

Frontend: HTML + CSS + JavaScript
Backend:  PHP / Java / Python / Ruby

Different language, different syntax, different ecosystem.
Context-switching every time you move between frontend and backend.
Enter fullscreen mode Exit fullscreen mode

How Node.js Made JavaScript Run on Servers

In 2009, Ryan Dahl had a brilliant idea: take the V8 engine out of Chrome, wrap it with server-level capabilities (file system access, networking, etc.), and create a standalone runtime for JavaScript.

That's Node.js. It's essentially:

Node.js = V8 Engine + Server APIs + Event Loop

V8 Engine     → Executes JavaScript (same engine as Chrome)
Server APIs   → File system, HTTP, networking, child processes
Event Loop    → Handles async I/O efficiently (non-blocking)
Enter fullscreen mode Exit fullscreen mode

What Changed

Before Node.js After Node.js
JavaScript = browser only JavaScript = browser + server + more
Frontend devs need a second language One language for everything
Different ecosystems for front & back Shared ecosystem (npm, shared code)
Can't run JS without a browser Run JS anywhere: terminal, server, IoT

Your First Node.js Code

Save this as hello.js:

console.log("Hello from Node.js! 🚀");
console.log("I'm running OUTSIDE the browser.");
console.log("Node version:", process.version);
Enter fullscreen mode Exit fullscreen mode

Run it in the terminal:

node hello.js
Enter fullscreen mode Exit fullscreen mode

Output:

Hello from Node.js! 🚀
I'm running OUTSIDE the browser.
Node version: v20.x.x
Enter fullscreen mode Exit fullscreen mode

No browser. No HTML file. Just JavaScript running directly on your machine. That's Node.js.

The V8 Engine — A High-Level Overview

V8 is the open-source JavaScript engine developed by Google for Chrome. It's what makes JavaScript fast enough to power servers.

What V8 Does 

Your JavaScript Code
        ↓
┌───────────────────────┐
│       V8 Engine       │
│                       │
│  1. Parses your code  │
│  2. Compiles to       │
│     machine code      │
│  3. Executes it       │
│     (very fast!)      │
└───────────┬───────────┘
            ↓
     Program runs
Enter fullscreen mode Exit fullscreen mode

The key innovation: V8 compiles JavaScript to machine code instead of interpreting it line by line. This makes it dramatically faster than older JavaScript engines and fast enough for server workloads.

You don't need to understand V8 internals to use Node.js — just know that it's the reason Node.js can handle millions of requests. It's the engine under the hood.

Browser JS vs Node.js — What's Different?

Same language, different superpowers. Here's what each environment gives you:

Browser JavaScript Can: 

// Manipulate the DOM
document.querySelector("#btn").addEventListener("click", () => {
  document.body.style.backgroundColor = "darkblue";
});

// Access browser APIs
window.alert("Hello!");
localStorage.setItem("theme", "dark");
fetch("https://api.example.com/data");
Enter fullscreen mode Exit fullscreen mode

Node.js JavaScript Can: 

// Read and write files
const fs = require("fs");
const content = fs.readFileSync("data.txt", "utf8");
console.log(content);

// Create an HTTP server
const http = require("http");
const server = http.createServer((req, res) => {
  res.end("Hello from my server!");
});
server.listen(3000);

// Access the operating system
const os = require("os");
console.log(`CPU: ${os.cpus()[0].model}`);
console.log(`Free memory: ${os.freemem() / 1024 / 1024} MB`);
Enter fullscreen mode Exit fullscreen mode

Comparison Diagram 

┌──────────────────────────┐    ┌──────────────────────────┐
│    Browser JavaScript    │    │       Node.js             │
├──────────────────────────┤    ├──────────────────────────┤
│                          │    │                          │
│  ✅ DOM manipulation     │    │  ❌ No DOM               │
│  ✅ window, document     │    │  ❌ No window, document  │
│  ✅ localStorage         │    │  ❌ No localStorage      │
│  ✅ alert(), prompt()    │    │  ❌ No alert/prompt      │
│  ✅ fetch()              │    │  ✅ fetch() (v18+)       │
│                          │    │                          │
│  ❌ No file system       │    │  ✅ File system (fs)     │
│  ❌ No HTTP server       │    │  ✅ HTTP server (http)   │
│  ❌ No OS access         │    │  ✅ OS info (os)         │
│  ❌ No child processes   │    │  ✅ Run commands (child) │
│                          │    │                          │
│  Shared:                 │    │  Shared:                 │
│  ✅ console.log          │    │  ✅ console.log          │
│  ✅ setTimeout           │    │  ✅ setTimeout           │
│  ✅ Promises             │    │  ✅ Promises             │
│  ✅ async/await          │    │  ✅ async/await          │
│  ✅ JSON, Math, Array    │    │  ✅ JSON, Math, Array    │
│                          │    │                          │
└──────────────────────────┘    └──────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

The core JavaScript language (let, const, functions, arrays, Promises, async/await) is the same everywhere. It's the APIs available in each environment that differ.

Event-Driven Architecture

One of the biggest reasons Node.js became popular is its event-driven, non-blocking architecture. This is the same concept we covered in the async JavaScript articles, but applied to servers.

Traditional Server Model (PHP, Java) 

Request 1 arrives → Thread 1 handles it → waits for database...
Request 2 arrives → Thread 2 handles it → waits for file...
Request 3 arrives → Thread 3 handles it → waits for API...
Request 4 arrives → No free threads! → WAIT IN LINE

Each request gets its own thread.
Threads wait (block) during I/O operations.
More requests = more threads = more memory.
Enter fullscreen mode Exit fullscreen mode

Node.js Model 

Request 1 arrives → Start handling → database call? Hand it off, move on
Request 2 arrives → Start handling → file read? Hand it off, move on
Request 3 arrives → Start handling → API call? Hand it off, move on
Request 4 arrives → Start handling immediately!

ONE thread handles all requests.
I/O operations are non-blocking — Node doesn't wait.
When data comes back, a callback/event fires.
Enter fullscreen mode Exit fullscreen mode

Node.js Runtime Architecture 

┌──────────────────────────────────────────────────┐
│                   Node.js                         │
│                                                  │
│  ┌──────────────────────────────────────┐        │
│  │           Your JavaScript            │        │
│  │    (server logic, routes, etc.)      │        │
│  └──────────────┬───────────────────────┘        │
│                 │                                │
│  ┌──────────────┴───────────────────────┐        │
│  │           Event Loop                  │        │
│  │    (checks for completed I/O,        │        │
│  │     runs callbacks when ready)        │        │
│  └──────────────┬───────────────────────┘        │
│                 │                                │
│  ┌──────────────┴───────────────────────┐        │
│  │       libuv (C++ library)             │        │
│  │    (handles file I/O, networking,    │        │
│  │     timers, and thread pool)          │        │
│  └──────────────┬───────────────────────┘        │
│                 │                                │
│  ┌──────────────┴───────────────────────┐        │
│  │           V8 Engine                   │        │
│  │    (compiles and runs JavaScript)     │        │
│  └──────────────────────────────────────┘        │
│                                                  │
└──────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

This is why Node.js can handle thousands of simultaneous connections with minimal resources. It doesn't create a new thread for each request — it uses one thread with an event loop, handling I/O asynchronously.

Node.js vs Traditional Backend — Comparison

Feature Node.js PHP / Java / Ruby
Language JavaScript PHP / Java / Ruby
I/O Model Non-blocking, event-driven Blocking (typically)
Concurrency Single thread + event loop Multi-threaded
Best for Real-time apps, APIs, I/O-heavy CPU-heavy computation
Package manager npm (largest in the world) Composer / Maven / Gems
Learning curve Easy if you know JS New language to learn
Full-stack sharing ✅ Same language front & back ❌ Different languages
JSON handling Native (it's JavaScript!) Needs parsing/serialization

Real-World Use Cases of Node.js

1. REST APIs and Web Servers

The most common use case. Node.js with Express.js is one of the most popular ways to build APIs:

const express = require("express");
const app = express();

app.get("/api/users", (req, res) => {
  res.json([
    { name: "Pratham", role: "developer" },
    { name: "Arjun", role: "designer" },
  ]);
});

app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});
Enter fullscreen mode Exit fullscreen mode

2. Real-Time Applications

Chat apps, live notifications, collaborative editors — anywhere data needs to flow instantly between server and client:

  • WhatsApp Web — real-time messaging
  • Trello — live board updates
  • Google Docs — collaborative editing

3. Streaming Applications

Netflix uses Node.js for streaming. Its non-blocking nature makes it perfect for handling large amounts of data flowing continuously.

4. Command-Line Tools

npm, webpack, ESLint, Prettier — these are all built with Node.js. You've been using Node.js tools without even realizing it.

5. Full-Stack JavaScript (MERN Stack)

This is what I'm learning in the cohort:

MongoDB   → Database
Express   → Backend framework (Node.js)
React     → Frontend library
Node.js   → Runtime for the backend

One language — JavaScript — for the ENTIRE stack.
Enter fullscreen mode Exit fullscreen mode

Companies Using Node.js

  • Netflix — migrated from Java, saw 70% startup time reduction
  • PayPal — rebuilt from Java, doubled requests per second
  • LinkedIn — moved from Ruby, reduced servers from 30 to 3
  • Uber — uses Node.js for its massive real-time system
  • NASA — uses Node.js for space suit data processing

Why Developers Adopted Node.js

Let me summarize the reasons Node.js took over:

Reason Explanation
One language everywhere Frontend + backend + tools — all JavaScript
npm ecosystem 2+ million packages. Need something? It probably exists.
Non-blocking I/O Handles thousands of connections without thread overhead
Fast execution V8 compiles to machine code, not interpreted
JSON native JavaScript is the language of JSON. No parsing overhead.
Active community Massive open-source ecosystem and constant innovation
Full-stack sharing Share validation logic, types, and utilities between front and back

Let's Practice: Hands-On Assignment

Part 1: Run JavaScript with Node.js

Create a file called server-basics.js:

console.log("Running on Node.js!");
console.log("Version:", process.version);
console.log("Platform:", process.platform);
console.log("Current directory:", process.cwd());
Enter fullscreen mode Exit fullscreen mode

Run it: node server-basics.js

Part 2: Read a File

Create message.txt with any text, then:

const fs = require("fs");

try {
  const content = fs.readFileSync("message.txt", "utf8");
  console.log("File contents:", content);
} catch (error) {
  console.log("Error reading file:", error.message);
}
Enter fullscreen mode Exit fullscreen mode

Part 3: Create a Simple HTTP Server 

const http = require("http");

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello from my first Node.js server! 🚀");
});

server.listen(3000, () => {
  console.log("Server running at http://localhost:3000");
});
Enter fullscreen mode Exit fullscreen mode

Run it and visit http://localhost:3000 in your browser.

Key Takeaways

  1. Node.js is a JavaScript runtime, not a language or framework. It lets you run JavaScript outside the browser — on servers, in terminals, anywhere.
  2. It's built on Chrome's V8 engine, which compiles JavaScript to machine code for fast execution.
  3. Node.js uses an event-driven, non-blocking I/O model — one thread handles many connections efficiently, making it ideal for real-time apps and APIs.
  4. Same language, different APIs — browser JS has document and window; Node.js has fs, http, and os. The core language is identical.
  5. Node.js enabled the full-stack JavaScript revolution. One language for frontend, backend, and tooling — which is exactly what the MERN stack is built on.

Wrapping Up

Node.js didn't just make JavaScript run on servers — it changed the entire web development landscape. Before Node.js, being a "full-stack developer" meant knowing JavaScript and PHP or Java. After Node.js, it means knowing JavaScript really well. One language, one ecosystem, one way of thinking — from the browser to the database.

I'm learning all of this through the ChaiCode Web Dev Cohort 2026 under Hitesh Chaudhary and Piyush Garg. Node.js is where everything I learned about JavaScript — async/await, modules, error handling — starts being applied to real server-side development. It's where the MERN stack journey begins.

Connect with me on LinkedIn or visit PrathamDEV.in. More articles on the way as the journey continues.

Happy coding! 🚀

Written by Pratham Bhardwaj | Web Dev Cohort 2026, ChaiCode

Top comments (0)