Backend with Node

Section 1: Introduction to Backend and Node.js

1. Prerequisites
2. What Is Backend & Client Server Architecture?
3. CLI vs GUI
4. What Is Node.js and What Is It Used For?
5. Installing Node.js
6. Running Our First Node.js Code
7. Why Do We Need Node.js and How Is It Different From JavaScript in Browser?
8. A Brief History of Node.js

Section 2: Basics of Terminal

1. Introduction to Terminal and Shell
2. Basic Shell Commands (echo, pwd, whoami)
3. Navigating the File System (cd)
4. Listing Directory Contents (ls)
5. Creating, Copying, Moving, and Deleting Files and Directories (touch, mkdir, cp, mv, rm, rmdir)
6. Viewing and Editing Files with Commands (cat, nano, vim)
7. What Is Prompt in Terminal?
8. Configuring Our Terminal Using .bashrc File
9. Using Aliases for Command Shortcuts (alias)

Section 3: Basics of OS

1. What Is CPU, Processor, and Core?
2. What Is OS and Kernel?
3. What Is a Process?
4. What Is Thread, Concurrency, and Parallelism?
5. Can a Process Exist Without a Thread?
6. Debugging Worker Threads
7. What Is an Environment Variable?
8. Setting and Using Environment Variables
9. Installing Windows Subsystem for Linux (WSL)
10. Understanding the Path System: Windows vs. Linux Explained
11. What are Executable Files?
12. Managing File Permissions
13. How Commands Get Executed?
14. Important Methods and Properties of The Process Object

Section 4: Fundamentals of Node.js

1. Module System in Node.js
2. Introduction to Common JS Module System
3. module.exports VS exports
4. module Object
5. Module Wrapper Function
6. Custom Require Function
7. ES6 Modules
8. Accessing filename and dirname in ES6 Modules
9. Why Different Module Systems?
10. Difference Between Common.js and ES6 Modules
11. Different Types of Modules
12. NPM and NPM Modules
13. Creating and Publishing NPM Modules
14. Understanding package.json File in Depth
15. What is Shebang?
16. Library VS CLI Packages and Local VS Global Packages
17. How npx Works?
18. What is npx?
19. Introduction to FS Module
20. Word Counter CLI Project
21. Writing to a File Using Node.js
22. Node.js File Operations: Rename, Delete, Move, Copy & More

Section 5: Data Representation in Computing

1. Introduction to Data Representation in Computing
2. Decimal Number System
3. Octal Number System
4. Hexadecimal Number System
5. Binary Number System
6. Introducing Programmer's Calculator
7. Digital Data Uints
8. Binary Data on Physical Level
9. Why DO We Use Decimal System?
10. Character Sets vs Character Encodings (ASCII and Unicode)
11. Understanding UTF-8 in Depth
12. What are Unicode Planes?
13. UTF-8 vs UTF-16 vs UTF-32
14. Byte Order Mark (BOM) and Endianness (Big Endian & Little Endian)

Section 6: Mastering Buffers - Handling Binary Data in Node.js

1. Introduction to Buffers
2. ArrayBuffer in JavaScript
3. Signed and Unsigned Values
4. Reading and Writing to Array Buffers
5. Writing Multi-Byte Data
6. Typed Arrays
7. Transferring Array Buffer Data from Memory to Disk and Network
8. Buffer in Node.js
9. Alloc VS AllocUnsafe
10. Buffer Pool in Node.js
11. Buffer Methods and Properties
12. Practical Use of Buffers
13. Limitations of Buffers
14. Base-64 Encoding
15. Base-64 in Node.js

Section 7: Event-Driven Architecture and EventEmitter in Node.js

1. What is an I/O Operation?
2. What is Async I/O?
3. Introduction to Event-Driven Architecture
4. The EventEmitter Class
5. Creating and Emitting Events
6. EventEmitter Methods

Section 8: Node.js Streams - Handling Data Flow like a Pro

