The Complete Node.js Backend Developer Bootcamp (2026) + AI

Node.js Backend Essentials

Take your 6 cheat sheets

Installing Nodejs

Working with the file system

The Global Object

The readline module

Working with path and util modules

Building our own Custom modules

Exports and imports

Listing directory files

How to Read files in Nodejs

Write & append to files

Creating directories

Rename, move and remove files

Rename, move and remove directories

Quiz 1

Readable stream in Nodejs

Writable Stream in Nodejs

Working with Pipes

Working with npm

Working with external modules

Installing, Managing and Updating npm packages

Working With Dependencies and Devdependencies

Using npm Scripts To Automate tasks

Asynchronous Programming In Nodejs | an Overview

Working With Callbacks

Working with Promises

Working with Async/Await syntax

Introduction to how the Web works and Rest APIs

Working with the HTTP module

Understanding Web Headers

Handling Get Requests

Returning JSON responses and handling URLs

Handling POSTs Requests

Parsing Request Body Data

Adding a Middleware and sharing data in the request

Unleashing the Power of Express.js: Your Gateway to Web Development

Installing expressjs

Working With Middlewares

Understanding How Middleware Works in Express.js

Handling Routes

Parsing Incoming Requests

Working with the Express Router

Path Prefix Filtering in Express.js: Navigating Your Routes with Precision

Creating a Product Model: Consistent Data Structure

Adding Products: Using Product Model and The Fake Database

Fetching Products from the API

Mastering Error Handling in Express.js: Keeping Your App Robust and Reliable

Building a deleteOne Method for Your Product Model

Understanding Dynamic Route Parameters in Express.js

Leave your honest review for the course

Git Mental Model & Everyday Workflow

The Timeline reconcile - Branches, Merges and Rebasing

Working with Remotes and Github - Team Collaboration

Git First-Aid : Diagnosing mistakes, safely undoing changes and recovering

Next Lectures are OPTIONAL

Git for Real Team Work: Workflows, Governance, and Integration Dynamics

Git Power Tools for Developers: complex version control workflows

Git Internals: Demystifying the Black Box

Professional Git: Large Repositories, Performance & Governance

Installing and Configuring Typescript

Basic typescript

Advanced typescript

Branded Types & Opaque Types for Security

Discriminated Unions & The never Type

Deep Immutability for State Management

Constrained Generics for Data Repositories

The Result Pattern (Functional Error Handling)

Exercise: The Multi-Region Cloud Deployment

Continue learning Enterprise Typescript

What you will learn in this Project

Introduction

Install nodejs

Project setup with Typescript

Using Express JS

Compiling and Running Our Project

Using Nodemon

Using Body-parser to Parse Requests

You can use express.urlencoded() && express.json() instead

Urlencoded=> extended: false | important

MongDB Atlas & mongoose

Connecting Mongoose

Create the Post model

Create the Comment model

Build the create post router

Error handler middle-ware

Save posts through mongoose

Updating posts using mongoose

Deleting and Reading a post

Fix: post/show router

Creating comments

Deleting comments

Using all routers

CORS Security Protocol

Test our API with Postman

What you will learn

Building the Signup route 1/2 and the User Model

Building the Signup route 2/2

Building the Signin route

Finishing the Signin route Part and adding the Authentication service

Use jwt and cookie session | signin and signup

Add expiration date to jwt token

Building the authorization middleware

Building the CurrentUser route and Learning about Password Hashing

Require auth middle-ware + signout router

Advanced Auth Architecture

Create a custom error abstract class

Bad request error

Not found error

Not authorized error

Database error

Use all errors inside our app

Error handler middle-ware

Update user model | use typescript with mongoose

Update all models | use typescript with mongoose

Use the build method when we create a new doc

Add post to user document

Update userDoc when we delete a post

Images uploader middle-ware

Use images uploader middle-ware

Save images to post document

Don't use file.buffer

Deleting Images

Adding images

Validate user input with express-validator

Handle validation errors

Validation request middle-ware

Bonus: Error Handling with TS - The Result Pattern (Functional Error Handling)

Don't use mongoDb cloud inside a test environment

Setting up the test environment

Declare a signin global method

Creating the Jest configuration file

Creating test suite for the current user route

Creating a test suite for the signup route

More exciting projects and content

