Skip to main content
CF

NestJS: The Complete Developer's Guide

19h 40m 39s
English
Free

NestJS: The Complete Developer's Guide is a 223-lesson 19 hours 40 minutes self-paced course by Stephen Grider, Udemy. Congratulations!

Course facts

Lessons
223
Duration
19 hours 40 minutes
Level
All levels
Language
English
Updated
Instructor
Stephen Grider, Udemy
Price
Free

Congratulations! You've found the complete guide on how to build enterprise-ready apps with NestJS. NestJS is a backend framework used to create scalable and reliable APIs. It is a "battery-included" framework, which means it includes tools for handling just about every possible use case—from data persistence to validation, config management to testing, and much more.

Mastering NestJS

This course will help you master NestJS. By the end of this course, you'll have the confidence to build any application you can imagine. Throughout the course, you'll develop a series of applications with growing complexity. We utilize as few external libraries and tools as possible. Instead, you'll write many custom systems to understand how each piece of Nest works together. Every application built includes discussions on data modeling and persistence, starting from a simple file-based datastore and advancing to a production-grade Postgres instance.

Focus on Testing

Testing is a fundamental aspect of NestJS, with substantial functionality dedicated to making projects easy to test. This course follows Nest's testing recommendations by incorporating integration and unit tests to ensure your project functions as expected. Although testing can be challenging and boring, special attention has been made to ensure the tests we write are expressive, fast, and effective, which you can apply to any project—even those that don't use Nest!

Leverage TypeScript

The use of Typescript throughout this course ensures you're writing clean and correct code. Unfamiliar with Typescript? Not to worry! A free appendix is included at the end to get you up to speed. Typescript helps catch errors and bugs in your code before you even run it. If you're new to TypeScript, you're in for a treat!

Course Design and Support

Everything in this course is designed to simplify your learning process.

  • Learn what Nest is doing internally and how to adapt it to your application's needs.

  • Each course video has an attached ZIP file with up-to-date code, just in case you get stuck.

  • Full-time teaching assistants are available to answer your questions.

  • Access included to a private live chat server for real-time help.

Course Topics Overview

Here's a partial list of the topics covered in this course:

  • Securely deploy your app to production.

  • Automate integration and unit tests to verify code functionality.

  • Build an authentication system from scratch for user login.

  • Implement a permissions system for user actions.

  • Manage data storage and retrieval with complex queries using TypeORM.

  • Grasp how TypeORM handles data relationships.

  • Utilize declarative code with property, method, and parameter decorators.

  • Master dependency injection for writing reusable code.

  • Implement automatic validation of incoming requests.

  • Format outgoing response data with a custom DTO system.

  • Manage requests and responses using Guards and Interceptors.

  • Organize your code into reusable Nest Modules.

  • Manage database structure using migrations.

Why This Course?

I struggled to learn NestJS due to the many outdated tutorials and unclear documentation. Nest itself can be difficult to understand. This course is designed to save you time and money, providing the essential knowledge needed to master NestJS. You'll find learning Nest to be a delightful experience while gaining a vast amount of knowledge.

Who teaches NestJS: The Complete Developer's Guide?

Stephen Grider

Stephen Grider thumbnail

Stephen Grider is one of the longest-running and most prolific instructors on Udemy, with a catalog covering essentially every major JavaScript framework, plus Docker, Kubernetes, AWS, and the broader full-stack development landscape. His teaching style is patient and project-oriented — most of his courses are structured around building a substantial application from scratch rather than working through disconnected tutorial examples.

The catalog covers React, Redux, Next.js, Vue, Angular, GraphQL, Node.js, Docker / Kubernetes, AWS infrastructure, React Native and Flutter for mobile, the algorithm / data-structure interview prep track, and the modern TypeScript / Bun / Rust adjacent material that working JavaScript developers increasingly encounter. Few independent instructors have maintained Stephen's breadth this consistently for this long.

