Master Node.js: From Basics to Production

Node.js is an open source, cross-platform runtime environment and library that is used for running web applications outside the client’s browser.

Node.js is an open-source and cross-platform JavaScript runtime environment.

It is a popular tool for almost any kind of project! Node.js runs the V8 JavaScript engine, Google Chrome’s core, outside the browser.

Node.js is a cross-platform runtime, perfect for a wide range of use cases.

Its huge community makes it easy to get started. It uses the V8 engine to compile JavaScript and runs at lightning-fast speeds.

Node.js was written initially by Ryan Dahl in 2009, about thirteen years after the introduction of the first server-side JavaScript environment, Netscape’s LiveWire Pro Web.

Both the browser and Node.js use JavaScript as their programming language.

Building apps that run in the browser is entirely different than building a Node.js application. Even though it’s always JavaScript, some key differences make the experience radically different.

The usual way to run a Node.js program is to run the globally available node command (once you install Node.js) and pass the name of the file you want to execute.

We split our code into different files to maintain, organize and reuse code whenever possible.

A module system allows us to split and include code and import code written by other developers whenever required.

Modules are the collection of JavaScript codes in a separate logical file that can be used in external applications based on their related functionality.

There are two ways to create modules in Node.js i.e. either via CommonJS or ESM.

In browsers, the top-level scope is the global scope, and its global object is called the window object.

Within the browser, var something will define a new global variable inside the window object.

In Node.js, this is different.

npm is the standard package manager for Node.js.

NodeJS and NPM allow two methods of installing dependencies/packages: Local and Global.

This is mainly used when adding a package or dependency as part of a specific project you’re working on.

Locally installed packages are available only to the project where the packages are installed, while the globally installed packages can be used any where without installing them into a project.

Another use case of the global packages is when using CLI tools.

npm provides various features to help install and maintain the project’s dependencies.

Dependencies get updates with new features and fixes, so upgrading to a newer version is recommended. We use npm update commands for this.

In Node.js, npm scripts are used for the purpose of initiating a server, starting the build of a project, and also for running the tests. We can define this scripts in the package.json file of the folder. Also, we can split the huge scripts into many smaller parts if it is needed.

npm packages allow you to bundle some specific functionality into a reusable package which can then be uploaded to some package registry such as npm or GitHub packages and then be installed and reused in projects using npm.

JavaScript uses Error objects to describe failures. Common built-in subclasses include TypeError for an invalid type, RangeError for a value outside an allowed range, ReferenceError for an unresolved name, and SyntaxError for invalid syntax. Other error classes, such as AggregateError, also exist.

In Node.js, system operations can produce errors with codes such as ENOENT. Read the error name, message, and code when present; do not assume a fixed exhaustive list of error types.

User specified errors can be created by extending the base Error object, a built-in error class.

When creating errors in this manner, you should pass a message string that describes the error.

An AssertionError in Node.js is an error that is thrown when the assert module determines that a given expression is not truthy.

The assert module is a built-in Node.js module that provides a simple set of assertion tests that can be used to test the behavior of your code.

When a JavaScript error is not properly handled, an uncaughtException is emitted.

These suggest the programmer has made an error, and they should be treated with the utmost priority.

The stack trace is used to trace the active stack frames at a particular instance during the execution of a program.

The stack trace is useful while debugging code as it shows the exact point that has caused an error.

Node.js includes a command-line debugging utility.

The Node.js debugger client is not a full-featured debugger, but simple stepping and inspection are possible.

npx runs a command from a package. It uses npm exec behavior: npm first looks for a matching local dependency and may download a missing package into the npm cache for the command. This avoids a permanent global installation, but it does not mean no package files are installed at all.

Use it for a one-time tool invocation, such as npx create-vite. Review the package and version before running code from a registry. The old standalone npx package is deprecated; npx is distributed with modern npm.

Node.js, being an asynchronous platform, doesn’t wait around for things like file I/O to finish - Node.js uses callbacks.

A callback is a function called at the completion of a given task; this prevents any blocking, and allows other code to be run in the meantime.

The setTimeout runs a function after the specified period expires.

Times are declared in milliseconds.

setInterval(callback, delay) schedules repeated callback execution with a delay measured in milliseconds. The timing is approximate: a busy event loop can postpone a callback. It returns a timer object that can be passed to clearInterval() to stop further calls.

Unlike setTimeout(), it schedules repeated calls while active. Clear it when the repeated task is no longer needed; an active timer can keep a Node.js process running.

setImmediate(callback) schedules a callback for the event loop’s check phase, after the current poll phase. It runs once and returns an Immediate object that can be cancelled with clearImmediate().

It differs from setTimeout(callback, 0), which uses timer scheduling. Their relative order can vary when scheduled from top-level code; do not rely on one always running first.

The process.cwd() method returns the current working directory of the Node.js process.

The path module provides utilities for working with file and directory paths. It’s built-in to Node.js core and can simply be used by requiring it.

File System or fs module is a built in module in Node that enables interacting with the file system using JavaScript. All file system operations have synchronous, callback, and promise-based forms, and are accessible using both CommonJS syntax and ES6 Modules.

The __dirname in a node script returns the path of the folder where the current JavaScript file resides. __filename and __dirname are used to get the filename and directory name of the currently executing file.