1. Introduction to Streams
2. Types Of Streams in Node.js
3. Readable Streams
4. Different States of Readable Streams
5. Internal Buffer of Readable Streams
6. More about Readable Streams
7. Writable Streams
8. Backpressure and Internal Buffer of Writable Streams
9. Closing Writable Streams
10. States of Writable Streams
11. Piping Streams
12. Piping Using Pipeline
13. Duplex, Transform and Passthrough Streams
14. Data Streams
15. Piping and Redirection of Data Streams
16. Writing 1 Lakh Numbers
17. Why Streams Are So Fast?
18. What is a File Descriptor?
19. Reading File with File Descriptor
20. Opening Files in Different Modes
21. Writing to a File with File Descriptor
22. Write One Lakh Numbers Faster than Streams
23. Implementing Internal Buffer in our Custom Stream
24. Handling Files Using Promises
25. Working with Streams using Promises
26. How Browsers use Streams?
27. Streams in JavaScript

Section 9: Basics of Computer Networking

1. Why Should We Learn Networking?
2. What is Computer Networking?
3. Story of The Internet
4. Story of DNS
5. Story of World Wide Web
6. Important Networking Devices
7. Types of Network
8. Creating Our Own LAN
9. Creating Our Own WAN
10. How Internet Comes to Our Homes?
11. How does Mobile Internet Work?
12. Understanding IPv4 Addresses in Depth
13. Dynamic vs Static IP Address
14. Private vs Public IP Address
15. Benefits and Drawbacks of Public and Private IP Addresses
16. How to get Public IP Adresss?
17. Turning Our Laptop into a Public Server
18. Running Multiples Severs on our Laptop
19. Understanding Domain Name System (DNS)
20. Connecting Our IP Address with a Domain Name
21. How DNS Servers Work?
22. DNS Hijacking
23. Understanding IPv6 Addresses
24. Turning Our Mobile Phone into a Public Server
25. What are Port Numbers?
26. Inspecting Port Numbers with Wireshark
27. What are Network Interfaces?
28. What is MAC Address?
29. What is Firewall?
30. Understanding OSI Model
31. Understanding TCP/IP Model
32. Network Topologies
33. TCP and UDP: The Backbone of the Internet
34. Remote Terminal Access Using SSH
35. Transferring files using SCP
36. SSH Public and Private Keys
37. Connecting to Multiple SSH Servers
38. Creating AWS Account
39. Understanding AWS EC2 Instance
40. AWS Cost Management
41. More Topics to Learn

Section 10: Networking with Core Node.js Modules

1. Networking Capabilities of Node.js
2. Creating UDP Server in Node.js
3. What is Socket?
4. Transferring Files Using UDP
5. Creating TCP Server in Node.js
6. Creating TCP Client using Node.js
7. Handling Multiple TCP Clients
8. Transferring Files Using TCP
9. Creating HTTP Server using Net Module
10. Understanding HTTP Headers
11. Important Response Headers
12. Controlling Data Transfer Speeds
13. Inspecting TCP Data Packets in Wireshark
14. Why We Await Twice When Making a Fetch Call?
15. Uploading Files
16. Creating HTTP Server Using HTTP Module
17. HTTP Request Methods
18. HTTP Response Status Codes
19. Creating HTTP Client
20. Anatomy of HTTP Request and Response
21. Creating a Web Server
22. Creating Online Storage Platform Like Google Drive
23. Implementing Preview and Download Feature in Our Storage App
24. Client-Side vs Server-Side Rendering
25. Separating Our Client-Side and Server-Side Code
26. Implementing File Upload with Progress
27. Adding Delete Functionality
28. Implementing Rename Functionality
29. Making Our App Live on Internet

Section 11: Building RESTful CRUD APIs with Express.js

