The Complete Node.js Backend Developer Bootcamp (2026)

Install and verify NodeJS on your system by downloading from nodejs.org, selecting LTS or current, then use the node cli to run JavaScript and check the version with node -v.

Explore the Node.js file system module to create, write, read, and delete files using fs methods like writeFile, readFile, and unlink, with callbacks and utf eight encoding.

Discover how the global object in Node exposes console and process for stdout and stdin, using console.log and write with newline, handling data events, and exiting with process.exit.

Learn to require the readline module to create a terminal interface, prompt questions with the question method, handle the answer in a callback, and log results to the terminal.

Explore node.js core modules path and util by using path.basename to get the file name, path.join to build custom paths, and util.log for timestamped logging of __filename and __dirname.

Create custom modules in node.js by building a logger that writes to app.log. Export default and named members, then import via require in main.js using a config object.

Learn to export a custom module and import it into another file, using default and named exports, testing with console.log, and handling path and module exports in Node.js.

Use the fs module to interact with the file system, list directories and read directory contents synchronously, then console.log the results to reveal the directory's files.

Learn how to read text files in Node.js by importing modules, using fs.readFileSync to read synchronously, handling buffers, and setting encoding to utf-8 to output readable text.

Learn to write and append to files with fs.writeFile, using the append flag a or a+ to create new files or replace existing ones.

Create directories with the node file system module using mkdir and fs.existsSync to handle existing paths, preventing errors, and verify by running main.js.

Rename, move, and delete files in Node.js using the fs renameSync method, renaming within and across directories, replacing filenames, and removing files with unlink.

Learn to rename and move directories in Node.js using fs.renameSync, by relocating the images folder into the images files directory, then handle non-empty directories by removing files first before deleting.

Explore how readable streams handle asynchronous, chunked data from files, using fs.createReadStream with utf-8 encoding to process text and log data chunks until the stream ends.

Create a writable stream from the file system module and copy data from a readable stream to a new file. Close the writable stream when finished and verify the copy.

Learn to connect a readable and writable stream with pipes, pass the readable stream data to the right stream in one line, and handle errors, avoiding manual data events.

Install NodeJS to get npm, check npm -v, then start a new NodeJS project with npm init, answer prompts, and generate a package.json with default values (npm init -y).

Explore external modules in Node.js by installing lodash with npm, managing dependencies in package.json and package-lock.json, and using require to sort numbers with lodash's sortBy in index.js.

Identify the difference between dependencies and dev dependencies in a Node.js project by examining package.json, npm install flags, and how eslint vs moment are used in production and development.

Automate project tasks with npm scripts, running the start command instead of direct node calls. Use nodemon to auto restart on changes, with index.js as the entry point.

Explore how callbacks drive asynchronous JavaScript operations by passing a function as an argument, using setTimeout to simulate delay, and logging the results with an arrow function.

Learn how promises simplify asynchronous JavaScript by creating and returning promise objects, handling resolve and reject outcomes, chaining then methods, and catching errors with catch in data fetch scenarios.

Learn to handle asynchronous operations with async/await, replacing the then/catch syntax. Use try/catch for errors and fetch data with a promise in a practical Node.js backend context.

Explore how Node.js enables web tools and sharing via the client-server web, and learn the fundamentals of http, rest, and api design with endpoints, methods, and data formats.

Initialize an npm project, install nodemon, and build a Node.js http server that listens on port 3000 and responds with a hello Node.js http server message.

Explore how headers drive http communication by configuring response and request headers, using content-type to control rendering, and understanding status codes like 200 for successful requests.

Learn to handle get requests by filtering http methods with an on event listener, responding with hello for get and 405 method not allowed for others, using content-type text plain.

Learn to return json responses and handle urls with a /products route that serves a json array of products, using content-type application/json and 404 not found for others.

Handle post requests by serving an HTML form at the root route and posting new products to /products. Parse the request body to add them to the products array.

Parse urlencoded post data in a Node.js server with a promise-based parse function to extract the product name and update the products array, returning a product created message.

Explore how middlewares run before routes and share data via the rack object, then validate requests and handle errors with 400 status codes.

Install express as a dependency, create an express app in index.js, configure routes and middleware, and start the server on port 3000 to run a readable Node.js API.

Build and test express middlewares by using app.use to intercept every request, access req and res, and chain multiple middlewares with next to handle API flows.

Explore how Express middleware sits between requests and responses, uses next to pass control, and how app.use order shapes the request pipeline and final responses.

Explore how express routes differ from middleware, filter requests by url and http method, and implement root and specific routes like add product, then test with postman.

Parse incoming request bodies with express.json and express.urlencoded to make the body available to route handlers, supporting json and urlencoded data and comparing extended true versus false.

Learn path prefix filtering in Express by using an admin prefix to group admin routes, differentiating routes like admin and shop, and improving security and maintainability of the API.

Create a product model with name, price, and id to enforce a consistent data structure, and implement a save method that writes to a json file via fs and path.

Create and save a new product with name and price from the request body via the product model in admin routes, then respond with json and appropriate http status codes.

Change shop router to fetch multiple products via a static find all method on product model, reading data with the fs read file sync method and parsing JSON.

Master error handling in express.js using promises and async/await, with try/catch and 500 json errors, and refactor routes into controllers for adding and retrieving products.

Build a static async deleteOne method on the product model to remove a product by id from a JSON file database, using fs readFile, JSON stringify, and writeFile.

Learn to implement a delete one route in express using url params, convert id to a number, handle async/await with try/catch, and return a 200 or 500 response.

Explore TypeScript basics by declaring typed variables (string, number, object), enforcing types with annotations, defining typed functions and return types, and using optional and union types.

Learn to define object types with interfaces, use generic interfaces for login, adopt type aliases, and employ enums to constrain statuses; implement an async login using a promise.