Programming Languages


NodeJS - The Complete Guide (MVC, REST APIs, GraphQL, Deno)

Master Node JS & Deno.js, build REST APIs with Node.js, GraphQL APIs, add Authentication, use MongoDB, SQL & much more!

4.69 (22628 reviews)



40.5 hours


Nov 2020

Last Update
Regular Price

What you will learn

Work with one of the most in-demand web development programming languages

Learn the basics as well as advanced concepts of NodeJS in great detail

Build modern, fast and scalable server-side web applications with NodeJS, databases like SQL or MongoDB and more

Understand the NodeJS ecosystem and build server-side rendered apps, REST APIs and GraphQL APIs

Get a thorough introduction to DenoJS


Join the most comprehensive Node.js course on Udemy and learn Node in both a practical as well as theory-based way!


This course was updated to also include sections on Deno.js - in addition to more than 30 hours of content on Node.js!


Node.js is probably THE most popular and modern server-side programming language you can dive into these days!

Node.js developers are in high demand and the language is used for everything from traditional web apps with server-side rendered views over REST APIs all the way up to GraphQL APIs and real-time web services. Not to mention its applications in build workflows for projects of all sizes.

This course will teach you all of that! From scratch with zero prior knowledge assumed. Though if you do bring some knowledge, you'll of course be able to quickly jump into the course modules that are most interesting to you.

Here's what you'll learn in this course:

  • Node.js Basics & Basic Core Modules

  • Parsing Requests & Sending Responses

  • Rendering HTML Dynamically (on the Server)

  • Using Express.js

  • Working with Files and generating PDFs on the Server (on-the-fly)

  • File Up- and Download

  • Using the Model-View-Controller (MVC) Pattern

  • Using Node.js with SQL (MySQL) and Sequelize

  • Using Node.js with NoSQL (MongoDB) and Mongoose

  • Working with Sessions & Cookies

  • User Authentication and Authorization

  • Sending E-Mails

  • Validating User Input

  • Data Pagination

  • Handling Payments with Stripe.js

  • Building REST APIs

  • Authentication in REST APIs

  • File Upload in REST APIs

  • Building GraphQL APIs

  • Authentication in GraphQL APIs

  • File Upload in GraphQL APIs

  • Building a Realtime Node.js App with Websockets

  • Automated Testing (Unit Tests)

  • Deploying a Node.js Application

  • Using TypeScript with Node.js

  • Exploring Deno.js

  • And Way More!

Does this look like a lot of content? It certainly is!

This is not a short course but it is the "Complete Guide" on Node.js after all. We'll dive into a lot of topics and we'll not just scratch the surface.

We'll also not just walk through boring theory and some slides. Instead, we'll build two major projects: An online shop (including checkout + payments) and a blog.

All topics and features of the course will be shown and used in these projects and you'll therefore learn about them in a realistic environment.

Is this course for you?

If you got no Node.js experience, you'll love this course because it starts with zero knowledge assumed. It's the perfect course to become a Node.js developer.

If you got basic Node.js experience, this course is also a perfect match because you can go through the basic modules quickly and you'll benefit from all the deep dives and advanced topics the course covers.

Are you an advanced Node.js user? Check the curriculum then. Maybe you found no other course that shows how to use SQL with Node.js. Or you're interested in GraphQL. Chances are, that you'll get a lot of value out of this course, too!


  • NO Node.js knowledge is required at all!

  • NO other programming language knowledge (besides JavaScript, see next point) is required

  • Basic JavaScript knowledge is assumed though - you should at least be willing to pick it up whilst going through the course. A JS refresher module exists to bring you up to the latest syntax quickly

  • Basic HTML + CSS knowledge helps but is NOT required


NodeJS - The Complete Guide (MVC, REST APIs, GraphQL, Deno)
NodeJS - The Complete Guide (MVC, REST APIs, GraphQL, Deno)
NodeJS - The Complete Guide (MVC, REST APIs, GraphQL, Deno)
NodeJS - The Complete Guide (MVC, REST APIs, GraphQL, Deno)




What is Node.js?

Join our Online Learning Community

Installing Node.js and Creating our First App

Understanding the Role & Usage of Node.js

Course Outline

How To Get The Most Out Of The Course

Working with the REPL vs Using FIles

Using the Attached Source Code

