Setting Up Our Developer Environment | Zero To Mastery Academy

Autoplay
Autocomplete

Previous Lesson Complete and Continue

Complete Node.js Developer in 2025: Zero to Mastery

Introduction

Complete Node.js Developer: Zero to Mastery (2:50)
Course Outline (6:22)
Exercise: Meet Your Classmates and Instructor
Node.js - How We Got Here (9:19)
Node.js Runtime (8:19)
How To Succeed In The Course (3:59)
Course Projects + Code + Cheatsheet
ZTM Plugin + Understanding Your Video Player
Set Your Learning Streak Goal

Node.js Fundamentals: Foundations and Environment Setup

Latest Version Of Node.js (2:28)
OPTIONAL: Installing Node.js (5:46)
OPTIONAL: Windows Installation Tips (3:33)
Node.js Release Cycle (4:11)
The Node.js REPL (6:08)
Setting Up Our Developer Environment (4:30)
Our First Node App (11:35)
Node.js VS JavaScript (5:46)
The global Object (5:45)
Introduction to Backend VS Frontend (8:55)
Monthly Coding Challenges, Free Resources and Guides

Node.js Fundamentals: Internals

What Node.js Includes (9:38)
Node Internals Deep Dive (10:57)
libuv Internals Deep Dive (12:53)
Synchronous vs Asynchronous (5:23)
Asynchronous Callbacks (5:55)
Non-Blocking Input & Output (3:32)
Exercise: Is JavaScript Asynchronous? (2:27)
Multi-Threading, Processes, and Threads (11:40)
Is Node.js Multi-Threaded? (10:56)
The Event Loop (4:03)
Callback Queues (4:52)
Phases of the Event Loop (9:18)
Comparing Node With PHP and Python (6:33)
What Is Node.js Best At? (4:52)
Observer Design Pattern (5:27)
The Node Event Emitter (14:06)
Recommended Path: Asynchronous JavaScript
Let's Have Some Fun (+ Free Resources)

Node.js Fundamentals: Module System

The require Function (2:49)
Making HTTP Requests (11:09)
Why Use Modules? (4:05)
Creating Our Own Modules (13:02)
Exporting From Modules (4:03)
CommonJS vs ECMAScript Modules (4:11)
Creating Our Own ECMAScript Modules (6:31)
Module Caching (7:42)
Importing Core Modules (2:59)
Using index.js (8:40)
Should We Use index.js? (4:42)
Unlimited Updates

Node.js Fundamentals: Package Management

NPM: The Node Package Manager (4:39)
Creating Our First NPM Package (9:23)
Do We Need package.json? (1:35)
Packages And The NPM Registry (1:56)
Using Third Party Modules (11:11)
The node_modules Folder (9:54)
Semantic Versioning (2:37)
package-lock.json and Versioning (9:42)
Vulnerabilities In Dependencies (4:54)
The Node Fetch Function (3:35)
Installing NPM Tools: nodemon (9:56)
Node.js Built-in Watcher (2:59)
Course Check-In

Node.js File I/O - Planets Project

Code For This Section
Exploring Planets With Node (1:49)
Importing Kepler Space Telescope Data (4:52)
Latest Version of CSV Parser
Setting Up Our CSV Parser (5:24)
Streaming Large Data Files (5:32)
Reading Our Planets Data (6:48)
Parsing Our Planets Data (6:04)
Finding Habitable Planets (8:26)
Exploring Habitable Planets (7:18)
Implement a New Life System

Web Servers with Node.js

Code For This Section
What is a Web Server? (5:24)
Introduction to HTTP Responses and Requests (3:58)
HTTP Requests (7:41)
HTTP Responses (13:36)
Our First Webserver (10:12)
HTTP APIs and Routing (9:00)
Parameterized URLs (10:37)
Same Origin Policy (9:23)
Exercise: Same Origin Policy
Cross Origin Resource Sharing (CORS) (10:29)
POSTing Data to the Server (11:31)
Requests and Responses as Streams (11:50)
Web Servers Recap (4:05)

