Node JS 2026: The Complete Modern Course ( Express, MongoDB)

Learn express.js, the popular Node.js framework, to build web apps by creating routes, handling requests, connecting to MongoDB, keeping projects organized, and securing with dotenv, with nodemon for automatic restarts.

Create a Node.js server with the Express framework by building index.js, installing express with npm, creating app, defining a get route, and listening on port 3000 to return hello world.

Explore Nodemon, a NodeJS library that automatically restarts your server when code changes are detected; install via npm, add a start script, and run using npm start.

Learn to create multiple routes in a node js app, use a port constant and template literals, and test routes like home, about, and contact.

Learn how to set up a MongoDB database, create a cluster and users, and connect using mongoose in a Node.js project with a connection string and npm installs.

Move secrets like API keys and passwords from code to environment variables using a .env file and the env library. Access them with process.env and confirm MongoDB connection.

Learn to structure NodeJS projects with modules, export functions via module.exports, and import them using require with correct relative paths, including named versus default exports and multi-folder organization.

Learn how to keep sensitive data safe by using a .gitignore file to prevent dot env and node_modules from being pushed to GitHub, GitLab, or Bitbucket.

Build, test, and debug complete APIs with Postman, implement CRUD with Express.js, and model data using Mongoose for MongoDB. Follow best practices for clean, scalable code and database integration.

Explore Postman, a popular API testing tool for sending HTTP requests, organizing collections, and automating tests. Download the tool, choose your OS, and create a collection named Inventory Management System.

Learn how back-end APIs use http status codes to indicate results, from 2xx success to 5xx server errors, with examples like 200 ok, 201 created, and 404 not found.

Post data to a database by creating a mongoose book schema and model, set up an express post route at /box with json body parsing to insert records.

Learn to fetch data from a database using a get route, define endpoints, test with postman, and return a json list with http 200 using app.get and find.

Learn how to handle errors in routes with try catch in node.js for post requests, wrapping code in a try block and returning a 400 with a JSON error message.

Learn to create a get by id endpoint for a book in Node.js, using app.get, route parameter, request.params, and model.find by id to return a json response.

Design and test a delete route using app.delete, fetch the id from request params, perform find by id and delete in a try-catch block, and return Bok deleted successfully.

Learn how to update data in a database using put for full updates and patch for partial updates, including updating by ID with request.body and returning the updated item.

Move routes into a dedicated routes folder using express router, export the router, and wire it into index.js with app.use, resulting in cleaner, modular endpoints.

Separate the route from index.js by adding a models folder with a box model (box.model.js) using mongoose and module.exports, then import it with require and enforce a required price.

Create a box schema virtual id that returns this._id as a hex string and enable virtuals so the api outputs id instead of underscore id for frontend use.

Enhance the book schema by adding validation rules for name, stock, price, and date created; implement custom messages, min/max lengths, and a url validator with postman testing.

Learn to validate user input in Node.js using Express Validator, ensuring email, password, and phone formats, adding custom rules, and integrating validation into reusable routes.

install and import express validator, then define a body-based validation middleware for book name, price, count in stock, and image. use validationResult to return 400 with errors when validation fails.

Learn to extend validation from creating parks to updating them by making fields optional, validating route params, and ensuring a valid Mongo ID, with postman testing and refactor plans.

Refactor your Node.js API by moving validation middlewares into a dedicated validators folder, defining reusable handle validation errors, exporting and applying them to create and update routes, with postman testing.

Import express validator param to create a reusable id validation middleware for mongo ids, apply it to get, update, and delete by id, export it, and handle validation errors.

Learn to add localization to a node.js application, enabling multi-language support and i18n in express, detecting and switching user language, with structured translations and maintainable translation files.

Learn how ISO 639-1 language codes enable localization by utilizing the accept-language HTTP header, which browsers and apps use to serve users in their preferred language.

Learn to implement localization with i18next, i18next-fs-backend, and i18next-http-middleware by loading translations from locales and configuring language detection, fallbacks, and multilingual routes.

Extend localization by updating index.js and book router to replace static strings with translation keys and req.t, adding Arabic and German translations for the three messages.

Learn how to localize validation messages by using translation keys, returning a function with request data, and generate English, German, and Arabic translations for robust Postman testing.

Master localization in update validation by using translation functions instead of strings, adding keys to English, German, and Arabic, and applying them to book name, price, stock, and ID validations.

Create JSON translation files for Spanish and Italian (codes es and it), generate translations via ChatGPT, and test in Postman; extend by adding Hindi or Chinese and test again.

Push your code to a GitHub repository by initializing a git repo, adding files, committing, renaming the branch to master, setting a remote, and pushing.

Deploy your NodeJS app to Render, connect GitHub, configure environment variables, and expose APIs with endpoints for listing and adding boxes, validating stock counts for front-end apps.

Build a secure, scalable e-commerce backend with authentication and authorization. Set up the project, configure environment variables, connect to MongoDB, localization, publishing, file uploads, and Morgan logging.

This lesson guides you to scaffold a multinational node.js e-commerce app: initialize npm, add locales with six translations, and install dot env, express, express validator, motor, and nodemon.