The CourseFlix listing under this source carries over 25 Stephen Grider courses spanning that range. Material is paid; Stephen Grider courses are typically sold individually on Udemy. Courses are aimed primarily at developers picking up a specific technology through working through a complete project.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in NestJS: The Complete Developer's Guide?

  • Space or K: play or pause
  • J: rewind 10 seconds
  • L: forward 10 seconds
  • Left Arrow: rewind 5 seconds
  • Right Arrow: forward 5 seconds
  • Up Arrow: volume up
  • Down Arrow: volume down
  • M: mute or unmute
  • F: toggle fullscreen
  • T: toggle theater mode
  • I: toggle mini player
  • 0 to 9: seek to 0 to 90 percent of the video
  • Shift plus N: next video
  • Shift plus P: previous video
0:00 0:00
#Lesson TitleDuration
1How to Get Help 00:52
2Project Setup 04:05
3TypeScript Configuration 05:37
4Creating a Controller 07:04
5Starting Up a Nest App 05:51
6File Naming Conventions 04:36
7Routing Decorators 02:48
8App Setup 07:43
9Using the Nest CLI to Generate Files 06:11
10More on Generating Files 04:12
11Adding Routing Logic 04:05
12[Optional] Postman Setup 04:48
13[Optional] VSCode REST Client Extension 05:12
14Accessing Request Data with Decorators 05:39
15Using Pipes for Validation 03:03
16Adding Validation Rules 07:38
17Behind the Scenes of Validation 07:22
18How Type Info is Preserved 06:15
19Services and Repositories 06:12
20Implementing a Repository 06:39
21Reading and Writing to a Storage File 04:40
22Implementing a Service 05:02
23Manual Testing of the Controller 07:13
24Reporting Errors with Exceptions 05:27
25Understanding Inversion of Control 11:18
26Introduction to Dependency Injection 09:26
27Refactoring to Use Dependency Injection 07:37
28Few More Notes on DI 05:50
29Project Overview 03:07
30Generating a Few Files 04:43
31Setting Up DI Between Modules 05:58
32More on DI Between Modules 04:40
33Consuming Multiple Modules 05:20
34Modules Wrapup 01:54
35App Overview 02:19
36API Design 04:09
37Module Design! 03:03
38Generating Modules, Controllers, and Services 02:28
39Persistent Data with Nest 02:51
40Setting Up a Database Connection 07:29
41Creating an Entity and Repository 07:14
42Viewing a DB's Contents 06:55
43Understanding TypeORM Decorators 07:15
44One Quick Note on Repositories 03:54
45A Few Extra Routes 03:09
46Setting Up Body Validation 07:16
47Manual Route Testing 03:53
48Creating and Saving a User 08:59
49Quick Breather and Review 05:55
50More on Create vs Save 07:37
51Querying for Data 04:42
52Updating Data 11:25
53Removing Users 03:45
54Finding and Filtering Records 05:51
55Removing Records 02:52
56Updating Records 06:00
57A Few Notes on Exceptions 06:49
58Excluding Response Properties 05:51
59Solution to Serialization 04:38
60How to Build Interceptors 12:14
61Serialization in the Interceptor 08:21
62Customizing the Interceptor's DTO 03:03
63Wrapping the Interceptor in a Decorator 03:08
64Controller-Wide Serialization 02:49
65A Bit of Type Safety Around Serialize 03:31
66Authentication Overview 08:22
67Reminder on Service Setup 04:17
68Implementing Signup Functionality 03:45
69[Optional] Understanding Password Hashing 18:50
70Salting and Hashing the Password 08:05
71Creating a User 03:23
72Handling User Sign In 08:29
73Setting up Sessions 06:03
74Changing and Fetching Session Data 05:46
75Signing in a User 04:48
76Getting the Current User 02:02
77Signing Out a User 03:47
78Two Automation Tools 01:58
79Custom Param Decorators 05:35
80Why a Decorator and Interceptor 06:13
81Communicating from Interceptor to Decorator 07:08
82Connecting an Interceptor to Dependency Injection 04:44
83Globally Scoped Interceptors 03:53
84Preventing Access with Authentication Guards 06:47
85Testing Overview 04:43
86Testing Setup 07:17
87Yes, Testing is Confusing 06:50
88Getting TypeScript to Help With Mocks 06:24
89Improving File Layout 04:03
90Ensuring Password Gets Hashed 05:57
91Changing Mock Implementations 07:33
92Testing the Signin Flow 02:03
93Checking Password Comparison 08:38
94More Intelligent Mocks 07:57
95Refactoring to Use Intelligent Mocks 03:25
96Unit Testing a Controller 06:49
97More Mock Implementations 06:01
98Not Super Effective Tests 08:11
99Testing the Signin Method 06:29
100Getting Started with End to End Testing 03:32
101Creating an End to End Test 06:42
102App Setup Issues in Spec Files 08:27
103Applying a Globally Scoped Pipe 05:03
104Applying a Globally Scoped Middleware 04:41
105Solving Failures Around Repeat Test Runs 04:47
106Creating Separate Test and Dev Databases 04:45
107Understanding Dotenv 05:26
108Applying Dotenv for Config 06:49
109Specifying the Runtime Environment 04:45
110Solving a SQLite Error 02:54
111It Works! 04:36
112A Followup Test 05:23
113Back to Reports 01:01
114Adding Properties to Reports 02:53
115A DTO for Report Creation 03:51
116Receiving Report Creation Requests 07:08
117Saving a Report with the Reports Service 04:12
118Testing Report Creation 04:08
119Building Associations 03:36
120Types of Associations 06:40
121The ManyToOne and OneToMany Decorators 05:46
122More on Decorators 08:29
123Setting up the Association 06:39
124Formatting the Report Response 03:39
125Transforming Properties with a DTO 05:05
126Adding in Report Approval 05:59
127Testing Report Approval 05:49
128Authorization vs Authentication 04:18
129Adding an Authorization Guard 04:36
130The Guard Doesn't Work?! 02:19
131Middlewares, Guards, and Interceptors 03:50
132Assigning CurrentUser with a Middleware 08:16
133Fixing a Type Definition Error 02:34
134Validating Query String Values 07:28
135Transforming Query String Data 03:49
136How Will We Generate an Estimate 03:32
137Creating a Query Builder 05:15
138Writing a Query to Produce the Estimate 08:33
139Testing the Estimate Logic 03:46
140The Path to Production 02:09
141Providing the Cookie Key 03:36
142Understanding the Synchronize Flag 03:44
143The Dangers of Synchronize 02:23
144The Theory Behind Migrations 03:21
145Headaches with Config Management 04:49
146TypeORM and Nest Config is Great 24:05
147Env-Specific Database Config 06:40
148Installing the TypeORM CLI 04:39
149Generating and Running Migrations 07:08
150Running Migrations During E2E Tests 02:50
151Production DB Config 04:03
152Heroku Specific Project Config 02:43
153Deploying the App - (Final Lecture) 02:52
154How to Get Help 01:05
155TypeScript Overview 06:20
156Environment Setup 08:00
157A First App 04:44
158Executing TypeScript Code 05:04
159One Quick Change 03:36
160Catching Errors with TypeScript 07:23
161Catching More Errors! 05:16
162Course Overview 03:37
163Types 05:13
164More on Types 05:54
165Examples of Types 04:50
166Where Do We Use Types? 00:50
167Type Annotations and Inference 02:04
168Annotations with Variables 04:54
169Object Literal Annotations 06:54
170Annotations Around Functions 05:57
171Understanding Inference 03:52
172The Any Type 07:48
173Fixing the "Any" Type 01:50
174Delayed Initialization 03:06
175When Inference Doesn't Work 04:38
176More Annotations Around Functions 04:57
177Inference Around Functions 06:09
178Annotations for Anonymous Functions 01:43
179Void and Never 02:50
180Destructuring with Annotations 03:36
181Annotations Around Objects 07:06
182Arrays in TypeScript 05:06
183Why Typed Arrays? 04:31
184Multiple Types in Arrays 02:58
185When to Use Typed Arrays 00:55
186Tuples in TypeScript 04:06
187Tuples in Action 05:29
188Why Tuples? 03:21
189Interfaces 01:27
190Long Type Annotations 04:43
191Fixing Annotations with Interfaces 04:37
192Syntax Around Interfaces 03:32
193Functions In Interfaces 04:47
194Code Reuse with Interfaces 04:16
195General Plan with Interfaces 03:13
196Classes 03:48
197Basic Inheritance 03:04
198Class Method Modifiers 06:42
199Fields in Classes 06:19
200Fields with Inheritance 04:19
201Where to Use Classes 01:11
202App Overview 02:46
203Bundling with Parcel 04:56
204Project Structure 03:20
205Generating Random Data 05:30
206Type Definition Files 05:18
207Using Type Definition Files 06:21
208Export Statements in TypeScript 05:07
209Defining a Company 04:44
210Adding Google Maps Support 07:39
211Google Maps Integration with TypeScript 04:07
212Exploring Type Definition Files 12:47
213Hiding Functionality 06:29
214Why Use Private Modifiers? Here's Why 08:26
215Adding Markers 09:19
216Duplicate Code 02:46
217One Possible Solution 06:39
218Restricting Access with Interfaces 05:36
219Implicit Type Checks 03:27
220Showing Popup Windows 06:24
221Updating Interface Definitions 07:12
222Optional Implements Clauses 06:07
223App Wrapup 08:09

