CF

Complete Node.js Developer in 2023: Zero to Mastery

38h 32m 8s
English
Paid

Complete Node.js Developer in 2023: Zero to Mastery is a 304-lesson 38 hours 32 minutes self-paced course by Zero To Mastery. Learn Node.

Course facts

Lessons
304
Duration
38 hours 32 minutes
Level
All levels
Language
English
Updated
Instructor
Zero To Mastery
Price
Premium

Learn Node.js with clear steps and real projects. You will build apps, work with data, and ship code. This course helps you use Node with confidence in real jobs and team work.

What You Will Learn

You build skills that help you write and ship Node apps. Each topic links to real tasks you may face as a backend developer.

Build Real Node Apps

  • Build and deploy Node apps on AWS.
  • Create a full MERN app and push it to production.
  • Use Node to build REST and GraphQL APIs.
  • Work with files, databases, and sockets.

Work With Real Data

  • Use the SpaceX API.
  • Build a NASA launch tool that checks new planets.

Learn Core Backend Skills

  • Plan clean app structure for teams.
  • Use SQL and MongoDB.
  • Add auth and secure your routes.
  • Write code that is safe, stable, and fast.

Learn Advanced Topics

  • Load balancing and app monitoring.
  • Set up CI/CD and zero downtime deploys.
  • Follow security best practices from the start.

Additional

  1. https://github.com/odziem/planets-project
  2. https://github.com/odziem/http-server
  3. https://github.com/odziem/express-project
  4. https://github.com/odziem/nasa-project
  5. https://github.com/odziem/performance-example
  6. https://github.com/odziem/security-example
  7. https://github.com/odziem/graphql-example
  8. https://github.com/odziem/multiplayer-pong

Who teaches Complete Node.js Developer in 2023: Zero to Mastery? Zero To Mastery

Zero To Mastery thumbnail

Zero To Mastery (ZTM) is a Toronto-based online coding academy founded by Andrei Neagoie, originally a senior developer at large Canadian tech firms before turning to teaching full-time. The academy's signature is the cohort-based bootcamp track combined with a deep self-paced course library, all aimed at career-changers and self-taught developers preparing to land software-engineering roles at top companies.

The instructor roster has grown well beyond Andrei to include other senior practitioners: Daniel Bourke (machine learning), Aleksa Tešić (DevOps), Jacinto Wong, and others. Courses cover the full software-engineering career path: web development with React and Next.js, Python, machine learning and deep learning, DevOps and cloud, system design, mobile, and the algorithm / data-structure interview prep that gates engineering jobs.

The CourseFlix listing under this source carries over 120 ZTM courses spanning that full range. Material is paid; ZTM itself runs on a monthly / annual membership model. The teaching style favours long-form, project-based courses where students build complete portfolio-quality applications rather than disconnected feature tutorials.

