Node.js · Beginner interview

Node.js is a runtime that lets you run JavaScript outside the browser, built on Chrome's V8 engine. It's event-driven and non-blocking, which makes it well suited to I/O-heavy services — REST and GraphQL APIs, real-time apps, CLIs, and tooling. You'd reach for it when you want one language across the stack and high throughput on I/O rather than CPU-bound work.

Your JavaScript runs on a single main thread, but Node isn't purely single-threaded: I/O is delegated to libuv, which uses the OS and a small thread pool, and results come back via the event loop. So while one request waits on the database, the single thread is free to handle others. It scales well for I/O, but CPU-heavy work blocks that one thread and hurts everyone.

There's no DOM, window, or document in Node, and no direct user UI. Instead you get server APIs — the filesystem, networking, processes, and modules like fs, http, and path — plus globals like process and Buffer. The browser sandboxes you for safety; Node gives you access to the machine.

CommonJS (require / module.exports) is Node's original module system: synchronous and the default in .cjs or plain .js without "type": "module". ES modules (import / export) are the standard, support static analysis and top-level await, and are enabled by "type": "module" or .mjs files. The main practical differences are syntax, that ESM is asynchronous, and that you can't use require and import interchangeably without care.

// CommonJS
const fs = require("fs");
module.exports = doThing;
// ES modules
import fs from "fs";
export default doThing;

package.json is the manifest for a Node project — its name, version, scripts, and the packages it needs. dependencies are required at runtime in production (e.g. express); devDependencies are only needed while developing or building (e.g. typescript, eslint, test runners) and are skipped with npm install --production. Keeping them separated keeps production installs lean.

npm is Node's package manager and registry — it installs dependencies into node_modules and runs scripts. package-lock.json records the exact resolved version of every package (including nested ones) so installs are reproducible across machines and CI; you commit it. node_modules itself is generated and gitignored.

A callback is a function you pass to an async operation to run when it finishes. Callback hell is the deeply nested, hard-to-read pyramid you get when callbacks depend on each other, which also makes error handling repetitive. Promises and async/await were introduced to flatten that nesting.

A promise represents a value that will exist later and can be chained with .then/.catch instead of nesting callbacks. async/await is syntax on top of promises that lets you write asynchronous code that reads top-to-bottom, with normal try/catch for errors. It's the same machinery — await just pauses the function until the promise settles.

async function load(id) {
  try { return await db.user(id); }
  catch (e) { logError(e); throw e; }
}

fs.readFileSync is blocking: it stops the single thread until the file is read, which is fine in a startup script but bad in a server because it freezes all other requests. fs.readFile is non-blocking: it returns immediately and delivers the result via a callback or promise, letting the event loop keep serving other work. Prefer the async versions in anything that handles concurrent requests.

Use the built-in http module: createServer takes a handler that receives the request and response, and you call listen on a port. For real apps most people use a framework like Express on top of this, but the core module is what's underneath.

const http = require("http");
http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello");
}).listen(3000);

Express is a minimal web framework for Node that adds routing, middleware, and convenient request/response helpers over the raw http module. You use it because it removes the boilerplate of parsing URLs, handling methods, and wiring up middleware, letting you define routes like app.get('/users', handler) cleanly.

Middleware are functions that run in order during a request, each receiving (req, res, next). They can read or modify the request and response, end the response, or call next() to pass control along. They're how you add cross-cutting behaviour like logging, body parsing, authentication, and error handling.

app.use((req, res, next) => { console.log(req.method, req.url); next(); });