1. Intro to Express.js
2. How Express Works Behind the Scenes?
3. What is Middleware in Express?
4. Handling Different HTTP Methods in Express
5. Difference Between Route and Request URL
6. Adding Global Middleware with app.use() Method
7. Adding Route-Specific Middleware
8. Serving Static Files using Express
9. Sending JSON using Express
10. Making File Storage App in Express
11. Dynamic Routing in Express
12. Handling File Uploads in Express
13. What is CORS?
14. Understanding Preflight Request
15. Adding Single-Level Nested Directory Support in Our Storage App
16. Adding Multi-Level Nested Directory Support
17. Adding Directory Creation Functionality
18. Understanding Path Traversal Vulnerability
19. Fixing Vulnerability with Path Module
20. Organizing Routes using Express Router
21. Understanding the Problem with Our Code
22. Creating Virtual File System
23. Adding Directory Support in Our VFS
24. Integrating VFS API in Our UI
25. Adding Nested Directory Feature in Our VFS
26. Adding Directory Rename and Delete Functionality
27. Understanding REST API Principles
28. Error Handling in Express
29. Handling File Uploads Using Multer
30. Showing Upload Progress While Using Multer in Backend
31. Adding Basic User Registration Functionality
32. Overview of New UI of Our App
33. What are Cookies?
34. Setting Cookies from Server
35. Implementing Simple Login Functionality
36. Providing User Specific File Access
37. Adding Logout and User Profile Functionality
38. Understanding res.download() Method
39. Using app.route() Method to Clean Our Code
40. Understanding router.param() Method
41. What is HTTP Redirection and How Does it Work?
42. Understanding Different Types of Form Data
43. Difference Between Extended True and False
44. Nested Dynamic Routes
45. RegEx in Routes
46. Using Arrays to Define Multiple Routes
47. Express v4 vs v5

Section 12: Mastering Database Fundamentals with MongoDB

1. Introduction To Database
2. Types Of Databases
3. Introduction To MongoDB
4. Understanding Mongo Shell
5. Installing MongoDB Server
6. MongoDB Fundamentals
7. Creating Documents In MongoDB
8. Reading Data In MongoDB
9. Inspecting MongoDB Data Packages
10. Update Operation In MongoDB
11. Delete Operation In MongoDB
12. Datatypes In MongoDB
13. Object Id Datatype
14. Different Number Types
15. MongoDB Datatypes In Practice
16. BSON Types In MongoDB
17. Where Data Is Stored
18. Configuring Our MongoDB Server
19. Accessing Our MongoDB Server From Anywhere In The World
20. Running MongoShell Scripts in JS Files
21. What is MongoDB Playground?
22. MongoDB in Node.js
23. MongoDB CRUD Operations in Node.js
24. Understanding Cursors in MongoDB
25. Cursor Methods in MongoDB
26. Batch Size in MongoDB
27. Projection in MongoDB
28. Limits of MongoDB
29. MongoDB Setup in Our Storage App
30. Integrating Database in User Routes
31. Integrating Database in Directory Routes
32. Integrating Database in File Routes
33. Performing Bulk Operations in MongoDB
34. Implementing Recursive Directory Delete Functionality
35. Why ObjectId() Is Not a String?
36. Fixing ObjectId() Validation
37. Understanding Application Architecture
38. Ordered Inserts in MongoDB
39. What Is Upsert in MongoDB?
40. Running Commands in MongoDB
41. Operators in MongoDB
42. What Is Schema?
43. Adding Basic Schema Validation in MongoDB
44. Creating a New Collection with Validation Enabled
45. Understanding JSON Schema Validation
46. Validation Action VS Validation Level
47. Finding Invalid Documents in a Collection
48. Adding Schema Validation in Our Storage App
49. Handling Database Validation Errors in Our App
50. What Are Transactions in Database?
51. Implementing Transaction in Code
52. ACID Properties of a Transaction
53. Relational vs. Non-Relational Databases: Key Differences
54. Embedded vs. Referenced Documents: Choosing the Right Data Model
55. Understanding One-to-One, One-to-Many, and Many-to-Many Relationships
56. Backup & Restore Using mongodump and mongoresotre for Backup
57. Using mongoimport and mongoexport to Export and Import JSON or CSV Data
58. mongoimport VS mongoexport: When to Use What?
59. Securing MongoDB: Authentication and Authorization
60. Enabling Auth in MongoDB Replica Set
61. Installing MongoDB On AWS EC2 Ubuntu Instance
62. Deploying MongoDB on EC2
63. Exploring MongoDB Atlas
64. Managed VS Self-Managed Databases

Section 13: Mastering MVC Architecture with Mongoose

