Complete Node.js Developer in 2023: Zero to Mastery

46h 5s
English
Paid

Course description

Learn from Node.js experts. This is the only Node JS tutorial + projects course you need to learn Node, build advanced large-scale applications from scratch & get hired as a Backend Developer in 2023. Go from Zero To Node Mastery.

Read more about the course
  • Build enterprise-level Node applications and deploy to the cloud (AWS)
  • Lead Node JS projects by making good architecture decisions and helping others on your team
  • Work with real-life data and the SpaceX API to build a NASA launch system to discover new planets that may contain life + other projects
  • Build a MERN (MongoDb, Express, React, Node) fullstack app and deploy to production
  • Become a top 10% Node Developer by learning advanced topics most courses don't cover
  • Master the latest ecosystem of a Backend Node JS Developer from scratch
  • Learn to build secure and performant, large-scale applications like a Senior Backend Developer
  • Use Node JS to build production grade apps including REST APIs and GraphQL APIs
  • Authentication, File I/O, Databases (SQL, MongoDB), Express Framework, Sockets, plus many other important topics a Backend Developer should know
  • Load balancing, Monitoring, CI/CD, and Zero Downtime Deployment
  • Learn security best practices throughout the course so you can be confident with your deployments

Watch Online

This is a demo lesson (10:00 remaining)

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

View Pricing

Watch Online Complete Node.js Developer in 2023: Zero to Mastery

0:00
/
#1: Course Outline

All Course Lessons (367)

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

Unlock unlimited learning

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

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Learn Node

Learn Node

Sources: wesbos
Learn to build applications and APIs with Node.js Node.js, Express, MongoDB and friends are some of the most in-demand web development skills. This course is th
9 hours 52 minutes 53 seconds
Build a Shopping Cart App

Build a Shopping Cart App

Sources: Reed Barger
Gain expert skills to build and deploy an amazing React app. An epic training course that gives you the entire process to build and deploy your own top-tier e-c
1 hour 41 minutes 52 seconds
Redis Caching Concepts with Node.js

Redis Caching Concepts with Node.js

Sources: Codedamn
Redis is an open-source in-memory data store used as a database, cache, and message broker. It is incredibly fast and suitable for a variety of tasks.
1 hour 52 minutes 26 seconds
The Node.js Master Class - No Frameworks, No NPM | Node v8.x

The Node.js Master Class - No Frameworks, No NPM | Node v8.x

Sources: udemy
Node as it was intended: Build a REST API, a web app GUI, and a CLI in plain javascript with no 3rd-party libraries.
15 hours 24 minutes 23 seconds