🚀 Highlights of the Ultimate Backend

Development Course 🚀
• 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.
◦ Learn introduction to golang and how to write backend services with golang.
• 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, Uber backend,
leetcode backend, 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.
◦ 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
• Key patterns in Typescript , Utility types and mapped types
Object-oriented programming with TS
• Abstraction polymorphism and inheritance in TS
• Writing functional and object oriented code with typescript
• Introduction to itnerfaces and generics
Low level design patterns in TS
• Builder Patter, Singleton pattern, and Factory pattern
• Facade, Strategy, Observer, Adapter pattern
• Proxy, State Machine and Chain of responsibility patterns and more..
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
Golang and Backend in Go
• Learn the basics of Go programming language
• Understand concurrency and parallelism in Go
• Master error handling and logging in Go
• Explore database integration with Go
• Gain proficiency in writing RESTful APIs with Go
• Implement authentication and authorization in backend apps using Go
• Utilize third-party packages and libraries for efficient backend development
with Go
• Integrate AWS SDK for Go into your applications for AWS service interaction
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
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
• 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
• 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
• 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
• 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
• 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
• 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
• 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
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
• 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
• 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
Leetcode Backend
• Write microservices to accept submission and run submissions
• Understand how code submissions of multiple languages can be run in docker
containers
• Understand storage of test cases in blob storages
• Integrate redis queues to prepare scalable submission platform
• Understand fastify integration for scalable microservices
• Integrate sockets for submission responses
Uber Backend
• Understand how geohashing works and comparison with quad trees
• How to use databases to use geohashing and find nearby drivers
• Use scalable APIs to keep access of current location of drivers
• Use websockets for real time driver and user notifications

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
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