Optional: JavaScript - A Quick Refresher

Module Introduction

JavaScript in a Nutshell

Refreshing the Core Syntax

let & const

Understanding Arrow Functions

Working with Objects, Properties & Methods

Arrays & Array Methods

Arrays, Objects & Reference Types

Understanding Spread & Rest Operators


Async Code & Promises

Template Literals

Wrap Up

Useful Resources & Links

Understanding the Basics

Module Introduction

How The Web Works

Creating a Node Server

The Node Lifecycle & Event Loop

Controlling the Node.js Process

Understanding Requests

Sending Responses

Request & Response Headers

Routing Requests

Redirecting Requests

Parsing Request Bodies

Understanding Event Driven Code Execution

Blocking and Non-Blocking Code

Node.js - Looking Behind the Scenes

Using the Node Modules System

Wrap Up

Useful Resources & Links

Improved Development Workflow and Debugging

Module Introduction

Understanding NPM Scripts

Installing 3rd Party Packages

Global Features vs Core Modules vs Third-Party Modules

Using Nodemon for Autorestarts

Global & Local npm Packages

Understanding different Error Types

Finding & Fixing Syntax Errors

Dealing with Runtime Errors

Logical Errors

Using the Debugger

Restarting the Debugger Automatically After Editing our App

Debugging Node.js in Visual Studio Code

Changing Variables in the Debug Console

Wrap Up

Useful Resources & Links

Working with Express.js

Module Introduction

What is Express.js?

Installing Express.js

Adding Middleware

How Middleware Works

Express.js - Looking Behind the Scenes

Handling Different Routes

Parsing Incoming Requests

Limiting Middleware Execution to POST Requests

Using Express Router

Adding a 404 Error Page

Filtering Paths

Creating HTML Pages

Serving HTML Pages

Returning a 404 Page

Using a Helper Function for Navigation

Styling our Pages

Serving Files Statically

Wrap Up

Useful Resources & Links

Working with Dynamic Content & Adding Templating Engines

Module Introduction

Sharing Data Across Requests & Users

Templating Engines - An Overview

Installing & Implementing Pug

Outputting Dynamic Content

Official Pug Docs

Converting HTML Files to Pug

Adding a Layout

Finishing the Pug Template

Avoiding an Error

Working with Handlebars

Converting our Project to Handlebars

Adding the Layout to Handlebars

Working with EJS

Working on the Layout with Partials

Wrap Up

[OPTIONAL] Assignment Solution

Useful Resources & Links

The Model View Controller (MVC)

Module Introduction

What is the MVC?

Adding Controllers

Finishing the Controllers

Adding a Product Model

Storing Data in Files Via the Model

Fetching Data from Files Via the Model

Refactoring the File Storage Code

Wrap Up

Useful Resources & Links

Optional: Enhancing the App

Module Introduction

Creating the Shop Structure

Working on the Navigation

Registering the Routes

Storing Product Data

Displaying Product Data

Editing & Deleting Products

Adding Another Item

Useful Resources & Links

Dynamic Routes & Advanced Models

Module Introduction


Applied Changes

Adding the Product ID to the Path

Extracting Dynamic Params

Loading Product Detail Data

Rendering the Product Detail View

Passing Data with POST Requests

Adding a Cart Model

Using Query Params

Pre-Populating the Edit Product Page with Data

Linking to the Edit Page

Editing the Product Data

Adding the Product-Delete Functionality

Deleting Cart Items

Displaying Cart Items on the Cart Page

Deleting Cart Items

Fixing a Delete Product Bug

Wrap Up

Useful Resources & Links

SQL Introduction

Module Introduction

Choosing a Database

NoSQL Introduction

Comparing SQL and NoSQL

Setting Up MySQL

Connecting our App to the SQL Database

Basic SQL & Creating a Table

Retrieving Data

Fetching Products

Fetching Products - Time to Practice

Inserting Data Into the Database

Fetching a Single Product with the "where" Condition

Wrap Up

Useful Resources & Links

Understanding Sequelize

Module Introduction

What is Sequelize?

Connecting to the Database

Defining a Model

Syncing JS Definitions to the Database

Inserting Data & Creating a Product

MUST READ: findById() in Sequelize 5

Retrieving Data & Finding Products

Getting a Single Product with the "where" Condition

Fetching Admin Products

