NodeJS Internals and Architecture

Name: NodeJS Internals and Architecture
Price: 9 USD
Availability: InStock

21h 9m 56s

English

Paid

June 30, 2025

Course description

My favorite part of engineering is making complex systems transparent and understandable.

Node.js is one of the most popular runtimes for server development, yet it often remains a "black box" even for experienced developers. I myself have felt this many times.

This course is the result of months of work on dissecting the architecture and internal mechanisms of Node.js. It is designed for those engineers who cannot work with something opaque.

Read more about the course

This course is for you if you:

Want to understand what's happening "under the hood" of Node.js
Enjoy dissecting one line of code into hundreds of lines of implementation
Wonder why the behavior of a Node program is sometimes unpredictable
Want to know why a Node process can terminate - or not terminate
Are curious why Node sometimes takes a long time to start
Value cross-platform compatibility and want to learn how Node works on all OS

For instance, by knowing how the HTTP module is constructed, you will be able to write a server that handles more requests. Understanding the event loop and its phases will allow you to restructure code logic for improved performance and stability.

If your code "crashes" 1% of the time for reasons that aren't clear - this course will give you an understanding of how to make program behavior predictable. Not with chaotic "quick fixes," but through a deep understanding of the internal workings of Node.

The course will teach you to go in the same direction as Node, rather than "fighting" with its mechanisms.

The course program includes:

Node.js Architecture

Phases of the event loop and what happens in each of them
How promises work and why they are just "new type of callbacks"
Module loading and its impact on performance
The structure of Node packages and how it affects your code

Inside Node.js

How Node implements asynchronous I/O through libuv
Protocols and their implementation in Node
Streams and processes: how Node handles concurrency at the OS level

Optimization and Performance

Tips on speeding up code based on architectural understanding
How to identify "bottlenecks" and work with them
When and how to use C++ extensions if JavaScript is no longer sufficient

This course is designed for developers with an intermediate level of knowledge in Node.js who want to deepen their understanding of its architecture and increase their confidence in working with it.

It's advisable to have a general understanding of OS basics, although this is not strictly necessary.

Watch Online

0:00

#1: Introduction

All Course Lessons (43)

#	Lesson Title	Duration
1	Introduction Demo	01:57
2	Who this course for?	03:06
3	Course Data	00:50
4	Course Outline	06:59
5	What do you need?	06:24
6	Node JS Architecture Intro	09:30
7	Interpreted Languages and V8	49:02
8	The Event Loop	24:14
9	The Main Module	19:39
10	Timers Phase	26:11
11	Pending Callbacks Phase	14:03
12	Idle, Prepare Phase	18:23
13	Poll Phase (Updated)	47:49
14	Check Phase	23:07
15	Close Callbacks Phase	24:08
16	Process.nextTick	16:46
17	How Promises work under the hood	22:44
18	Require, Import Event	34:12
19	Anatomy of Node Packages	32:35
20	When does Node terminate?	20:31
21	Node Internals Section Intro	06:42
22	libuv Overview	08:05
23	Asynchronous IO in the Operating System	29:35
24	Inside Node Network IO	43:36
25	Inside Node File IO	51:51
26	Inside Node HTTP	01:14:04
27	Inside Node HTTPS	01:00:56
28	Inside Node DNS	48:00
29	Inside Node TCP	48:37
30	Inside Node UDP	34:03
31	Inside Node Streams	01:03:12
32	Process vs Thread	01:00:38
33	Worker Threads	51:55
34	Child Process and Cluster	36:31
35	Optimization Section Intro	13:23
36	Node Performance	39:36
37	Debugging NodeJS	08:07
38	Capturing Node's Traffic	32:36
39	Request modules performance showdown	22:24
40	C++ Add-ons	39:22
41	Course Summary	08:39
42	Proxy vs Reverse Proxy	20:06
43	Memcachd and NodeJS	01:05:48