Lambda 4.

0 Course Syllabus
🚀Development Course 🚀
Highlights of the Ultimate Backend

Master the Fundamentals of Backend Engineering:

Gain a deep understanding of Node.js internals, including the V8 engine,

event loop, and raw HTTP server development.

Learn how to build typesafe backends with TypeScript and frameworks

like Express and tRPC.

Industry-Ready Project Structures and Best Practices:

Design scalable applications with MVC architecture, service layers, and

repository layers.

Explore modern database practices: sharding, replication, indexing, and

schema optimization for apps like Twitter and Airbnb.

Build Cutting-Edge Real-World Projects:

Develop Codesandbox clone, Netflix-style streaming app, Live streaming

platform, and a hotel booking backend with microservices.

Implement advanced features like video transcoding, adaptive streaming,

and RTMP protocol for live streams.

Modern Communication Standards and APIs:

Dive into GraphQL and gRPC to build high-performance, scalable APIs.

Master REST API development with real-world examples like building a

Twitter backend.

Scaling and Deployment Like a Pro:

Scale apps using AWS Cloud: EC2, RDS, S3, Lambda, and auto-scaling
groups.

Lambda 4.0 Course Syllabus 1

 Learn Docker, Kubernetes, and CI/CD pipelines for containerization and
automation.

Explore Redis for caching, queues, and geospatial indexing for apps like
Uber.

Hands-on System Design and Advanced Concepts:

Design scalable systems like Twitter, Netflix, and Uber with load balancers,
consistent hashing, and CAP theorem.

Implement authentication and authorization with JWT, OAuth 2.0, and

secure session management.

Course Syllabus 🔥
Node JS
V8 engine, LibUV and internals of NodeJS

Event Loop | Timer, Close, I/O Queue | I/O poll

Module pattern in NodeJS, ES6 and CommonJS modules

Streams in NodeJS and application of Streams | Read and Write streams |

Piping Streams

How the C++ layer of Node interacts with JS layer

How to do network interactions in NodeJS

How to write a raw HTTP server without any 3rd party framework in Node

Writing an HTTP Client in NodeJS

Typescript
Understanding typescript and type interfacing

Generics and interfaces in TS

Lambda 4.0 Course Syllabus 2

 Key patterns in Typescript , Utility types and mapped types

Express JS + TS
Making http servers in ExpressJS

Handling dynamic data with URL parameters and query strings

Middleware in Express: Most important aspect of Express

Routing in ExpressJS

Writing express code with typescript

APIs in NodeJS - REST APIs - Make a Twitter APP

Backend
What are APIs and why do you need them ?

REST APIs and REST standards, Status Codes in Rest

Designing API operations & endpoints and handling HTTP methods (GET,
POST, PUT, DELETE)

Headers, Request Body, Response Body and best practices

API Versioning and its importance

Modern communication standard with gRPC &

graphQL
What is gRPC and why is it better than rest ?

Protocol buffers and performance improvements offered by gRPC

GraphQL and graphQL queries

Queries vs Mutations

Setting up a GraphQL server with Apollo Server

Understanding resolvers and schema design

|
Lambda 4.0 Course Syllabus 3
 MVC Architectures | Services and repository layers
Making industry ready project structure with MVC and modified MVC

Service layer, Schema layer and repository layer

Config layer, Seeders and Controllers

Routing layer, Config layer

Jobs and consumers

Writing Validations using Zod

Using Zod to add validation layers

Validating request body with zod

Writing Zod schema

Writing validations manually without zod

Writing Typesafe backends with tRPC

Understanding what is RPC and why it is useful

Understanding different RPC frameworks

Making backends with tRPC , a typescript first framework.

Making URL Shortener with tRPC

Microservices | Monolith and Monorepo

Creating projects as monolith

Understanding microservices and interservice communication

Sync and Async microservice communication

Making monorepo and understanding turbo repo

Transactions in microservices

File uploads using AWS S3 & Multer

Lambda 4.0 Course Syllabus 4

 Handling file uploads using AWS S3

Presigned URL and optimising uploads

Integrating multer for managing uploads in Node

Websockets and Socket.IO

Need of websockets and implementing sockets using Socket.io

Events in socket.io with acknowledgments

Rooms and namespaces in sockets

Real time communication using websockets

Server sent events and polling, How are they different from sockets

Basic Databases - MySQL & MongoDB

Why databases are requires ? Introduction to MySql

Basic CRUD Queries in MySQL, Pagination, Limit, Offsets, Where, Having, etc.

Introduction to MongoDB

Basic CRID Queries in MongoDB

MongoDB Atlas

Normalisation and Different normal forms

Indexing in Databases
Creating indexes in databases

Types of Indexes

Checking query performance with and without indexes

Internals of Indexes - B-Trees

Scaling DBs - Partitioning , Replication & Sharding

Lambda 4.0 Course Syllabus 5

 Partitioning DBs and why do you need partitioning