1. Introduction to MVC Architecture
2. Controllers in Action: Organizing Your Application Logic
3. Views Explained: Creating and Managing User Interfaces
4. Introduction to Mongoose and Models
5. Mongoose Query Buffering: Queries Wait for Database Connection
6. Schema and Types in Mongoose
7. CRUD Operation Using Mongoose
8. What are Thenable Objects in JavaScript?
9. What is a Mongoose Query?
10. What are Documents in Mongoose?
11. Integrating Mongoose in Our TodoApp
12. Adding Custom Validation in Mongoose Schema
13. Using Ref and Populate to Fetch Referenced Fields
14. Implementing MVC Architecture in StorageApp
15. Integrating Mongoose in UserController
16. Integrating Mongoose in FileController
17. What are Virtuals in Mongoose?
18. Define Custom Methods on Mongoose Documents
19. Define Custom Static Methods on Mongoose Model
20. What Is Middleware in Mongoose?
21. Understanding Document Middleware
22. Understanding Query Middleware
23. Understanding Model Middleware
24. Introduction to Indexes in MongoDB
25. Understanding Unique True Property of Mongoose Schema
26. Creating Unique Index for Email in Our StorageApp
27. Document Versioning in Mongoose
28. Understanding Mongoose Object
29. Mongoose Built-in Error Types ValidationError, MongoServerError, etc.

Section 14: Mastering Authentication and Authorization in Node.js

1. Introduction to Authentication and Authorization
2. Stateful vs Stateless Auth
3. Limitations of Auth in Our Storage App
4. Trying to Fix Cookie Expiry Issue
5. Cryptography Basics: Understanding Encryption vs Hashing
6. Basics of Hashing
7. Hashing in Node.js Using crypto Module
8. How Git Uses Hashing for Commits?
9. Understanding Digital Signatures
10. Signing Cookies in Node.js
11. Understanding MAC and HMAC
12. Signing Cookies Using cookie-parser
13. Hashing Passwords Before Saving to the Database
14. What Are Rainbow Tables?
15. Understanding Key Derivation Functions
16. Using pbkdf2() to Hash Passwords
17. Understanding bcrypt
18. Using bcrypt to Hash Passwords
19. Understanding JSON Web Tokens
20. Do Not Use JWT for Login
21. What Are Sessions?
22. Stateful vs Stateless Servers
23. Overview of Our New LMS App
24. Adding Guest Session in Our LMS App
25. Implementing Cart Functionality
26. Adding Get and Delete Routes for Cart
27. Adding Authorized Sessions in LMS App
28. Moving Cart Data to Cart Collection
29. Implementing Logout and Session Expiry Functionality
30. Auto-Deleting Documents in MongoDB
31. Implementing Sessions in Storage App
32. Restricting Multiple Device Access
33. Implementing Logout from All Devices Functionality
34. Sending Emails Using Node.js
35. Sending Email With Custom Domain
36. Verifying Email Using OTP
37. Understanding OAuth and Its Flow
38. Understanding OpenID Connect and Its Flow
39. Client Registration for Google OAuth Integration
40. Understanding Google’s OpenID Connect
41. How to Open a Popup for Google Login?
42. Creating a Different Page for Redirect URL
43. Implementing Login With Google on Backend
44. Implementing Logout Functionality
45. Receiving Auth Code on Backend
46. Putting Google Auth Redirect Logic in Backend Code
47. Verifying ID Token
48. Using Google Auth Library to Verify ID Token
49. Using Google Auth Library to Fetch ID Token
50. Using Google Auth Library to Generate AuthURL
51. Calling User Info Endpoint With Access Token
52. Customizing OAuth Login Popup With Prompt and Login Hint Parameters
53. Error Handling in Google Login
54. Implementing Google Login With Passport.js
55. Grant Types in OAuth 2.0
56. Understanding Implicit Grant Type
57. Implementing Google Login Using Implicit Grant Type
58. Problem With Implicit Login Flow
59. Enabling One Tap Login and Fixing Implicit Flow Issue
60. GSI vs FedCM
61. Branding Guidelines of Login With Google Button
62. Using GSI Library in React.js
63. Adding Google Login in StorageApp
64. Wrapping Up Authentication – Next Steps & Assignments

Section 15: Understanding Role-Based Access Control (RBAC)

1. What Is RBAC?
2. Implementing GET All Users Endpoint
3. Adding Role-Based Access in Users Route
4. Role-Based UI Rendering
5. Implementing User Logout Functionality
6. Implementing User Delete Feature
7. Implementing Soft Delete for Users
8. Preventing Users from Self-Deletion
9. What is Google Zanzibar and OpenFGA?
10. RBAC Assignments for Storage App