What courses are similar to NestJS: The Complete Developer's Guide?

More courses by Stephen Grider

Frequently asked questions

What are the prerequisites for enrolling in this NestJS course?
Before enrolling in this course, it is recommended that you have a basic understanding of JavaScript and TypeScript, as these languages are used throughout the course material. Familiarity with Node.js and backend development will be beneficial, though not strictly necessary. The course will guide you through the setup and configuration of a NestJS application, so prior experience with NestJS itself is not required.
What kinds of projects will I build during this course?
Throughout the course, you will develop a series of applications that increase in complexity. Starting from basic routing and validation, you will move on to more sophisticated applications involving data modeling and persistence. You will initially work with a simple file-based datastore before advancing to a production-grade Postgres database, thereby gaining hands-on experience with building enterprise-ready applications using NestJS.
Who is the target audience for this NestJS course?
This course is designed for developers who want to master NestJS and learn how to build scalable backend applications. It is suitable for those with a background in JavaScript or TypeScript who are looking to enhance their skills in building APIs and enterprise-level applications. Both beginners in NestJS and those looking to deepen their understanding of the framework will find value in the structured, project-based approach.
What specific tools and platforms will be used in this course?
The course focuses on using NestJS as the primary backend framework, along with TypeScript for type-safe development. You will utilize the Nest CLI for generating files and setting up applications. Data persistence will be managed using Postgres, and testing will be emphasized through integration and unit tests. Optional tools like Postman and the VSCode REST Client Extension are also discussed for testing and development purposes.
How does this course compare in depth and scope to other NestJS courses?
This course offers a comprehensive exploration of NestJS by guiding you through the creation of multiple applications with varying complexity. Unlike some other courses, there is a strong focus on writing custom systems rather than relying heavily on external libraries. This approach ensures a deeper understanding of how NestJS components work together. Additionally, the course emphasizes testing and TypeScript, providing skills that are transferable to other projects and frameworks.
What topics are not covered in this NestJS course?
The course does not cover frontend development or client-side frameworks as it focuses exclusively on backend development using NestJS. Additionally, while the course provides a strong foundation in testing with NestJS, it does not delve into advanced testing frameworks beyond what is recommended by Nest itself. Advanced database topics beyond the use of Postgres for persistence are also not covered.
What is the expected time commitment to complete this course?
The course consists of 223 lessons, and while the total runtime is not specified, it is designed to be comprehensive and thorough. Prospective students should be prepared to dedicate a significant amount of time to engage with the material, complete exercises, and build the projects. The time required will vary depending on prior experience and familiarity with the concepts covered, but consistent study and practice will be key to mastering the content.