What is Node.js? JavaScript on the Server Explained

You've heard about Node.js everywhere. Maybe you've wondered: "Why would anyone run JavaScript outside the browser?" This guide explains what Node.js is, why it exists, and why developers love it.

Before Node.js: JavaScript Was Browser-Only

JavaScript started in 1995 as a language for browsers. Its job was to add interactivity to web pages: validating forms, showing/hiding elements, animating things.

It worked great for that. But it had a limitation: it only ran in browsers. If you wanted to build a server, you used PHP, Python, Java, or other languages.

This meant developers had to learn two languages:

• JavaScript for the frontend

• Another language for the backend

Node.js: JavaScript on the Server

In 2009, Ryan Dahl created Node.js. It brought JavaScript runtime to servers.

Now developers could write both frontend and backend in JavaScript. One language, multiple environments.

// Frontend (browser)
document.getElementById('button').addEventListener('click', () => {
  console.log('Button clicked');
});

// Backend (Node.js)
import express from 'express';
const app = express();
app.get('/api/data', (req, res) => {
  res.json({ message: 'Data from server' });
});

Same language, different contexts.

What Exactly Is Node.js?

Node.js is a JavaScript runtime. A runtime is an environment where code executes.

A programming language is one thing. A runtime is the environment that understands and runs that language.

Think of it like this:

• Language: JavaScript (the syntax and rules)

• Runtime: Browser (for frontend), Node.js (for backend)

Node.js uses the V8 engine, the same JavaScript engine that powers Google Chrome. V8 compiles JavaScript to machine code, making it fast.

Why JavaScript, Though?

Developers already knew JavaScript. Instead of learning a new language for the server, they could use JavaScript everywhere.

Also, JavaScript is event-driven and asynchronous by design. This fits perfectly with server applications that handle many concurrent requests.

Node.js Architecture: High Level

When you run a Node.js application, here's what happens:

Your JavaScript Code
        |
        v
Node.js Runtime
  (V8 Engine + APIs)
        |
        v
Operating System
  (File system, networking, etc.)
        |
        v
Hardware

V8 compiles your JavaScript to machine code. The Node.js runtime provides APIs like fs (file system) and http (networking) that your code can use.

Node.js vs Browser JavaScript

Both run JavaScript, but differently:

Aspect	Browser	Node.js
Purpose	User interface	Server, CLI tools, servers
APIs	DOM, fetch, window	fs, http, path
File access	Restricted	Full file system access
Modules	ES modules	ES modules, CommonJS
Globals	window, document	global, process
Typical use	Web apps	APIs, services, scripts

In a browser, you manipulate the DOM. In Node.js, you work with the file system and network.

Real-World Use Cases

Building APIs and Web Servers:

import express from 'express';
const app = express();
app.get('/api/users', (req, res) => res.json({ users: [] }));
app.listen(3000);

Command-line Tools:

# Tools like npm, webpack, eslint are built with Node.js
npm install
webpack build
eslint --fix

Real-time Applications: Node.js handles concurrent connections well, perfect for chat apps, collaborative tools, live updates.

Scripting and Automation: Automate tasks, process files, generate reports.

Building single-page applications: Tools like webpack, Vite, and Next.js use Node.js.

The Event-Driven Architecture

Node.js is event-driven. Instead of threads doing work, events trigger handlers.

import fs from 'fs';

console.log('Starting...');

fs.readFile('data.txt', (err, data) => {
  console.log('File read complete');
});

console.log('Continuing...');

Output:

Starting...
Continuing...
File read complete

The file read doesn't block. While waiting, Node.js handles other things. When the file is ready, an event fires, triggering the callback.

This is why Node.js handles many concurrent requests efficiently. Most time is spent waiting for databases, files, or network responses. Node.js doesn't waste processor time on waiting.

Companies Using Node.js

Node.js powers major applications:

• Netflix: Node.js for UI and streaming

• Uber: Real-time ride matching

• LinkedIn: Real-time updates

• Walmart: API backend

• Airbnb: Backend services

These companies chose Node.js because it's fast, scalable, and lets them reuse developers across frontend and backend.

Node.js Ecosystem: npm

npm (Node Package Manager) is a package repository. Hundreds of thousands of packages are available, from HTTP frameworks to image processing.

Install packages easily:

npm install express
npm install lodash
npm install axios

This ecosystem is massive and active. Most problems you encounter, someone's already solved with a package.

Performance Considerations

Node.js is fast for I/O-bound tasks (database queries, file reads, HTTP requests). Most web applications are I/O-bound.

It's less ideal for CPU-intensive tasks (image processing, complex calculations). For those, you'd use worker threads or other languages.

But for typical web applications and APIs, Node.js performance is excellent.

Getting Started

To start with Node.js:

1. Install from nodejs.org

2. Create a file: hello.js

3. Write code: console.log('Hello')

4. Run: node hello.js

That's it. You're running JavaScript on your server.

Node.js vs Other Backend Languages

Language	Strengths	Typical Use
Node.js	Async, JavaScript everywhere	Web APIs, real-time apps
Python	Readable, ML/data science	Data science, scripting
Java	Mature, OOP, enterprise	Large systems, enterprises
Go	Simple, concurrent, fast	Microservices, DevOps
PHP	Easy deployment, shared hosting	Web hosting, WordPress

Each language has tradeoffs. Node.js excels at I/O-heavy applications where you want full JavaScript from frontend to backend.

Key Takeaways

• Node.js is a JavaScript runtime that lets you run JavaScript on servers

• It uses the V8 engine, the same engine that powers Chrome

• It's event-driven and asynchronous, perfect for handling many concurrent requests

• The npm ecosystem is massive with hundreds of thousands of packages

• Many major companies use Node.js for their backend infrastructure

• It's ideal for I/O-bound applications like web APIs and real-time apps

• Learning Node.js lets you build full-stack applications in JavaScript

Node.js democratized backend development. You no longer need to learn multiple languages. JavaScript everywhere has become reality.

If you know JavaScript, you can build servers. That's the power of Node.js.