Scaling DBs further with practically sharding your DBs

Controlling DB shards in express

Replication In DBs and its needs

Replication in Distributed DB - Master slave & Multi

Master
Need of replication for scaling databases

Strategies of replicating a database

Replication in a write/read heavy system

Master slave and multi master architecture

leader less architecture and quorums

Schema Designing - Twitter & Airbnb

Designing Complex DB schema - Designing Social Media DB & Airbnb DB

Normalising the DBs

Optimising for different edge Cases

Advanced Transaction in databases

ACID properties in databases

Understanding atomicity and how DBs implement atomicity

Consistent and consistency patterns

Strong vs eventual consistency

Isolation levels and serialisation

Durability in DBs, Pessimistic & Optimistic Concurrency control

Advanced MongoDB

Lambda 4.0 Course Syllabus 6

 backing up mongodb databases

Sharding and replicating mongodb databases

Transactions in MongoDB and ACID in mongo

Indexing and performance in Mongo along with Security in mongoDB

Aggregation framework in Mongo

ORMs and ODMs

Integrating ORMs and ODMs in Express

Mongoose ODM for MongoDB

Prisma ORM and TS Support

Authentication and Authorization

Token and Session based Auth

JWT-based authentication

Role-based access control

OAuth2.0 and third-party authentication

Secure session management

REDIS
Understanding redis infrastructure

Using redis as a cache and how redis helps in scaling your applications

Redis as a queue and integrating redis with Node using BullMQ

Redis Geospatial indexing and it’s use cases in applications like Uber

Scaling apps with AWS Cloud

AWS EC2 and deploying applications using AWS EC2

Amazon machine image and configuring images for EC2 instances

Lambda 4.0 Course Syllabus 7

 Elastic load balancer in AWS

Auto scaling and horizontal scaling with EC2 instances and Scaling groups

Vertical scaling in EC2 instances

AWS Key vault service

Scaling NodeJS and Deploying Node Apps

Deploying node apps on Render

Deploying node apps on AWS

Scaling node apps by running on multiple cores

Using PM2 for managing multiple node daemons

Auto-restarting Node.js apps on crashes

Databases in AWS Cloud

AWS RDS for relational databases in AWS

AWS Document store and MongoDB Atlas

Amazon dynamoDB

Amazon S3 (Simple storage service) for blob storage

Amazon redshift

AWS Lambda & IAM

Creating serverless function in AWS Lambda

Setting up permissions using IAM

Integrating lambda with ELB

Basics Of System Design

Horizontal and vertical Scaling

Load balancers and their usecases

Lambda 4.0 Course Syllabus 8

 L4 and L7 load balancers

Improving system performance with Caching

Redis cache and setting up redis

Scaling databases with sharding and replication

System design of twitter, codesandbox, leetcode, netflix and uber.

Microservices and scaling microservices

CAP Theorem

Consistent hashing

SQL vs NoSQL

Containers and Docker

Virtual machines and Docker containers

Images and containers, Creating your own Docker images

Publishing images to docker hub

Understanding docker CLI

Docker volumes and networking in docker

Applications of docker containers in real life systems like leetcode and

codesandbox

Devops for backend engineers

What is devops and why you need to know devops ?

Writing CICD pipelines with Github actions and Jenkins

Understanding artifacts

Preparing steps and jobs in pipelines

Storing and managing secrets in CI CD Pipelines

Setting up jenkins on AWS for scaling pipelines

Lambda 4.0 Course Syllabus 9

 Understanding containerisation and container orchestration with Docker and
Kubernetes

Infrastructure as Code (IaC) using Terraform and AWS CloudFormation

Monitoring and logging practices using tools like Prometheus, Grafana, and
ELK stack

Implementing blue-green deployments and canary releases

Setting up automated testing environments in CI/CD pipelines

Performance monitoring and optimisation in production environments

Setting up automated alerts and incident response systems

Kafka and RabbitMQ

Understanding message queues and their importance in distributed systems

Apache Kafka architecture - Topics, Partitions, and Brokers

Kafka Producer and Consumer APIs in NodeJS

Kafka Stream processing and real-time data pipelines

RabbitMQ architecture and message exchange patterns

Implementing publish-subscribe patterns with RabbitMQ

Message acknowledgments and delivery guarantees

Dead letter queues and message retry mechanisms

Scaling message queues and handling high throughput

Comparing Kafka vs RabbitMQ - use cases and trade-offs

Idempotent API, API Gateways and Proxies

Understanding idempotency and it’s use cases

Implementing an Idempotent API

NGINX as a reverse proxy and load balancer

API Gateway patterns and implementation using Kong and AWS API Gateway

Lambda 4.0 Course Syllabus 10

 Rate limiting and throttling in API Gateways

Request/Response transformation and routing

API versioning and documentation

Authentication and authorization at gateway level

Circuit breaking and fallback mechanisms