Section 16: Working with Redis – Caching, Session Storage, and Beyond

1. Introduction to Redis
2. Installing Redis: Server, CLI and GUI
3. Data Types in Redis
4. Working with Strings in Redis
5. Time-to-Live (TTL): Expiring Keys in Redis
6. Database Management in Redis
7. Organizing Redis Keys with Namespacing
8. Connecting Redis in Node.js
9. Creating getJSON() and setJSON() Methods
10. Working with RedisJSON Data Type
11. Redis vs MongoDB: Speed Test
12. Using Redis for Caching
13. Using Redis as Session Store
14. Understanding Redis Search and Indexing
15. Fixing Multiple Device Access
16. Working with Redis Search in GUI
17. Exploring Redis Extension for VSCode
18. What is Fuzzy Search in Redis?
19. Understanding SCAN Command in Redis
20. KEYS vs SCAN Command in Redis
21. Working with Redis Lists Data Type
22. Working with Redis Sets Data Type
23. Working with Redis Hashes Data Type
24. Working with Redis Hashes in Node.js
25. Real-Time Messaging with Redis Pub/Sub
26. Enabling Authentication in Redis
27. Understanding Eviction Policies in Redis
28. Exploring Redis Cloud
29. More Topics to Explore in Redis

Section 17: Securing Our Node.js Application

1. Importance of Security in Web Apps
2. Using .env File in Node.js Natively
3. Storing Sensitive Info in .env File
4. Understanding SQL Injection Vulnerability
5. Schema-Based Data Validation With Zod
6. Prevent SQL Injection: Validate User Input With Zod
7. Understanding Same-Origin Policy
8. Hacking the Web: Learn XSS Attacks Practically
9. Fix XSS Vulnerability Using DOMPurify
10. Types of XSS Attacks
11. Understanding Reflected XSS Attack
12. What Is DOM-Based XSS Attack?
13. Understanding Content Security Policy in Depth
14. Reporting CSP Violations
15. Using Inline Scripts With Hash
16. Using Inline Scripts With Nonce
17. Performing Self-XSS Attack Even After CSP Is Enabled
18. What Is Clickjacking?
19. Understanding Domain Attribute in Cookies
20. Understanding Top-Level Navigation
21. Creating Self-Signed HTTPS Server in Node.js
22. Understanding SameSite Cookie Attribute in Depth
23. SameSite Cookies Attribute With Cross-Site Fetch Requests
24. Understanding Cross-Site Request Forgery (CSRF) Attacks
25. Preventing CSRF Attacks With CSRF Tokens
26. Creating a CSRF Token Middleware
27. Preventing CSRF Attacks Using Custom Headers
28. Understanding Denial of Service (DoS) Attack
29. Protecting APIs With Rate Limiting
30. Using express-rate-limit Package
31. Understanding DDoS Attack
32. Important Security Headers You Should Know
33. Using Helmet.js for Adding Security Headers
34. Add API Throttling With Custom Throttle Function
35. Using express-slow-down Package for Throttling
36. Benefits of Throttling
37. Drawbacks of Throttling
38. Dynamic Throttling vs Adaptive Throttling
39. Rate Limiting vs Throttling
40. Searching Security Vulnerabilities in Storage App
41. What Are Dependency Vulnerabilities?
42. More Security Topics to Know

Section 18: Cloud Storage Integration with AWS S3