The __filename in Node.js returns the filename of the executed code. It gives the absolute path of the code file. The following approach covers implementing __filename in the Node.js project.

The glob pattern is most commonly used to specify filenames, called wildcard characters, and strings, called wildcard matching.

User-friendly glob matching Based on fast-glob but adds a bunch of useful features.

fs-extra adds file system methods that aren’t included in the native fs module and adds promise support to the fs methods. It also uses graceful-fs to prevent EMFILE errors. It should be a drop in replacement for fs.

Chokidar is a fast open-source file watcher for node. js. You give it a bunch of files, it watches them for changes and notifies you every time an old file is edited; or a new file is created.

Command Line Applications are applications that can be run from the command line. They are also called CLI (Command Line Interface) applications. Users can interact with clients entirely by terminal commands. They are very useful for automation and building tools.

dotenv is a zero-dependency module that loads environment variables from a .env file into process.env. Storing configuration in the environment separate from code is based on The Twelve-Factor App methodology.

In Node. js, process. env is a global variable that is injected during runtime. It is a view of the state of the system environment variables. When we set an environment variable, it is loaded into process.env during runtime and can later be accessed.

Exiting is a way of terminating a Node.js process by using node.js process module.

The process.stdin is a standard Readable stream which listens for user input and is accessible via the process module. It uses on() function to listen for input events.

Prompts is a higher level and user friendly interface built on top of Node.js’s inbuilt Readline module. It supports different type of prompts such as text, password, autocomplete, date, etc. It is an interactive module and comes with inbuilt validation support.

Inquirer.js is a collection of common interactive command line interfaces for taking inputs from user.

It is promise based and supports chaining series of prompt questions together, receiving text input, checkboxes, lists of choices and much more.

The process.stdout property is an inbuilt application programming interface of the process module which is used to send data out of our program. A Writable Stream to stdout. It implements a write() method. console.log() prints to the process.stdout.write() with formatted output or new line.

Chalk is a clean and focused library used to do string styling in your terminal applications. With it, you can print different styled messages to your console such as changing font colors, font boldness, font opacity, and the background of any message printed on your console.

This package aims to fully implement the FIGfont spec in JavaScript, which represents the graphical arrangement of characters representing larger characters. It works in the browser and with Node.js.

CLI-Progress is a package that provides a custom progress bar for CLI applications.

process.argv is an array of parameters that are sent when you run a Node.js file or Node.js process.

Commander is a light-weight, expressive, and powerful command-line framework for node.js. with Commander.js you can create your own command-line interface (CLI).

API is the acronym for Application Programming Interface, which is a software intermediary that allows two applications to talk to each other.

Express is a node js web application framework that provides broad features for building web and mobile applications. It is used to build a single page, multi-page, and hybrid web application.

Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture, inspired by Hapi and Express.

NestJS organizes server-side applications into modules. Controllers receive requests, while providers hold reusable logic and can be injected as dependencies. This structure helps separate routing from business behavior. A small service may need little framework setup; choose modules and providers when the application benefits from explicit organization.

Ky is a small HTTP client built on the Fetch API. It supports modern browsers and current Node.js versions with native Fetch, as well as other JavaScript runtimes. It provides a compact API for requests and JSON responses.

Compared with plain fetch(), Ky offers method shortcuts, retry behavior, timeouts, and configurable defaults. Check the installed Ky version’s runtime requirements before using it in a Node.js project.

During development, a file watcher such as node --watch app.js or nodemon can restart an application when its source changes. This shortens the edit-and-test cycle, but a watch flag does not by itself supervise a production service.

For production, use a process manager or hosting platform with restart policies, logs, health checks, and controlled deployment. Investigate repeated crashes instead of relying on automatic restarts alone.

Run node --watch app.js to start Node.js in watch mode. When the entry file or a required or imported module changes, Node.js restarts the process. This is useful during development, where it shortens the edit-and-restart cycle.

Watch mode requires a script path. It does not preserve in-memory state across restarts, and it is not a substitute for a production process manager. Use --watch-path only when you need to select particular watched paths; platform support for that option differs.

A native database driver lets a Node.js application connect directly to a particular database without an ORM abstraction. For example, the official MongoDB Node.js driver connects to MongoDB and exposes operations on databases and collections. SQL databases have their own driver packages and APIs.

Choose a driver that matches the database and supported Node.js version. Open a connection or pool, run queries or commands, handle errors, and close resources when the application shuts down. A driver gives direct control over database operations; an ORM adds a higher-level mapping layer.

A production process manager such as PM2 can restart a Node.js application after a crash and keep it running in the background. Configure startup behavior, logs, and health checks so an operator can see whether the app is actually serving requests. A restart policy helps availability but does not fix the underlying crash; inspect logs and address repeated failures.

JavaScript callbacks in a typical Node.js process run on one main event-loop thread. The runtime can perform asynchronous I/O and use an internal worker pool, so the entire application is not limited to one operating-system thread.

For CPU-heavy JavaScript, node:worker_threads can run code on additional threads. Child processes provide separate process isolation. Choose the model based on the task and measure the overhead of creating and communicating with workers.

The built-in Node.js inspector supports breakpoints, stepping, and examining values while code runs. Start a script with node inspect app.js for a command-line debugging session, or use --inspect to connect a compatible DevTools client. Keep the inspector endpoint private because a connected debugger can control the process.