Node JS Course

Lesson 1 • Core Global Objects and Built-in APIs

Explores process, console, Buffer, and global scope available without imports. Connects built-in capabilities to practical scripting tasks throughout the course.

Lesson 2 • What Node.js Is and How It Works

Covers the V8 engine, single-threaded event loop, and non-blocking I/O model. Grounds all later async patterns in a concrete mental model of runtime execution.

Lesson 3 • The Node.js REPL and CLI Basics

Introduces the interactive REPL and essential CLI flags for running scripts. Builds confidence executing and inspecting Node.js code immediately.

Lesson 1 • ES Modules in Node.js

Covers import/export syntax, .mjs files, and package.json type field. Prepares students for modern module interoperability in production codebases.

Lesson 2 • CommonJS Module System

Teaches require, module.exports, and the module resolution algorithm. Provides the foundation for organizing code across multiple files.

Lesson 3 • Scalable Project Structure and Configuration

Defines folder conventions, environment config patterns, and .gitignore best practices. Produces a reusable project scaffold for all course exercises.

Lesson 4 • Semantic Versioning and Dependency Management

Decodes semver ranges, peer dependencies, and safe upgrade strategies. Prevents version conflicts that commonly break Node.js projects.

Lesson 1 • Async/Await Patterns and Error Handling

Transforms Promise chains into readable async functions and enforces try/catch discipline. Connects directly to real-world API and database code in later chapters.

Lesson 2 • Promises and Promise Combinators

Covers Promise construction, chaining, and combinators like Promise.all and Promise.race. Enables composing multiple async operations cleanly.

Lesson 3 • Streams and Backpressure

Introduces Readable, Writable, Transform, and Duplex streams with pipeline usage. Solves large-data processing without exhausting memory.

Lesson 4 • Callbacks and the Error-First Convention

Establishes the error-first callback pattern and common pitfalls like callback hell. Provides the historical context needed to appreciate Promises.

Lesson 1 • OS Module and Process Interaction

Exposes CPU, memory, network interface, and platform data via the os module. Connects system metrics to monitoring and cross-platform scripting tasks.

Lesson 2 • Working with Directories and Paths

Teaches directory creation, listing, deletion, and cross-platform path construction. Prevents path-separator bugs when code runs on multiple operating systems.

Lesson 3 • Reading and Writing Files

Covers fs.readFile, fs.writeFile, and their synchronous counterparts with encoding options. Establishes safe file I/O patterns used in logging and config loading.

Lesson 4 • File System Promises API and fs/promises

Migrates callback-based fs calls to the promise-based fs/promises module. Aligns file I/O code with the async/await style established in Chapter 3.

Lesson 1 • Input Validation and Error Handling

Validates request data with a schema library and centralizes error responses. Ensures the API returns consistent, informative errors to clients.

Lesson 2 • Introduction to Express.js

Installs Express, defines routes, and explains the request-response cycle. Accelerates API development while reinforcing the HTTP concepts from the previous section.

Lesson 3 • Routing and Controller Organization

Separates routes into Express Router instances and maps them to controller functions. Produces a maintainable codebase that scales as endpoints multiply.

Lesson 4 • Middleware Architecture in Express

Explains the middleware pipeline, next(), and built-in middleware like express.json. Enables cross-cutting concerns such as logging, parsing, and authentication.

Lesson 1 • Connecting to a Relational Database

Establishes a connection pool to a relational database and executes parameterized queries. Prevents SQL injection and connection exhaustion from the start.

Lesson 2 • ORM Usage and Schema Definition

Defines models, associations, and migrations using a Node.js ORM. Abstracts raw SQL while maintaining control over schema evolution.

Lesson 3 • Caching with an In-Memory Store

Integrates a Redis-compatible client to cache query results and session data. Reduces database load and improves API response times measurably.

Lesson 4 • Transactions and Data Integrity

Wraps multi-step operations in database transactions to guarantee atomicity. Protects data consistency in concurrent API environments.

Lesson 1 • Authentication with JSON Web Tokens

Issues and verifies JWTs for stateless authentication across API routes. Establishes the token lifecycle: creation, validation, and expiry.

Lesson 2 • Password Hashing and Credential Storage

Hashes passwords with bcrypt and enforces secure credential storage rules. Prevents plaintext password exposure in database breaches.

Lesson 3 • Role-Based Access Control

Attaches roles to JWT payloads and enforces permissions in route middleware. Restricts sensitive endpoints to authorized user groups only.

Lesson 4 • HTTPS and Secure Transport

Configures TLS certificates and forces HTTPS in Node.js servers. Ensures data in transit is encrypted in development and production environments.

Lesson 1 • Containerization and CI/CD Deployment

Packages the Node.js app in a Docker container and automates deployment via a CI/CD pipeline. Delivers a repeatable, environment-agnostic release process.

Lesson 2 • Unit Testing with a Test Framework

Writes isolated unit tests for functions and modules using Jest or a comparable framework. Establishes a test suite that runs on every code change.

Lesson 3 • Debugging Node.js Applications

Uses the built-in inspector, VS Code debugger, and logging libraries to locate bugs. Reduces mean time to resolution for runtime and logic errors.

Lesson 4 • Integration and API Testing

Tests full HTTP request-response cycles against a running Express app using Supertest. Validates routing, middleware, and database interactions end to end.