1. Showing Size of Each File
2. Setting Max File Size Limit
3. Adding Server-Side Validation for Max File Size
4. Implementing Folder Size Feature
5. Adding Total Storage Limit
6. How to Add Path and Breadcrumb Features?
7. Introduction to AWS S3 Bucket
8. Benefits of Using S3 Bucket
9. Serving Files Publicly Using S3 Bucket
10. AWS CLI Introduction and Installation
11. Working with S3 Bucket Using CLI
12. Understanding AWS S3 API Command
13. Managing Bucket Policy Using S3 API
14. What Is AWS CloudShell?
15. Understanding Signed URL in S3
16. Identity and Access Management (IAM) in AWS
17. What Are User Groups in IAM?
18. Understanding IAM Policies
19. Understanding IAM Roles
20. AWS S3 SDK Setup in Node.js
21. S3 CRUD Operations Using Node.js
22. Showing S3 Upload Progress in Node.js
23. Creating GET and PUT Signed URLs Using Node.js
24. Creating Signed URLs Using AWS Presigner Library
25. S3 Storage Classes and Pricing
26. Delivering Content at Lightning Speed with CloudFront CDN
27. Cache Invalidation in CloudFront
28. Securing Files with CloudFront Signed URLs
29. Comparing CloudFront Pricing with S3 Pricing
30. Preparing Our StorageApp for S3 Bucket Integration
31. Uploading to S3 from Browser (CORS Enabled)
32. Integrating S3 Bucket in StorageApp – File Uploads
33. Integrating S3 Bucket in StorageApp – File Downloads
34. Implementing Upload Complete Endpoint for File Verification
35. Implementing Delete Feature for S3 Files
36. Integrating CloudFront in StorageApp

Section 19: Razorpay and Stripe Payment Gateway Integration

1. Introduction to Payment Gateway
2. Creating Razorpay Account: Step-by-Step Guide
3. Creating Stripe Account: Step-by-Step Guide
4. Different Ways to Accept Payments with Razorpay and Stripe
5. Enabling International Payments on Razorpay
6. Receiving Payments Using Code in Razorpay
7. What are Orders in Razorpay?
8. Different States of Payment in Razorpay
9. Using the Razorpay API: A Complete Guide
10. Calling Razorpay API Using Fetch with Basic Auth
11. Working with Node.js SDK of Razorpay
12. Secure Payments with Razorpay Orders
13. Integrating Razorpay in React and Node.js
14. Securing Razorpay Order Creation
15. Loading Razorpay CDN Script Dynamically
16. Custom Checkout in Razorpay
17. Accepting Payments on Stripe Using Payment Links
18. Difference Between Invoice and Receipt
19. What are Line Items?
20. Receiving Amount in the Available Balance in Stripe Test Mode
21. Introduction to Stripe API
22. Core Resources in Stripe
23. Payment Objects in Stripe - Checkout Sessions, Payment Intents, and Charges
24. Getting Started with Stripe Node.js SDK
25. Creating Checkout Session in Stripe Using Node.js
26. Integrating Stripe in React and Node.js
27. Custom Checkout in Stripe
28. What is a Webhook?
29. Why Do We Need Webhooks in Payment Gateway?
30. Using ngrok to Make Our Server Public for Testing Webhooks
31. Webhooks in Action
32. Verifying Webhook Signature
33. Understanding Webhooks Retry Logic
34. Automatic Payments with Razorpay Subscriptions
35. Subscription States in Razorpay
36. Creating Razorpay Subscriptions Using Node.js
37. Webhooks in Razorpay
38. Verifying Razorpay Webhook Signature
39. Subscriptions in Stripe
40. Listening to Stripe Subscription Webhook Events
41. Customer Portal in Stripe
42. Integrating Razorpay in StorageApp
43. Assignments for Payment Gateway Integration in StorageApp

Section 20: Mastering Deployment and CI/CD Pipelines