Create an express server in index.js, instantiate the app, listen on port 3000, and add a /health route that returns 'Hello NodeJS project'; run with nodemon and npm start.

Learn to manage environment variables with dotenv in a node js project, set the ecommerce MongoDB database, configure port and jwt secret, and test the health endpoint with mongoose.

Connect your Node.js app to MongoDB using mongoose. Configure the connection with an environment variable and log success or catch errors.

Add localization with i18next, backend, and language detector, initializing with a fallback to English and locales translations; test with req.t keys like validation field and resolve missing middleware.

Initialize a git repository, add a gitignore to exclude node_modules and .env, commit changes, and push to GitHub, so published code omits bulky files.

Enable cross-origin resource sharing (cors) to securely allow front-end apps on localhost 3000 to access back-end APIs on different origins by configuring origins, methods, credentials, and headers.

Create a category model with mongoose, including a name field and a virtual id for clean JSON output, then set up get, post, delete, and put routes.

Create a category endpoint using express router and the category model, handling json input via express.json, and test with postman to create the first category named category one.

Learn to use Postman environment variables to set a base URL, apply it to requests, post a category with validation for at least three characters, and translate errors.

Set up a get route to fetch categories from the database and return the category list. Implement try-catch error handling and a no categories message, then test with postman.

Implement a delete route with router.delete to remove a category by id, using async and try-catch, returning 404 when not found and a translated category deleted successfully message.

Update the category route with router.put to update by id, set the name from request.name, and return category updated successfully or category not found; test with Postman using mobiles.

Learn to integrate the Morgan http request logger into a Node.js express app, install and configure it with tiny or other formats, and interpret logs for debugging and production monitoring.

Learn to migrate from require to ES module imports in a Node.js project by updating package.json, refactoring imports across files, and adjusting exports, with practical testing of the API.

Define a Mongoose user model for the ecommerce app with email unique, password min 6, role enum of admin or user with default user, username trimmed, and automatic timestamps.

Add city, postal code, address line one and two, and phone number fields to the user model as strings, mark required fields, trim, and format the code.

Hash passwords with bcrypt using a pre-save middleware in a Node.js app, hashing only when the password changes, and using ten rounds of salt for secure storage.

Learn to implement password comparison by creating a user schema method that compares a plaintext password with the stored bcrypt-hashed password, enabling login and preventing sign-in with invalid credentials.

Master how to secure user data by adding a custom toJSON method that converts a mongoose document to a plain object, excludes the password, and returns id instead of _id.

Learn to build a register endpoint with express router, async error handling, and user model integration to register new users and respond with success or error messages.

Create a register validation using express validator to validate email, password, username, city, postal code, address line one, address line two optional, and phone number, with messages and a regex.

handle duplicated emails by manually checking for existing users in the register route: extract email from request.body, query for an existing user, and return an email already exists message.

Learn how to add and translate validator strings for the auth validator by generating camel case JSON translations with ChatGPT, updating invalid rules, and planning multilingual support.

Generate a JSON web token by signing a payload with user id, email, role, username, and phone, using env secret and expiration, then return it for authentication in the header.

Create login route that uses post request to fetch a user by email, verify the password, and return user data with a generated token or an error for invalid credentials.

Focus on the login task: check if the user exists; if not, set success to false and present a 'user not found' message for unregistered emails.

Practice implementing register and login validations in a Node.js app, using middleware to handle errors, validate email and password, and export reusable validators to obtain a token.

Remove duplications by creating a centralized error handling function, a mongoose plugin for common virtuals, and applying these changes across routes and models to streamline profile data endpoints.

Create an auth middleware that validates jwt tokens from the authorization header, decodes user data, attaches it to the request, and protects routes while exposing login and register as public.

Identify and expose public routes in a node auth middleware by excluding login and register endpoints, determine method and path, build a root, and test with Postman.

Create a secure get profile endpoint to fetch the logged-in user's data using the decoded token id, exclude the password, and plan a future profile update with error handling.

Create an update profile route with router.put and an async function, access the user id and body, update fields dynamically, save, and return the updated user data.

Update email flow ensures unique emails by checking existing users in the auth route before updating, excluding the current user, returning 'email already exists' on duplication.

Implement update profile validation using express validator in a Node.js course, adding an optional update validation array and middleware to the put profile route to handle errors.

Master the difference between authentication and authorization, and implement a role-based authorization middleware to enforce admin and user permissions for categories and products.

Create a product model for an e-commerce app using Mongoose, defining a comprehensive schema with title, category reference, price, description, images, stock, ratings, views, and timestamps, plus validation and middleware.

Create a product route in express, import the product model, and implement post request with parse float for price and parse int for stock, with error handling and postman testing.

Create a multer-based upload middleware in node.js to handle image uploads with disk storage in public/uploads, unique filenames, a five‑megabyte limit, image filter, and export single and multiple upload handlers.

Build a get file url function using request protocol and host to form image urls under public/uploads, then map uploaded images for product creation and test with form-data.

Fix the access token error by excluding public uploads path in OAuth middleware, then enable browser access by serving public/uploads with express.static, making uploaded images load in the browser.