Updating Products

Deleting Products

Creating a User Model

Adding a One-To-Many Relationship

Creating & Managing a Dummy User

Using Magic Association Methods

Fetching Related Products

One-To-Many & Many-To-Many Relations

Creating & Fetching a Cart

Adding New Products to the Cart

Adding Existing Products & Retrieving Cart Items

Deleting Related Items & Deleting Cart Products

Adding an Order Model

Storing Cartitems as Orderitems

Resetting the Cart & Fetching and Outputting Orders

Wrap Up

Useful Resources & Links

Working with NoSQL & Using MongoDB

Module Introduction

What is MongoDB?

Relations in NoSQL

Setting Up MongoDB

Installing the MongoDB Driver

Creating the Database Connection

Finishing the Database Connection

Using the Database Connection

Creating Products

Understanding the MongoDB Compass

Fetching All Products

Fetching a Single Product

Making the "Edit" & "Delete" Buttons Work Again

Working on the Product Model to Edit our Product

Finishing the "Update Product" Code

One Note About Updating Products

Deleting Products

Fixing the "Add Product" Functionality

Creating New Users

Storing the User in our Database

Working on Cart Items & Orders

Adding the "Add to Cart" Functionality

Storing Multiple Products in the Cart

Displaying the Cart Items

Fixing a Bug

Deleting Cart Items

Adding an Order

Adding Relational Order Data

Getting Orders

Removing Deleted Items From the Cart

Wrap Up

Useful Resources & Links

Two Adjustments (behind the scenes)

Working with Mongoose

Module Introduction

What is Mongoose?

Connecting to the MongoDB Server with Mongoose

Creating the Product Schema

Saving Data Through Mongoose

Fetching All Products

Fetching a Single Product

Updating Products

Deleting Products

Adding and Using a User Model

Using Relations in Mongoose

One Important Thing About Fetching Relations

Working on the Shopping Cart

Loading the Cart

Deleting Cart Items

Creating & Getting Orders

Storing All Order Related Data

Clearing the Cart After Storing an Order

Getting & Displaying the Orders

Wrap Up

Useful Resources & Links

Sessions & Cookies

Module Introduction

What is a Cookie?

The Current Project Status

Optional: Creating the Login Form

Adding the Request Driven Login Solution

Setting a Cookie

Manipulating Cookies

Configuring Cookies

What is a Session?

Initializing the Session Middleware

Using the Session Middleware

Using MongoDB to Store Sessions

Sessions & Cookies - A Short Summary

Deleting a Cookie

Fixing Some Minor Bugs

Making "Add to Cart" Work Again

Two Tiny Improvements

Wrap Up

Code Adjustments

Useful Resources & Links

Adding Authentication

Module Introduction

What is Authentication?

How is Authentication Implemented?

Our Updated Project Status

Implementing an Authentication Flow

Encrypting Passwords

Adding a Tiny Code Improvement

Adding the Signin Functionality

Working on Route Protection

Using Middleware to Protect Routes

Understanding CSRF Attacks

Using a CSRF Token

Adding CSRF Protection

Fixing the Order Button

Providing User Feedback

Optional: Styling Error Messages

Finishing the Flash Messages

Adding Additional Flash Messages

Wrap Up

Useful Resources & Links

Sending Emails

Module Introduction

How Does Sending Emails Work?

Using SendGrid

Using Nodemailer to Send an Email

Potential Limitation for Large Scale Apps

Useful Resources & Links

Advanced Authentication

Module Introduction

Resetting Passwords

Implementing the Token Logic

Creating the Token

Creating the Reset Password Form

Adding Logic to Update the Password

Why we Need Authorization

Adding Authorization

Adding Protection to Post Actions

Why Editing Fails

Wrap Up

Useful Resources & Links

Understanding Validation

Module Introduction

Why Should We Use Validation?

How to Validate Input?

Setup & Basic Validation

Using Validation Error Messages

Built-In & Custom Validators

More Validators

Checking For Field Equality

Adding Async Validation

Keeping User Input

Adding Conditional CSS Classes

Adding Validation to Login

Sanitizing Data

Validating Product Addition

Validating Product Editing

Wrap Up

Useful Resources & Links

Error Handling

Module Introduction

Types of Errors & Error Handling

Analyzing the Error Handling in the Current Project