First Express.js API

Code For This Section
Why Express? (3:35)
Introduction to Express (9:36)
Express vs Next.js vs Koa (11:18)
Route Parameters (9:04)
Postman and Insomnia (6:07)
Development Dependencies (3:49)
Middleware (7:30)
Writing Our Own Logging Middleware (10:25)
POST Requests in Express (16:21)
Model View Controller (MVC) (7:38)
Model View Controller in Express (18:30)
Express Routers (16:38)
RESTful APIs (11:39)
Create Read Update and Delete (CRUD) (6:56)
Sending Files (6:06)
Serving Websites With Node (9:45)
Templating Engines (11:33)
Layouts and Separation of Concerns (7:43)

NASA Project

Code For This Section
Introduction & Architecture (11:02)
NASA Dashboard Front End Setup (5:47)
NASA Dashboard Functionality (5:11)
What You Need To Know (2:15)
React.js Front End Code Walkthrough (18:10)
API Server Setup (12:32)
Environment Variables On Windows
GET /planets (15:32)
CORS Middleware (7:22)
Models vs Controllers vs Routers (4:41)
The Planets Model (5:30)
Loading Data On Startup (15:40)
Common Issues With NPM Scripts
Automating Full Stack Applications With NPM (13:44)
Serving React.js Front End In Production (12:15)
Setting BUILD_PATH On Windows
Logging Requests With Morgan (8:44)
The Launches Model (12:56)
GET /launches (16:56)
Serving Applications With Client Side Routing (5:58)
Working With Data Models: Building a Data Access Layer (8:49)
POST /launches: Creating Launches 1 (13:15)
POST /launches: Creating Launches 2 (10:41)
POST /launches: Validation For POST Requests (12:39)
Connecting POST /launches With Front End Dashboard (13:39)
DELETE /launches: Aborting a Launch 1 (13:05)
DELETE /launches: Aborting a Launch 2 (12:00)
Updating Our Architecture Diagram (11:42)

Testing APIs

Testing In Node (3:26)
Testing APIs With Jest (14:21)
Testing API Endpoints With Supertest: GET (8:03)
Testing API Endpoints With Supertest: POST (9:09)
Testing API Endpoints With Supertest: Error Cases (6:48)
Node.js Test Runner (1:38)
OPTIONAL: Migrating To Node's Built-in Test Runner (6:46)
OPTIONAL: Third Party Assertions With Chai (2:19)
Exercise: Imposter Syndrome (2:55)

Improving Node Performance

Code For This Section
Node Server Performance (4:15)
Building A Simple Blocking Server (10:20)
Real Life Blocking Functions (8:47)
Running Multiple Node Processes (3:18)
The Node Cluster Module (4:17)
Clustering In Action (12:27)
Naming Updates
Operating System Schedulers (3:40)
Maximizing Cluster Performance (7:40)
Load Balancing (5:36)
The PM2 Tool (2:26)
Using PM2 To Create Clusters (9:38)
Managing Live Clusters With PM2 (6:10)
Zero Downtime Restart (3:46)
Improving Performance Of Our NASA Project (8:06)
Worker Threads (8:21)
Worker Threads In Action (8:15)

Databases