What you will learn

Discover The Architecture of a Senior Developer: Building for the AI Era

Section introduction

Let's talk about the project structure

Download the complete project

Initiate the common package

Publish our package to npm

Fix1: npm package

Fix2: npm package

Structure our code and run the app

Express.urlencoded() && express.json()

Urlencode: extended false

Structure & create user model

User model types

User service

Auth service & signup method

Create and use the authentication service | common package

Signin method + password hash

Auth routers

Use auth routers inside app.module

Test the auth routers with postman

Push our code to github

Building the Product Model

Uploader class | common package

Use the Uploader class middle-wares

Create product method | product.service

Finish new product router

Don't use file.buffer | and fix the upload path

The Uppdate Product router

Understand instanceof Error

Delete product

Add/delete images to/from an existing product

Stage everything, and create a git commit then push to github

What if we want to edit the last commit?

How are going to build the cart model

Building the cart and the productCart models

Building the cart service

Add product to cart | cart service

Update product quantity | cart service

Remove cartProduct from cart

Create addProduct method | buyer service

Create "cart/add" router | buyer.routers

1/2 - update cartProduct quantity | buyer.service

2/2 update cartProduct quantity | buyer.service

Update cartProduct quantity router | buyer.router

Don't send null to the client

Delete product from cart & get cart routers

Introduction

Stripe secret key

Stripe implementation & the checkout method

Create new Customer and save customer_id

Creating the Order model + service

Create new order

Update customer stripe card

Let's make a payment with stripe!

Github/actions | automated build

Github/actions | automated deployment

Deploying our api

Deploy with netlify

What you will learn

What is graphql?

Project introduction | the rooms concept

Full project | downloadable

Initialize a new project and Defining the Graphql schema

Building the Auth resolver

Generate typescript from schema automatically

Setup Apollo Server inside src/module.ts

Run apollo server & test graphql endpoint

Install & config typeorm

Defining the User entity

Create user method | user.service

App Data source

Creating the signup resolver

Signin resolver

CurrentUser resolver & graphql context

Docker Fundamentals

Docker images and dockerfiles

Docker networking: Containers, Pods, DNS & Container comunication

Important note about the next lectures - mini-Docker course

Install docker on linux

Images to containers

Containers to images

Running Postgres database with Docker

Test graphql endpoint

From db container to image - Docker

Creating the "room" Graphql schema

Auto generate and merge schemas

Creating the room resolver

Let's merge resolvers

Defining the "room" Entity

Create & update room | room service

CreateRoom resolver 1/2

CreateRoom resolver 2/2

GetRooms resolver

Test graphql endpoint

Implement validation with class validator

Catch validation errors

Why we should use socket io

Join rooms with socketio

Emit message to a specific room

Test socket Io server

Database migration with typeorm

Generate your first Nestjs project!

Setting up mongoose

Designing and Implementing The Blog Schema

Creating The Blog Service

Creating the Blog Controller 1/2

Creating the Blog Controller 2/2

Test the Blog Component with postman

Designing and Implementing The User Schema

Creating The User service

Creating The User Controller

Implementing authentication with Auth Guards

AI-Augmented Software Development: Ai-Assisted Coding

Coding Agents & Agentic IDEs: Repository-Aware Agents, Planning & more

Context Engineering For Coding Agents: Token Budgeting, Memory Systems & more

AI-Asissted Software Engineering Workflows

Multi-Agent & Agent-Team Development: Subagents, Parallel Coding Agents & more

AI Coding Quality & Verification: AI-Generated Code, Agent Harness & more

Secure & Responsible AI Coding

The AI-Naitive Engineering Workflow

Attention!

The Semicolon Law (Statements vs. Expressions)

Variables, Immutability, and the mut Contract

The Global Execution Trap (File Scope)

Blocks as Values (If/Else & Anonymous Blocks)

The Stack vs. The Heap (&str vs String)

The "Double Free" Illusion (Ownership)

Join the emailing list for more resources and tech news

Learn more Enterprise TypeScript: Architecture, Patterns, and AI Code Review

The 'Senior Architect' Blueprint: Master the 6 layers of Enterprise Architecture

Subscribe for Additional Resources, Industry News, Career tips and more

Why Everyone is Switching to Rust (A Code Deep Dive)