Errors - Some Theory

Throwing Errors in Code

Returning Error Pages

Using the Express.js Error Handling Middleware

Updating the App

Using the Error Handling Middleware Correctly

Status Codes

Available Status Codes

Wrap Up

Useful Resources & Links

File Upload & Download

Module Introduction

Adding a File Picker to the Frontend

Handling Multipart Form Data

Handling File Uploads with Multer

Configuring Multer to Adjust Filename & Filepath

Filtering Files by Mimetype

Storing File Data in the Database

Remove imageUrl from "Add Product"

Serving Images Statically

Downloading Files with Authentication

Setting File Type Headers

Restricting File Access

Streaming Data vs Preloading Data

Using PDFKit for .pdf Generation

Generating .pdf Files with Order Data

Deleting Files

Fixing Invoice Links

Wrap Up

Useful Resources & Links

Adding Pagination

Module Introduction

Adding Pagination Links

Retrieving a Chunk of Data

Skip & Limit with SQL

Preparing Pagination Data on the Server

Adding Dynamic Pagination Buttons

Re-Using the Pagination Logic & Controls

Wrap Up

Useful Resources & Links

Understanding Async Requests

Module Introduction

What are Async Requests?

Adding Client Side JS Code

The JSON Data Format

Sending & Handling Background Requests

Manipulating the DOM

Useful Resources & Links

Adding Payments

Module Introduction

How Payments Work

Adding a Checkout Page

Using Stripe in Your App

Useful Resources & Links

Working with REST APIs - The Basics

Module Introduction

What are REST APIs and why do we use Them?

Accessing Data with REST APIs

Understanding Routing & HTTP Methods

REST APIs - The Core Principles

Creating our REST API Project & Implementing the Route Setup

Sending Requests & Responses and Working with Postman

REST APIs, Clients & CORS Errors

Sending POST Requests

Wrap Up

Useful Resources & Links

Working with REST APIs - The Practical Application

Module Introduction

REST APIs & The Rest Of The Course

Understanding the Frontend Setup

Planning the API

Fetching Lists of Posts

Adding a Create Post Endpoint

Adding Server Side Validation

Setting Up a Post Model

Storing Posts in the Database

Static Images & Error Handling

Fetching a Single Post

Image Names & Windows

Uploading Images

Updating Posts

Deleting Posts

Adding Pagination

Adding a User Model

Adding User Signup Validation

Signing Users Up

How Does Authentication Work?

Starting with User Login

Logging In & Creating JSON Web Tokens (JWTs)

Using & Validating the Token

Adding Auth Middleware to All Routes

Connecting Posts & Users

Adding Authorization Checks

Clearing Post-User Relations

Wrap Up

Useful Resources & Links

Understanding Async Await in Node.js

Module Introduction

What is Async Await All About?

Transforming "Then Catch" to "Async Await"

The User Name is Missing!

Wrap Up

Useful Resources & Links

Understanding Websockets & Socket.io

Module Introduction

What Are Websockets & Why Would You Use Them?

Websocket Solutions - An Overview

Setting Up Socket.io on the Server

Establishing a Connection From the Client

Identifying Realtime Potential

Sharing the IO Instance Across Files

Synchronizing POST Additions

Fixing a Bug - The Missing Username

Updating Posts On All Connected Clients

Sorting Correctly

Deleting Posts Across Clients

Wrap Up

Useful Resources & Links

Working with GraphQL

Module Introduction

What is GraphQL?

Understanding the Setup & Writing our First Query

Defining a Mutation Schema

Adding a Mutation Resolver & GraphiQL

Adding Input Validation

Handling Errors

Connecting the Frontend to the GraphQL API

Adding a Login Query & a Resolver

Adding Login Functionality

Adding a Create Post Mutation

Extracting User Data From the Auth Token

Sending the "Create Post" Query

Fixing a Bug & Adding New Posts Correctly

Adding a "Get Post" Query & Resolver

Sending "Create Post" and "Get Post" Queries

Adding Pagination

Uploading Images

Fetching the imageUrl

Viewing a Single Post

Updating Posts

Deleting Posts

Adding Posts & Pagination

Managing the User Status

Using Variables

Fixing a Pagination Bug

Wrap Up

Useful Resources & Links

Deploying our App

Module Introduction

Deploying Different Kinds of Apps