Introduction to Databases (3:46)
Recommended Path: SQL
Comparing SQL vs NoSQL (8:10)
Database Schemas & Schemaless Databases (3:45)
Choosing a Database for our NASA Project (5:32)
SQL vs MongoDB: Trends and Object-Relational Impedance Mismatch (8:18)
SQL vs MongoDB: Schemas, References, and ACID Transactions (14:19)
Setting up MongoDB Atlas (12:23)
Connecting to MongoDB (8:54)
Connecting with the Latest Version of Mongoose
Mongoose (5:24)
Creating Mongoose Schema for Launches (15:18)
Exercise: Creating Mongoose Schema for Planets (5:29)
Reminder: Destination Planets Dropdown
Creating Models From Schemas (4:30)
Mongoose Models vs MVC Models (4:15)
Inserting And Updating Documents (8:09)
Finding Documents (6:48)
The Upsert Operation (8:20)
Exploring Data Using Atlas (4:52)
Updating Project Architecture (5:09)
ObjectIDs (3:51)
Excluding Fields From The Response (3:30)
Saving Launches (4:51)
Listing All Launches (2:57)
Referential Integrity (10:56)
Auto Increment In MongoDB (7:28)
Getting Latest Flight Number (5:58)
Scheduling New Launches (9:00)
Investigating A Mongoose Mystery (7:10)
Aborting Launches (12:54)
Aborting with the Latest MongoDB Driver
Updating Tests For Mongoose 1 (15:02)
Updating Tests For Mongoose 2 (10:00)
Fixing A Bug In Jest: Open Handles

Working With REST APIs - SpaceX Project

Working With SpaceX (2:47)
The SpaceX API (3:22)
Versioning Node APIs (9:09)
Updating Our API Tests (1:00)
Exploring SpaceX Launches API (5:40)
Running Search Queries (13:04)
Loading SpaceX Data In Our API (14:51)
Mapping SpaceX Data To Our Database (11:56)
Using Paginated APIs (7:59)
Minimizing API Load (8:18)
Persisting SpaceX Launches (6:40)
Paginating Our Endpoints 1 (7:57)
Paginating Our Endpoints 2 (15:27)
Sorting Paginated Data (3:48)
Cleaning Up Launch Data (3:33)
Managing Secrets With Dotenv (9:04)
Running API Tests With Dotenv
Securing Leaked Secrets (5:09)

Node Security + Authentication

Code For This Section
Security and Authentication Overview (3:43)
Encrypted Connections with SSL and TLS (6:28)
Digital Certificates, Signing, and Man In The Middle Attacks (5:42)
Setting Up Our Security Example (4:18)
HTTPS With Node, Self Signed Certificates, and Public Key Cryptography (16:17)
Helmet.js (9:46)
Authentication vs Authorization (7:28)
Social Sign In (5:11)
API Keys (11:03)
JWT Tokens (14:32)
The OAuth Standard (5:40)
OAuth 2.0 Authorization Code Flow (6:34)
OAuth In Action with Single Sign On (15:15)
Registering with the Google Authorization Server (14:11)
Authentication Endpoints With Middleware (11:07)
Passport.js (3:24)
Dotenv for Client Secrets (8:23)
Authentication With Google And OAuth 1 (11:11)
Authentication With Google And OAuth 2 (11:45)
Cookie Based Authentication (6:54)
Sessions (3:33)
Server VS Client Side Sessions With Cookies (9:04)
Session Middleware in Express (9:50)
Setting Up OAuth Cookie Session (12:34)
Sessions with the Latest Version of Passport.js (5:35)
Reading and Writing the OAuth Session 1 (13:02)
Reading and Writing the OAuth Session 2 (6:44)
Restricting Access to Endpoints (7:53)
Implementing Logout (7:12)
Asynchronous Logout (3:16)
Experimenting With Fake Sessions (5:11)
Wrap Up and Next Steps (5:54)
Resource: Security Cheat Sheet

Continuous Integration and Delivery

Introduction to CI and CD (6:41)
Continuous Integration (8:23)
Continuous Delivery (9:37)
Continuous Deployment (6:00)
Pipelines (4:26)
GitHub Actions (9:42)
Setting Up GitHub Actions (5:36)
Continuous Integration: Build Pipeline (12:02)
Keeping Our Pipeline Updated
Build Pipeline In Action (8:37)
Common Build Pipeline Errors
GitHub Actions Marketplace (3:07)
Continuous Integration: Test Pipeline (11:20)
Mocking Out Databases (5:18)
Databases With Continuous Integration (10:18)
Populating Data For Continuous Integration (8:50)

