Welcome to the most comprehensive Node.js course on the internet.

In this course, we're going to do a deep dive into Node.js itself without cluttering our minds with other tools and NPM packages and truly master this powerful technology.

This course is heavily focused on computer science topics and fundamentals that are crucial to understand for becoming a great back-end engineer. You can only properly understand Node.js and unlock its full power if you understand these other computer science topics. So that's why we will also learn these other vital topics so that you can truly master Node.js and take your back-end engineering skills to a whole new level.

We will also use all these vital concepts that we'll learn in practice by building various exciting projects just using Node.js.

This is an intense course for people who want to get to the top of the field and get to a level of driving innovation and making an impact within the industry instead of just scratching the surface and following a few software trends and tools.

Each section of the course is like its own mini-course, and by completing each section, you'll learn some essential Node.js, computer science and back-end engineering concepts that will help you not just if you want to use Node.js but throughout your whole career as a software engineer. These things will stay with you for years and decades to come.

Let's do a quick walkthrough about what you will accomplish after completing some of the sections:

Understanding Buffers: Here, we will deeply understand buffers and how to work directly with binary data, which is essential for all the other sections.

Understanding File System: As a back-end developer, you'll work with files a lot, be it saving some data to disk, handling file uploads and many other examples, so it's essential to have a good understanding of them, which you'll gain after completing this section. We'll also learn how Node.js deals with files and master the "fs" module.

Understanding Streams: In this section, we're going to master Streams, which will allow us to develop highly-performant apps capable of handling terabytes of data with ease while having great memory usage. We'll build many mini-projects throughout the section, including an encryption-decryption app from scratch that could encrypt terabytes of data by directly modifying the binary data. This section lays the foundation for future sections where we'll utilize Streams heavily to create powerful and efficient network applications.

Understanding Networking: Node.js was primarily designed to create network applications, so it's of utmost importance that we gain a decent understanding of networking, which we will do after completing this section. Here's a list of items we'll learn in this section:

• What exactly a network is

• How the internet works

• Mac Addresses

• IPV4 & IPv6 Addresses

• TCP

• UDP

• DNS

• Fundamentals of deployment

We'll build 2 low-level apps using only Node.js, a chat and a file uploader app directly on top of TCP. And then, we'll deploy them to a Linux server in the most basic way without using unnecessary tools.

We'll see exactly what happens in our network card, every single 0s and 1s exchanged for a particular thing using Wireshark, and gain a much better understanding of networking and how most of the well-known protocols like This section will broaden your horizons, and you'll realize that there are far more things that you can do with Node.js than just creating web servers.

Understanding HTTP: In this section, we'll utilize and combine all that we've learned from previous sections and finally deeply understand HTTP once and for all. We won't be learning how to use Express; instead, we will build something similar ourselves.

We'll start by understanding the most important HTTP concepts, such as connection types, client-server model, messages, requests, responses, HTTP Methods, status codes, mime types, necessary headers and so much more. And then emulate an HTTP protocol directly on top of TCP using the net module and see precisely every single 0s and 1s that get exchanged for an HTTP request and response interaction.

Once we understand the fundamentals of HTTP and the "http" module, we'll take things to the next level and start building our framework. And then, using our framework, we'll make a fully functional web application.

This section will take your web development skills to the next level. You'll have a much better understanding of how all these popular NPM packages, like Express, body-parser, Multer, cors, etc., that are built on top of the "http" module work. Well, you'll learn how to make them from scratch, just using them will not be that much of a problem.

Update February 2024 - New Module Is Out. Understanding Unix:

With over 15 hours of comprehensive new content, get ready to learn how you can harness the power of multiple technologies and programming languages together with Node.js to create extraordinarily powerful applications.

Unix, one of the most influential inventions ever in the software industry, is crucial for software engineers to understand. In this module, we'll delve deep into some of the key concepts such as Bash, Shells, IPC, Data Streams, Process Management, Clustering, even some C and much more.

We will also understand these Node.js modules:

• Child Processes

• Cluster

• Process

• Path

• Console

• OS

All these Unix concepts that you'll learn in this section instantly apply to many other programming languages. You'll gain a foundation that you can keep building on to create much higher-quality applications than ever before.

At the end of the section, we'll develop a video editing web application with Node.js without using other NPM packages. And this is just the beginning. You'll be able to do much more than this once you're done with the section and see many new possibilities that you never thought about before.

Update May 2024 - New Module Is Out. Understanding Compression:

In this section, we will explore the fascinating world of compression. Understanding compression is crucial for reducing the size of your data, and one important use case is to enhance the speed of your network applications. We'll dive into the Node.js Zlib module and see how it is possible to reduce the number of bits needed to store and transfer your data without losing any information.

Update July 2024 - New Module Is Out. Understanding Multi-Threading:

Get ready for the most advanced section of the course, where we're going to utilize the full power of Node.js to see how extreme we can get. 

We'll learn what exactly threads are and how to utilize them to achieve performance boosts up to many times, depending on how many CPU cores we have. We'll learn when we should use multi-threading and when we shouldn't. We'll learn how to set up communication channels between our threads, both with message passing and shared memory. We'll explore the Node.js thread pool and even develop one ourselves from scratch. We'll see how multi-threading differs in Node.js from some of the other languages. We'll cover synchronization, race conditions, deadlocks, semaphores, mutual exclusion and more.

You'll learn how to keep the event loop light and not end up doing operations that will mysteriously block your main thread and cause your app to be way slower.

This section will take your Node.js skills to the next level by teaching you how to run things in parallel, handle multiple event loops, and understand the complications that arise with that.

Please note that there are more exciting sections to come. The course is still in production, and the expected date for the course completion is within the fall of 2024.

If at any point in the course, you get stuck or feel like you need more clarification on something, I will be there in the QA to help you every step of the way from start to finish. Sign up today, and let's master Node.js and take your back-end engineering skills to a whole new level.