What lessons are included in Complete Node.js Developer in 2023: Zero to Mastery?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 304 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Complete Node.js Developer: Zero to Mastery
All Course Lessons (304)
#Lesson TitleDurationAccess
1
Complete Node.js Developer: Zero to Mastery Demo
02:51
2
Course Outline
06:23
3
Node.js - How We Got Here
09:20
4
Node.js Runtime
08:20
5
How To Succeed In The Course
04:00
6
Latest Version Of Node.js
02:13
7
OPTIONAL: Installing Node.js
05:45
8
OPTIONAL: Windows Installation Tips
03:11
9
Node.js Release Cycle
04:10
10
The Node.js REPL
06:09
11
Setting Up Our Developer Environment
04:31
12
Our First Node App
11:36
13
Node.js VS JavaScript
05:47
14
The global Object
05:46
15
Introduction to Backend VS Frontend
08:56
16
What Node.js Includes
09:39
17
Node Internals Deep Dive
10:58
18
libuv Internals Deep Dive
12:54
19
Synchronous vs Asynchronous
05:24
20
Asynchronous Callbacks
05:56
21
Non-Blocking Input & Output
03:33
22
Exercise: Is JavaScript Asynchronous?
02:28
23
Multi-Threading, Processes, and Threads
11:41
24
Is Node.js Multi-Threaded?
10:57
25
The Event Loop
04:04
26
Callback Queues
04:53
27
Phases of the Event Loop
09:19
28
Comparing Node With PHP and Python
06:34
29
What Is Node.js Best At?
04:53
30
Observer Design Pattern
05:28
31
The Node Event Emitter
14:07
32
The require Function
02:50
33
Making HTTP Requests
11:10
34
Why Use Modules?
04:06
35
Creating Our Own Modules
13:03
36
Exporting From Modules
04:04
37
CommonJS vs ECMAScript Modules
04:12
38
Creating Our Own ECMAScript Modules
06:32
39
Module Caching
07:43
40
Importing Core Modules
03:00
41
Using index.js
08:41
42
Should We Use index.js?
04:43
43
NPM: The Node Package Manager
04:40
44
Creating Our First NPM Package
09:24
45
Do We Need package.json?
01:36
46
Packages And The NPM Registry
01:57
47
Using Third Party Modules
11:12
48
The node_modules Folder
09:55
49
Semantic Versioning
02:38
50
package-lock.json and Versioning
09:43
51
Vulnerabilities In Dependencies
04:55
52
The Node Fetch Function
03:36
53
Installing NPM Tools: nodemon
09:57
54
Node.js Built-in Watcher
02:59
55
NPM vs PNPM vs Yarn
03:30
56
Overview: The Bun Runtime
02:32
57
Exploring Planets With Node
01:50
58
Importing Kepler Space Telescope Data
04:53
59
Setting Up Our CSV Parser
05:25
60
Streaming Large Data Files
05:33
61
Reading Our Planets Data
06:49
62
Parsing Our Planets Data
06:05
63
Finding Habitable Planets
08:27
64
Exploring Habitable Planets
07:19
65
What is a Web Server?
05:25
66
Introduction to HTTP Responses and Requests
03:59
67
HTTP Requests
07:42
68
HTTP Responses
13:37
69
Our First Webserver
10:13
70
HTTP APIs and Routing
09:01
71
Parameterized URLs
10:38
72
Same Origin Policy
09:24
73
Cross Origin Resource Sharing (CORS)
10:30
74
POSTing Data to the Server
11:32
75
Requests and Responses as Streams
11:51
76
Web Servers Recap
04:06
77
Why Express?
03:36
78
Introduction to Express
09:37
79
Express vs Next.js vs Koa
11:19
80
Route Parameters
09:05
81
Postman and Insomnia
06:08
82
Development Dependencies
03:50
83
Middleware
07:31
84
Writing Our Own Logging Middleware
10:26
85
POST Requests in Express
16:22
86
Model View Controller (MVC)
07:39
87
Model View Controller in Express
18:31
88
Express Routers
16:39
89
RESTful APIs
11:40
90
Create Read Update and Delete (CRUD)
06:57
91
Sending Files
06:07
92
Serving Websites With Node
09:46
93
Templating Engines
11:34
94
Layouts and Separation of Concerns
07:44
95
Introduction & Architecture
11:04
96
NASA Dashboard Front End Setup
05:48
97
NASA Dashboard Functionality
05:12
98
What You Need To Know
02:16
99
React.js Front End Code Walkthrough
18:11
100
API Server Setup
12:33
101
GET /planets
15:33
102
CORS Middleware
07:23
103
Models vs Controllers vs Routers
04:42
104
The Planets Model
05:31
105
Loading Data On Startup
15:41
106
Automating Full Stack Applications With NPM
13:45
107
Serving React.js Front End In Production
12:16
108
Logging Requests With Morgan
08:45
109
The Launches Model
12:57
110
GET /launches
16:57
111
Serving Applications With Client Side Routing
05:59
112
Working With Data Models: Building a Data Access Layer
08:50
113
POST /launches: Creating Launches 1
13:16
114
POST /launches: Creating Launches 2
10:42
115
POST /launches: Validation For POST Requests
12:40
116
Connecting POST /launches With Front End Dashboard
13:40
117
DELETE /launches: Aborting a Launch 1
13:06
118
DELETE /launches: Aborting a Launch 2
12:01
119
Updating Our Architecture Diagram
11:43
120
Testing In Node
03:27
121
Testing APIs With Jest
14:22
122
Testing API Endpoints With Supertest: GET
08:04
123
Testing API Endpoints With Supertest: POST
09:10
124
Testing API Endpoints With Supertest: Error Cases
06:49
125
Node.js Test Runner
01:39
126
OPTIONAL: Migrating To Node's Built-in Test Runner
06:47
127
OPTIONAL: Third Party Assertions With Chai
02:20
128
Exercise: Imposter Syndrome
02:56
129
Node Server Performance
04:16
130
Building A Simple Blocking Server
10:21
131
Real Life Blocking Functions
08:48
132
Running Multiple Node Processes
03:19
133
The Node Cluster Module
04:18
134
Clustering In Action
12:28
135
Operating System Schedulers
03:40
136
Maximizing Cluster Performance
07:41
137
Load Balancing
05:37
138
The PM2 Tool
02:27
139
Using PM2 To Create Clusters
09:39
140
Managing Live Clusters With PM2
06:11
141
Zero Downtime Restart
03:47
142
Improving Performance Of Our NASA Project
08:07
143
Worker Threads
08:22
144
Worker Threads In Action
08:16
145
Introduction to Databases
03:47
146
Comparing SQL vs NoSQL
08:11
147
Database Schemas & Schemaless Databases
03:46
148
Choosing a Database for our NASA Project
05:33
149
SQL vs MongoDB: Trends and Object-Relational Impedance Mismatch
08:19
150
SQL vs MongoDB: Schemas, References, and ACID Transactions
14:20
151
Setting up MongoDB Atlas
12:24
152
Connecting to MongoDB
08:55
153
Mongoose
05:25
154
Creating Mongoose Schema for Launches
15:19
155
Exercise: Creating Mongoose Schema for Planets
05:30
156
Creating Models From Schemas
04:31
157
Mongoose Models vs MVC Models
04:16
158
Inserting And Updating Documents
08:10
159
Finding Documents
06:49
160
The Upsert Operation
08:21
161
Exploring Data Using Atlas
04:53
162
Updating Project Architecture
05:10
163
ObjectIDs
03:52
164
Excluding Fields From The Response
03:31
165
Saving Launches
04:52
166
Listing All Launches
02:58
167
Referential Integrity
10:57
168
Auto Increment In MongoDB
07:29
169
Getting Latest Flight Number
05:59
170
Scheduling New Launches
09:01
171
Investigating A Mongoose Mystery
07:11
172
Aborting Launches
12:55
173
Updating Tests For Mongoose 1
15:03
174
Updating Tests For Mongoose 2
10:01
175
Working With SpaceX
02:48
176
The SpaceX API
03:23
177
Versioning Node APIs
09:10
178
Updating Our API Tests
01:01
179
Exploring SpaceX Launches API
05:41
180
Running Search Queries
13:05
181
Loading SpaceX Data In Our API
14:52
182
Mapping SpaceX Data To Our Database
11:57
183
Using Paginated APIs
08:00
184
Minimizing API Load
08:19
185
Persisting SpaceX Launches
06:41
186
Paginating Our Endpoints 1
07:58
187
Paginating Our Endpoints 2
15:28
188
Sorting Paginated Data
03:49
189
Cleaning Up Launch Data
03:34
190
Managing Secrets With Dotenv
09:05
191
Securing Leaked Secrets
05:10
192
Security and Authentication Overview
03:44
193
Encrypted Connections with SSL and TLS
06:29
194
Digital Certificates, Signing, and Man In The Middle Attacks
05:43
195
Setting Up Our Security Example
04:19
196
HTTPS With Node, Self Signed Certificates, and Public Key Cryptography
16:18
197
Helmet.js
09:47
198
Authentication vs Authorization
07:29
199
Social Sign In
05:12
200
API Keys
11:04
201
JWT Tokens
14:33
202
The OAuth Standard
05:41
203
OAuth 2.0 Authorization Code Flow
06:35
204
OAuth In Action with Single Sign On
15:16
205
Registering with the Google Authorization Server
14:12
206
Authentication Endpoints With Middleware
11:08
207
Passport.js
03:25
208
Dotenv for Client Secrets
08:24
209
Authentication With Google And OAuth 1
11:12
210
Authentication With Google And OAuth 2
11:46
211
Cookie Based Authentication
06:55
212
Sessions
03:34
213
Server VS Client Side Sessions With Cookies
09:05
214
Session Middleware in Express
09:51
215
Setting Up OAuth Cookie Session
12:35
216
Sessions with the Latest Version of Passport.js
05:36
217
Reading and Writing the OAuth Session 1
13:03
218
Reading and Writing the OAuth Session 2
06:45
219
Restricting Access to Endpoints
07:54
220
Implementing Logout
07:13
221
Asynchronous Logout
03:16
222
Experimenting With Fake Sessions
05:12
223
Wrap Up and Next Steps
05:55
224
Introduction to CI and CD
06:42
225
Continuous Integration
08:24
226
Continuous Delivery
09:38
227
Continuous Deployment
06:01
228
Pipelines
04:27
229
GitHub Actions
09:43
230
Setting Up GitHub Actions
05:37
231
Continuous Integration: Build Pipeline
12:03
232
Build Pipeline In Action
08:38
233
GitHub Actions Marketplace
03:08
234
Continuous Integration: Test Pipeline
11:21
235
Mocking Out Databases
05:19
236
Databases With Continuous Integration
10:19
237
Populating Data For Continuous Integration
08:51
238
Deploying to the Cloud
02:15
239
Serverless vs Containers
03:59
240
Virtual Machines
04:17
241
What is a Container?
05:00
242
Installing Docker
03:29
243
Running Our first Docker Container
05:39
244
Your DockerHub Account
01:40
245
Creating a Dockerfile
14:03
246
Improving Our Dockerfile With Layers
13:23
247
Updating Our API URL
02:17
248
Building NASA Project Docker Image
05:38
249
Running NASA Project in a Container
04:30
250
Pushing Images to Docker Hub
03:47
251
Exploring Amazon Web Services
06:29
252
Creating an EC2 Instance 1
07:51
253
Creating an EC2 Instance 2: Security
13:11
254
What is SSH?
02:59
255
Connecting To Our EC2 Instance With SSH
07:49
256
Setting Up Our EC2 Server
05:46
257
Deploying Our NASA API
10:39
258
GraphQL Overview
08:04
259
Our First GraphQL Query
08:16
260
GraphQL Queries In Action
05:48
261
GraphQL vs REST: Over-fetching & Under-fetching
10:53
262
GraphQL vs REST Summary
10:09
263
Exploring GraphQL Implementations
03:25
264
GraphQL In Node
11:02
265
Working With Deprecated Packages
03:20
266
Recommended: Migrating GraphQL Packages
05:07
267
GraphiQL
04:26
268
Designing An E-Commerce Schema
16:02
269
GraphQL Tools
03:40
270
Modularizing Large GraphQL Projects: Schemas
14:02
271
Resolvers
09:02
272
Modularizing Large GraphQL Projects: Resolvers
09:28
273
Filtering with Queries and Resolvers
10:21
274
Exercise: Query Products By ID
05:31
275
Mutations In Action
06:41
276
Implementing Mutations on the Server
10:11
277
Exercise: Add New Product Review
10:59
278
GraphQL With Apollo
06:32
279
Building an Apollo Server with Node.js - Part 1
02:58
280
Building an Apollo Server with Node.js - Part 2
10:08
281
Building an Apollo Server with Node.js - Part 3
05:16
282
Introduction to Sockets
02:12
283
Polling
03:58
284
What is a Socket?
02:59
285
Sockets VS Polling
05:02
286
WebSockets
05:26
287
Introduction to socket.io
03:21
288
socket.io Client and Server APIs
08:44
289
Multiplayer Pong Overview
03:32
290
Reviewing Our Pong Front End
11:58
291
Multiplayer Pong Message Sequence
07:39
292
Setting Up a socket.io Server
04:31
293
Connecting to socket.io
04:04
294
Identifying Connected Clients
06:39
295
Listening for Events in the Pong Server
03:09
296
Broadcasting Events
02:47
297
Handling Events in the Pong Client
07:16
298
Implementing the Game Logic: Paddle
09:21
299
Implementing the Game Logic: Ball
08:47
300
What Happens When You Disconnect?
05:24
301
Using Socket.io with Express
11:46
302
Namespaces
06:06
303
Rooms
10:40
304
Thank You!
01:18
Unlock unlimited learning