Node Production and the Cloud (Docker + AWS)

Deploying to the Cloud (2:14)
Serverless vs Containers (3:58)
Virtual Machines (4:16)
What is a Container? (4:59)
Installing Docker (3:28)
Running Our first Docker Container (5:38)
Your DockerHub Account (1:39)
Creating a Dockerfile (14:02)
Improving Our Dockerfile With Layers (13:22)
Installing Only Production Dependencies
Updating Our API URL (2:16)
Building NASA Project Docker Image (5:37)
Running NASA Project in a Container (4:29)
Pushing Images to Docker Hub (3:46)
Exploring Amazon Web Services (6:28)
Creating an EC2 Instance 1 (7:50)
Creating an EC2 Instance 2: Security (13:10)
What is SSH? (2:58)
Connecting To Our EC2 Instance With SSH (7:48)
Setting Up Our EC2 Server (5:45)
Deploying Our NASA API (10:38)

GraphQL

Code For This Section
GraphQL Overview (8:03)
Our First GraphQL Query (8:15)
GraphQL Queries In Action (5:47)
GraphQL vs REST: Over-fetching & Under-fetching (10:52)
GraphQL vs REST Summary (10:08)
Exploring GraphQL Implementations (3:24)
GraphQL In Node (11:01)
Working With Deprecated Packages (3:19)
Recommended: Migrating GraphQL Packages (5:06)
GraphiQL (4:25)
Populating E-Commerce Data
Designing An E-Commerce Schema (16:01)
GraphQL Tools (3:39)
Modularizing Large GraphQL Projects: Schemas (14:01)
GraphQL Tools Update
Resolvers (9:01)
Modularizing Large GraphQL Projects: Resolvers (9:27)
Filtering with Queries and Resolvers (10:20)
Exercise: Query Products By ID (5:30)
Mutations In Action (6:40)
Implementing Mutations on the Server (10:10)
Exercise: Add New Product Review (10:58)
GraphQL With Apollo (6:31)
Building an Apollo Server with Node.js - Part 1 (2:57)
Building an Apollo Server with Node.js - Part 2 (10:07)
Building an Apollo Server with Node.js - Part 3 (5:15)

Sockets with Node.js

Code For This Section
Introduction to Sockets (2:11)
Polling (3:57)
What is a Socket? (2:58)
Sockets VS Polling (5:01)
WebSockets (5:25)
Introduction to socket.io (3:20)
socket.io Client and Server APIs (8:43)
Multiplayer Pong Overview (3:31)
Recommended Path: Pong Front End
Reviewing Our Pong Front End (11:57)
Multiplayer Pong Message Sequence (7:38)
Setting Up a socket.io Server (4:29)
Connecting to socket.io (4:03)
Handling CORS With Sockets
Identifying Connected Clients (6:38)
Listening for Events in the Pong Server (3:08)
Broadcasting Events (2:46)
Handling Events in the Pong Client (7:15)
Implementing the Game Logic: Paddle (9:20)
Implementing the Game Logic: Ball (8:46)
What Happens When You Disconnect? (5:23)
Using Socket.io with Express (11:45)
Namespaces (6:05)
Rooms (10:39)

Where To Go From Here?

Thank You! (1:17)
Review This Course!
Become An Alumni
Learning Guideline
ZTM Events Every Month
LinkedIn Endorsements

Bonus: Deno vs Node.js

Watch Deno Fundamentals Sections

Appendix: How JavaScript Works

Watch JavaScript Foundation Section
Recommended Path: Back To Node

Appendix: Asynchronous JavaScript

Watch Asynchronous JavaScript Section
Recommended Path: Back To Node

Appendix: Pong Front End

Watch Building Pong Section
Recommended Path: Back to Sockets

Appendix: TypeScript

Watch TypeScript Section

Appendix: SQL

Watch SQL Sections
Recommended Path: Back to Node

Setting Up Our Developer Environment

Visual Studio Code - https://code.visualstudio.com/