1. Creating GitHub Repository for StorageApp
2. One Click Deployment with Netlify and Render
3. Deploying Node.js Backend on AWS EC2
4. Understanding PM2 in Depth: Background Process Management
5. What Is NGINX and How to Install It?
6. NGINX Configuration Deep Dive + Static Server
7. Understanding the Autoindex and Location Directives in NGINX
8. Creating Multiple Servers Using NGINX
9. What Is a Proxy Server? Forward vs Reverse Proxy Explained
10. Using NGINX as a Reverse Proxy for Node.js Apps
11. Setting Response and Request Headers in NGINX
12. Understanding Variables in NGINX
13. NGINX Logs Explained: Access Logs and Error Logs
14. Setting Up NGINX Server on AWS EC2
15. HTTP to HTTPS: Enabling SSL Certificate on Our Website
16. Deploying React App on AWS EC2 Using NGINX
17. Deploying React App on S3 and CloudFront for Lightning Fast Speed⚡
18. Adding Custom Domain + SSL to CloudFront with ACM
19. Using Cloudflare for DNS Management
20. CloudFront Functions Explained
21. Understanding and Paying AWS Bills
22. Introduction to CI/CD
23. What Is DevOps?
24. Automating Deployments with Bash Scripting
25. Create Custom CI/CD Pipeline Using Node.js and GitHub Webhooks
26. Verifying GitHub Webhook Signature
27. Creating Custom CI/CD Pipeline for Backend
28. Zero Downtime Deployment with PM2 Cluster Mode
29. Turning Our Laptop Into a CI/CD Server
30. What Is GitHub Actions?
31. How to Run Jobs Sequentially?
32. What Are Actions in GitHub Actions?
33. Expressions and Context Objects in GitHub Actions
34. Understanding Environments and Secrets in GitHub Actions
35. Setting Environments Dynamically in GitHub Actions
36. Understanding If Condition in GitHub Actions
37. Creating CI/CD Pipeline for Frontend Using GitHub Actions
38. Creating CI/CD Pipeline for Backend Using GitHub Actions
39. Setting Up Self Hosted Runners
40. Assignments for Deployment Section

Section 21: Serverless Computing with AWS Lambda

1. What Is Serverless Computing?
2. Introduction To AWS Lambda Functions
3. Checking AWS Lambda Logs In CloudWatch
4. Developing AWS Lambda Locally
5. Creating A Todo API Using AWS Lambda
6. Lifecycle Of A Lambda Function
7. Connecting A Database In AWS Lambda
8. Serving Files Using Lambda Functions
9. Creating An Express App With AWS Lambda
10. What Is An API Gateway?
11. Understanding AWS API Gateway
12. Default Route In AWS API Gateway
13. Route Priority In AWS API Gateway
14. Adding A Custom Domain In API Gateway
15. Adding An API Gateway Trigger In Lambda Functions
16. Deploying StorageApp On AWS Lambda
17. Fixing Login Issues By Increasing Lambda Memory
18. Fixing File Access Issues Caused By An Invalid CloudFront Private Key
19. Fixing File Upload Issues By Granting S3 Permissions To Lambda
20. AWS Lambda And API Gateway Pricing
21. How HTTP Requests Reach Lambda Function
22. Introduction To Serverless Framework And Assignments

Section 22: Observability Fundamentals for Production Systems

1. Why Observability Matters in Production
2. Monitoring vs Observability
3. Understanding Production Failures in Backend Systems
4. The Three Pillars of Observability
5. Introduction to Metrics
6. Types of Metrics in Backend Systems
7. Understanding Time Series Data
8. How Metrics Are Stored and Queried
9. Introduction to Prometheus
10. Exposing Metrics from a Node.js Application
11. Prometheus Scraping and Target Discovery
12. Understanding Labels and Cardinality
13. Introduction to PromQL
14. Calculating Rates, Averages, and Percentiles
15. Understanding Latency and Tail Latency
16. Histograms and Percentile Approximation
17. Designing Good Metrics for Node.js Backends
18. Introduction to Logging in Production
19. Structured Logging and Log Levels
20. Logging in Node.js with Pino
21. Centralized Logging Concepts
22. Introduction to Loki
23. How Loki Stores and Queries Logs
24. Writing Effective LogQL Queries
25. Correlating Logs with Requests
26. Introduction to Distributed Tracing
27. Understanding Traces and Spans
28. Introduction to OpenTelemetry
29. Tracing a Node.js Application
30. Introduction to Grafana
31. Visualizing Metrics in Grafana
32. Visualizing Logs in Grafana
33. Correlating Metrics and Logs in Grafana
34. Introduction to Alerting
35. Designing Meaningful Alerts
36. Observability for Database-Heavy Applications
37. Observability for API Performance
38. Debugging Slow Requests in Production
39. Debugging Errors Using Metrics and Logs
40. Observability Architecture for a Single VPS
41. Scaling Observability Concepts
42. Introduction to APM Tools
43. Observability vs APM
44. Grafana Stack vs ELK Stack
45. Cost Considerations in Observability
46. Production Observability Checklist
47. Common Observability Mistakes
48. Observability Best Practices for Node.js
49. Real World Observability Case Study
50. Designing an Observability Strategy from Scratch