Get instant access to all 303 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Complete Node.js Developer in 2023: Zero to Mastery?

More courses by Zero To Mastery

Frequently asked questions

What are the prerequisites for enrolling in this Node.js course?
The course is designed for students who want to learn Node.js from the ground up. While there are no strict prerequisites, a basic understanding of JavaScript and programming concepts would be beneficial. The course covers foundational topics like the Node.js runtime, asynchronous programming, and the Node event loop, which require some programming background to fully grasp.
What kinds of projects will I build during the course?
Students will engage in building real Node.js applications, including deploying Node apps on AWS and creating a full MERN stack application. Additional projects include using the SpaceX API and building a NASA launch tool. These projects are designed to simulate real-world tasks a backend developer might face.
Who is the target audience for this course?
The course is targeted at aspiring backend developers, JavaScript developers looking to expand their skill set to include server-side programming, and anyone interested in building and deploying Node.js applications. It is also suitable for developers who want to learn how to work with real data and set up production-ready applications.
What specific tools and platforms will I learn to use in this course?
Students will learn to use various tools and platforms, including deploying applications on AWS, working with databases like SQL and MongoDB, and using the Node Package Manager (NPM). The course also covers CI/CD setup and monitoring, which are essential skills for maintaining production applications.
How does this course compare in scope to other Node.js courses?
This course offers a comprehensive journey from basic to advanced topics in Node.js. It not only covers foundational aspects such as the Node.js runtime and event loop but also delves into advanced topics like load balancing, app monitoring, CI/CD, and security best practices. This breadth makes it suitable for beginners and those seeking deeper knowledge.
What topics are not covered in the course?
While the course covers a wide range of topics related to Node.js development, it does not focus on frontend development beyond the scope of a MERN application. It also does not cover non-JavaScript server-side languages or frameworks in detail, such as PHP or Python, though comparisons are made to these technologies.
What is the expected time commitment to complete this course?
The course consists of 304 lessons, and while the total runtime is not specified, students should prepare to invest a significant amount of time to go through the video content, complete exercises, and build projects. The time commitment will vary based on individual learning pace and prior experience.