Deployment Preparations

Using Environment Variables

Using Production API Keys

Setting Secure Response Headers with Helmet

Compressing Assets

Setting Up Request Logging

More on Logging

Setting Up a SSL Server

Using a Hosting Provider

Understanding the Project & the Git Setup

A Deployment Example with Heroku

Storing User-generated Files on Heroku

Deploying APIs

Useful Resources & Links

Testing Node.js Applications

Module Introduction

What is Testing?

Why & How?

Setup and Writing a First Test

Testing the Auth Middleware

Organizing Multiple Tests

What Not To Test!

Using Stubs

Testing Controllers

Testing Asynchronous Code

Setting up a Testing Database

Testing Code With An Active Database

Cleaning Up


Testing Code That Requires Authentication

Wrap Up & Mastering Tests

Useful Resources & Links

Node.js as a Build Tool & Using npm

Module Introduction

npm & Node.js

Using npm

Versioning in package.json

What is a Build Tool?

Using Node.js in Build Processes

Useful Resources & Links


Course Roundup

Course Slides

Bonus: More Content!


Stefan8 October 2020

I am in my first half. Pretty good and clear explanation. There is one problem though: So fare this course uses template engines for the UI or the views. Template engines should be optional at the end of the course since nowadays many views/the UI is done with react or angular.

Amanda4 October 2020

Very Complete!! Don't change anything! I would rather the course be 40 hrs and be a complete knowledge than to be one hour and there were concepts that I missed. Thank you!!

Hkbu-Davidlo4 October 2020

A good course overall as the structure are well defined. However, starting from section 9, the pace goes unreasonably difficult to follow and pages jumping back and forth with no pause in between for picking up the correct pages. Quite frustrating to see some intentional errors

Michel4 October 2020

Love the way Maximilian teach, almost as he could hears me asking questions and answers it seconds after. But what I most like is that, until now, every lessons works on the fly, without any issues. Had no extra effort with his code, and, just haven't to search anywhere for, you know, some sort of instructor code fix! And, at least for me, trustable code examples and lessons that really work are the most important. Also like how he cut sections into so small pieces, this gives me coffee intervals!

Kanade2 October 2020

Yes this is a right course for anyone who wanted to learn Node.js in deep. Nicely explained core concepts as well as more in detail with how real world projects works.

Siri26 February 2020

This is yet another great course from Max! This is the fourth course that I have taken from Max. He is a great teacher. I really like the way he teaches. Provides deep knowledge in every concept and covers most of the topics. The resources and links provided at the end of every topic are very helpful. All your courses helped me gain much needed knowledge on web development. Thank you so much Max and team!!

Michael25 February 2020

This is my second class from this instructor. Anything I could possibly ask from an online class. Highly recommended.

Vinay22 February 2020

The explanation is awesome, and the concept of giving an assignment at the end of every module is very helpful. Thankyou

Aman22 February 2020

Yeah, of course. Although I have ample experience in javascript it makes more clear about JS. Such as spread and rest operator, object destructuring and about the promise.

Vishal21 February 2020

A very good course to understand the basics to the masters of server side programming...!! All in one programming package

Dong19 February 2020

Nice course overall. Amazing range of topics covered. Max has really good delivery of concepts. Spent some time on fixing the issues that weren't mentioned on the videos. Still very interesting and well formed course. Thank you!

Maleesh19 February 2020

I know about the man who teach this and who never turns back till we get the concepts right, Thanks max

Adam17 February 2020

I've listened and watched many instructors both on Udemy here and YouTube as well, but This instructor has opened my mind and created more depth in understanding everything as well as simplified it all and apply it. I'm impressed and thankful to finding this course.

Omer17 February 2020

I took this course to improve my skills. In some subjects, found it very helpful. but mostly I was known the subjects. finally conclusion, I very recommend this course to improve your knowledge and students or developers are want to start learning Nodejs

Mor17 February 2020

Thank you Max for another great and detailed course. It has helped me a lot with my personal and freelance projects. Keep it coming :)


Expired7/19/201994% OFF
Expired11/26/201993% OFF
Expired6/11/202095% OFF
Expired12/17/202095% OFF
Valid1/7/202194% OFF


Udemy ID


Course created date


Course Indexed date
Course Submitted by

Android PlayStore
Apple Appstore