Caching strategies at the proxy layer

Cross-origin resource sharing (CORS) configuration

Fastify - Boost up your node servers 100x

Understanding Fastify's architecture and performance benefits over Express

Schema validation and serialization using JSON Schema

Plugins and hooks in Fastify for extending functionality

Request-response lifecycle and middleware system

Type support and TypeScript integration

Building high-performance REST APIs with Fastify

Performance benchmarking against other Node.js frameworks

Testing - Unit and Performance testing

Writing unit tests using Jest framework

Test driven development (TDD) approach in Node.js

Mocking dependencies and API calls using libraries like Sinon

Integration testing of REST APIs using Supertest

Testing asynchronous code and handling promises in tests

Setting up continuous testing in CI/CD pipelines

Stress and performance testing using K6

Performance testing and monitoring using Postman

Lambda 4.0 Course Syllabus 11

 Misc Topics
Dumping logs in mongoDB

Dumping application logs in Azure Cosmos

LinkedIn Optimisation and Resume preparation

Writing CRON Jobs in NodeJS

Integrating payment gateways like razorpay

Integrating mailers in a node app

Monitoring and Observability

Projects 🧩
Codesandbox clone
Make a project similar to Codesandbox / Google Project IDX / Repl.IT

How to integrate code editor in the browser ?

How to run a react project in browser using containers ?

How to show project structure like VS code in browser ?

Editting files and creating / deleting files from the browser

WS library and integrating sockets in the APP

Running an end to end react project in the browser

Movie Streaming app backend

Learn how to Make Full stack streaming apps like Netflix

How to stream recorded & live videos like Netflix

How to handle user with low internet using Video segmenting

Process videos to multiple resolutions for low connectivity

Streamlining content for adaptive streaming with HLS

Lambda 4.0 Course Syllabus 12

 Make your app CORS ready | Stream using multiple packets

Video transcoding architecture | Parallelise video uploading

Live Streaming App

Learn how live streaming is done using nodejs

Understand the concept of RTMP protocol

Integrating live stream using OBS

Implementing live stream player on the web

Twitter app backend

Understand Basic CRUD APIs in a social media setup

Understand complex schema setup with twitter app

Understanding of MVC architecture with services and repositories

Implementing complex ODM queries-

Telegram Bot
Integrating telegram related npm packages

Making a bot on the telegram app that can be customised for anything for free

setting up the node server to run the telegram bot logic

understanding packages in node and how to publish your own node pakcgaes

Booking.com backend
Setup microservices based hotel booking application

Integrating MySQL and MongoDB both for different microservices

Integrating authentication using JWT tokens

Handling concurrency issues in booking using transactional APIs

Implementing idempotent APIs

Lambda 4.0 Course Syllabus 13

 Integrating migrations in MySQL

URL Shortener
Use tRPC to prepare a typesafe backend for URL shortener

Techniques to shorten URL

Implementing shortener logic

Implementing redirections

Pre-requisites (Good to have)

All the below content are a set of important pre-requisites but if you don’t know
about them then don’t worry, immediately after your course purchase you will
get recorded content that you can start to consume before live classes start.

Basics Of JavaScript
Variables and Data Types (Numbers, Strings, Booleans, Objects, Arrays)

Functions and Function Expressions

Coercion

Scope and Closures

Promises and Async/Await

ES6+ Features (Arrow Functions, Destructuring, Template Literals)

Object-Oriented Programming in JavaScript

Event Loop and Asynchronous Programming

Error Handling (try-catch blocks)

Array Methods (map, filter, reduce, etc.)

Modern JavaScript Modules and Import/Export

Basic MySQL Queries & MongoDB Queries

Lambda 4.0 Course Syllabus 14

 For MySQL:

Basic CRUD operations (SELECT, INSERT, UPDATE, DELETE)

JOIN operations (INNER, LEFT, RIGHT, FULL)

Aggregation functions (COUNT, SUM, AVG, MAX, MIN)

GROUP BY and HAVING clauses

Indexing and database optimisation

Stored procedures and triggers

For MongoDB:

Document CRUD operations (insertOne/Many, find, updateOne/Many,

deleteOne/Many)

Query operators ($eq, $gt, $lt, $in, $or, $and)

Aggregation pipeline stages ($match, $group, $sort, $lookup)

Indexing in MongoDB

Array operators ($push, $pull, $addToSet)

Document relationships and embedding vs referencing

Basics of computer networks

OSI Model and its 7 layers (Physical, Data Link, Network, Transport, Session,
Presentation, Application)

TCP/IP Protocol Suite and common protocols (HTTP, HTTPS, FTP, SMTP)

IP addressing (IPv4, IPv6) and subnetting

DNS (Domain Name System) and how domain resolution works

Network security basics (Firewalls, SSL/TLS, HTTPS)

Client-Server architecture and request-response cycle

Torrents

Lambda 4.0 Course Syllabus 15