Implement admin only access via middleware, and handle Multer upload errors with a dedicated middleware that returns localized messages for file size, file count, and missing file issues.

Implement post product validation with express validator, create product validation and error handling, and add a get products route with pagination and localization across languages.

Implement search and category filtering in a node js backend using query parameters, MongoDB $or filters, and regex on title or description.

Filter products by category using query parameters in the node js course and MongoDB find with an or search on title and description, including case-insensitive matching and postman testing.

Learn to enforce case sensitivity for query parameters in node.js express by aligning keys with request.query. Implement a conditional to return 'no products found' when the product list is empty.

Apply pagination by splitting large data into pages, sending ten products per page to speed up API calls, reduce memory usage, and improve load times for the product list.

Read page and limit from the query, compute skip, apply skip and limit to the query, count documents, and return page, limit, total pages, total count, and navigation flags.

Implement a router.get endpoint to fetch a product by id, use find by id and update to increment its views with Mongo's $inc, and return the product with category populated.

Build an admin-only delete product endpoint in node js using router.delete with an id and admin only middleware. Handle not found cases and verify admin token via postman.

Practice building a put request to update a product, with router put, admin and upload middlewares, optional update validation, find-by-id checks, and image handling for file uploads.

Build a Mongoose order model for an e-commerce app, defining order item schema with product ref, quantity and price, and an order schema with user, status, total price, and timestamps.

Learn to calculate the total price on the backend using order items and reduce price by quantity, with a pre save middleware to ensure security.

Create an order route with express, adding a post new order endpoint, validate order items, and enforce user or admin authentication for secure submissions.

Validate each order item for product existence, valid product id via mongoose, and proper quantity (numeric, at least one, and whole number) using a for loop and 400 error responses.

Add and validate translation keys for order item errors in english.json, test with Postman, and prepare localization keys for product, quantity, and stock messages.

Extract product IDs from order items, fetch matching products with a database query using $in to ensure they exist, validate stock, compute the total price, and save the new order.

Populate an order by enriching it with user and order items' product data for the front end.

Decrease stock after each order by looping through items and updating stock. Use a MongoDB decrement operator with find by ID and update, tested in postman.

Build a get orders route with an async handler, admin vs user checks, pagination, search, sorting by date, and MongoDB filtering.

master search in Node.js by using the or operator and the regex operator with case-insensitive matching, while avoiding population to balance performance and data transfer.

Learn to create a get order by id route in node, including id parameter handling, order lookup with populated user data, 404 handling, and admin versus user access control.

Create an admin-only delete by id endpoint for orders, protected by middleware, that finds the order by id and deletes it, returning 'order not found' or 'order deleted successfully'.

Create an admin-only patch endpoint to change order status (pending, processing, shipped, delivered, canceled), validate input, and return the updated order by id.

Implement a user-only cancel order endpoint with router.patch, validating order existence and ownership, blocking shipped or delivered orders, and restoring stock by increasing the product quantity.

Learn to handle file uploads in Node.js and Express using Molter, connect to Cloudinary, upload images to cloud storage, store the returned URLs, and complete a hands-on task.

Create a new Node.js app, set it to module, install nodemon and express with dotenv, configure port from .env (default 3000), and add a health endpoint.

Learn to set up Cloudinary uploads in Node.js by installing Cloudinary, configuring with env keys, using Cloudinary storage, and returning image URL and public ID.

Implement cloud-based image uploads by integrating Cloudinary into the e-commerce app, replacing public/uploads storage to address production concerns and ensure files are accessible across servers.

Install and configure Cloudinary with multer storage, set up image uploads, enforce formats and unique public IDs, and validate the url helper.

Learn the fix for updating a product by correctly handling image deletion with Cloudinary, correcting the upload segment, and using Promise.all to delete images while updating the product.

Build a Node.js mailing service with express and node mailer, configure dotenv for Gmail credentials, and implement a send email route that handles multiple recipients.

Explore how EI EBIs work and secure their keys from OpenAI and HuggingFace. Build a Node.js backend that uses OpenAI SDK and HuggingFace EBI to power an EI chat app.

Build an AI-chat architecture using backend security to hide EBI keys, choose OpenAI or HuggingFace models, and expose a secure Express POST chat endpoint with validation.

Learn to generate a chat gbt abi key on the OpenAI platform, set up an organization, and manage billing with a $5 credit.

Set up a Node.js project by initializing package.json and installing .env, express, node-mon, and OpenAI. Create index.js and .env, ignore .env and node_modules, and run on port 3000 with node-mon.

Create a post /chat endpoint in Node.js, load the port from dotenv, call OpenAI chat completions with system and user messages, and return the reply.

Secure the api key with a .env file. Build a chat post endpoint and route user messages to ObinAI with a model, using a system message to define AI behavior.

Learn how to obtain a free Hugging Face API key to access free AI models, create and store the token securely, and configure a .env entry for your node app.

Learn to call the HuggingFace chat completions API using axios, including setting the URL, body, and headers. Test free models such as llama and deep seek via the API.