Web Development + System Design + Security + Devops (New)

course thumbnail
PRICE

$60.64

$91.54

33.76% off
Description

 

 

Web Development + System Design + Security

Prerequiste: HTML and CSS
Course start date 1 June 2026
Class timing: 9pm (Mon,tue,thu and Fri)
Class duration: 2 Hours
Live class, recording will also be provided.
 

 

PHASE 1: JavaScript Mastery

Module 1: Introduction to JavaScript

  • Introduction to JavaScript
  • Role in Web Development
  • State of JavaScript in 2026
  • Future Scope of JavaScript
  • JavaScript Engine vs Runtime
  • Introduction to V8 JavaScript Engine
  • How JavaScript Code Executes.

Module 2: JavaScript Fundamentals

  • Hello, World Program
  • Comments in JavaScript
  • Variables (var, let, const)
  • Primitive Data Types
  • Operators
    • Arithmetic, Comparison, Logical, Assignment
  • Type Coercion
  • Introduction to Memory (Stack vs Heap – basic idea)

Module 3: Control Flow

  • Conditional Statements
    • if-else
    • switch
    • Ternary Operator
  • Loops
    • for
    • while
    • do-while
  • Break and Continue

Module 4: Functions and Execution Context

  • What is a Function
  • Function Declaration, Expression, Arrow Functions
  • Parameters and Arguments
  • Return Values
  • Default and Rest Parameters
  • Execution Context
    • Global Execution Context
    • Function Execution Context
  • Creation Phase and Execution Phase
  • Hoisting
  • Scope
    • Global, Function, Block Scope

Module 5: Call Stack and Closures

  • Call Stack
  • Stack Frames
  • Function Invocation Flow
  • Closures (Introduction)
  • Closures with Memory Reference
  • Practical Use Cases of Closures

Module 6: Data Types Deep Dive

  • Strings
  • Arrays
    • Array Methods (map, filter, reduce, etc.)
    • Iteration Techniques
  • Objects (Basics)
  • Date and Time

Module 7: Objects in JavaScript

  • Object Properties and Methods
  • Object References and Copying
  • Optional Chaining
  • JSON (JavaScript Object Notation)
  • Symbol Data Type

Module 8: Modern JavaScript (ES6+)

  • Template Literals
  • Destructuring (Arrays and Objects)
  • Spread and Rest Operator
  • Default Parameters
  • Modules (import / export)
  • Maps and Sets
  • WeakMap and WeakSet

Module 9: Object-Oriented JavaScript

  • Introduction to OOP
  • Classes and Objects
  • Constructors
  • this Keyword (Basics)
  • Prototypal Inheritance
  • Encapsulation (Private Fields)
  • Polymorphism

Module 10: Asynchronous JavaScript

  • Synchronous vs Asynchronous Execution
  • setTimeout and setInterval
  • Callbacks
  • Callback Hell
  • Promises
  • Promise Chaining
  • async and await
  • Error Handling using try-catch

Module 11: Event Loop and Async Internals

  • JavaScript Single Thread Model
  • Web APIs (Browser Environment)
  • Callback Queue (Task Queue)
  • Microtask Queue
  • Event Loop
  • Microtask vs Macrotask
  • Execution Order Deep Dive

Module 12: DOM Manipulation

  • DOM Introduction
  • DOM Tree
  • Selecting Elements
  • Updating Content
  • Adding and Removing Elements

Module 13: Event Handling

  • Browser Events
  • Event Listeners
  • Event Bubbling and Capturing
  • Event Delegation
  • Prevent Default
  • Stop Propagation

Module 14: Network Requests and Advanced Concepts

  • HTTP Basics
  • Fetch API
  • Handling API Responses
  • Error Handling in Requests
  • CORS (Cross-Origin Requests)
  • Deep Dive into this Keyword
  • call, apply, bind
  • Advanced Error Handling
  • Custom Errors
  • Introduction to Garbage Collection
  • High-Level Optimization in V8 JavaScript Engine

10 Projects on javascript

Phase2: Backend Mastery

Module 1: Backend Fundamentals and Node.js Introduction

  • What is Backend Development
  • Client-Server Architecture
  • Need for JavaScript on Server
  • Introduction to Node.js
  • How Node.js runs JavaScript
  • Event-driven and Non-blocking nature

Module 2: Node.js Basics

  • Running JavaScript outside the browser
  • Global objects (process, __dirname, etc.)
  • Modules in Node.js
    • CommonJS (require, module.exports)
  • Creating a basic project structure

Module 3: Core Node.js (Only What You Need)

  • File System (fs)
    • Reading files
    • Writing files
  • Understanding async vs sync code in Node.js
  • Intro to Streams (very basic intuition)

Module 4: Building Your First Server

  • Creating HTTP server using Node.js
  • Request and Response objects
  • Handling routes manually
  • HTTP Methods
    • GET, POST, PUT, DELETE
  • Sending JSON data

Limitation discussion:

  • Why raw Node.js is painful → leads to Express

Module 5: Introduction to Express.js

  • Why Express.js
  • Setting up Express server
  • Basic routing
  • Handling requests and responses
  • Sending JSON

Module 6: Routing and Middleware

  • Route parameters
  • Query parameters
  • Middleware concept (very important)
  • Built-in middleware (express.json)
  • Custom middleware
  • Request lifecycle in Express

Module 7: REST API Development

  • REST principles (practical, not theory heavy)
  • CRUD operations
  • Designing endpoints
  • Handling request body
  • Status codes (important ones only)
  • Centralized error handling

Module 8: MongoDB Basics

  • Why database is needed
  • SQL vs NoSQL (quick comparison)
  • Introduction to MongoDB
  • Collections and Documents
  • Basic CRUD operations

Module 9: MongoDB with Mongoose

  • Introduction to Mongoose
  • Creating schemas and models
  • CRUD using Mongoose
  • Data validation
  • Simple relationships

Module 10: Authentication (Core Only)

  • Authentication vs Authorization
  • User signup and login flow
  • Password hashing using bcryptjs
  • JWT basics
  • Protecting routes using middleware

Module 11: File Uploads (Practical Feature)

  • Handling file uploads using Multer
  • Storing files locally
  • Returning file URLs

Module 13: AI Integration

  • What is LLM
  • Vector Database
  • Integrating AI
  • AI Agent

Projects

Phase 3: System Thinking and Backend Scaling Basics

Module 1: Introduction to System Thinking

  • What is System Design (practical meaning)
  • Difference between coding vs designing systems
  • Understanding scale (users, requests, data)
  • Latency vs Throughput (intuition only)
  • Monolith vs Microservices (high level overview)

Module 2: Backend Performance Basics

  • What happens when traffic increases
  • Identifying bottlenecks
    • CPU
    • Memory
    • Database
  • Introduction to horizontal vs vertical scaling
  • Why naive backend breaks under load

Module 3: Rate Limiting (Core Concept + Implementation)

  • What is Rate Limiting and why it is needed
  • Real-world use cases (login, APIs, payment endpoints)
  • Types of Rate Limiting
    • Fixed Window
    • Sliding Window (basic idea)
  • Implementing Rate Limiting in Express.js
  • Using middleware for rate limiting
  • Intro to tools like Redis (conceptual, optional)

Module 4: MongoDB Architecture Basics

  • How MongoDB works internally (high level)
  • Collections, Documents, Indexes revisited
  • What are Indexes and why they matter
  • Query performance basics
  • Replication (primary-secondary concept)
  • Sharding (very basic intuition, no deep dive)
  • When MongoDB becomes slow and why

Module 5: Caching Fundamentals

  • What is caching
  • Why caching improves performance
  • Where to use caching
    • API responses
    • Database queries
  • Intro to Redis
  • Cache invalidation problem

Module 6: Real-Time Systems with WebSockets

  • Why HTTP is not enough for real-time apps
  • Polling vs WebSockets vs SSE (high level)
  • Introduction to WebSockets
  • How WebSocket connection works internally (upgrade request)
  • Building real-time features using Socket.IO
  • Sending and receiving real-time data
  • Handling multiple clients

Module 7: System Design Thinking (Applied Basics)

  • Breaking a feature into components
  • Designing APIs for a feature
  • Handling data flow between client and server
  • Basic fault tolerance thinking
  • Simple scalability decisions
  • Build one project

Phase 4: Advanced System Design (Internals + HLD)

Module 1: Advanced System Design Foundations

  • Revisiting scalability with real numbers (RPS, storage, bandwidth)
  • Latency vs Throughput (quantitative understanding)
  • Availability vs Consistency (practical trade-offs)
  • CAP Theorem (applied, not theoretical)
  • Identifying bottlenecks in large-scale systems

Module 2: Core Architecture Components (Deep Understanding)

  • API Gateway (routing, authentication, aggregation)
  • Load Balancers
    • L4 vs L7
    • Algorithms (Round Robin, Least Connections, IP Hash etc)
  • Reverse Proxy
  • Stateless vs Stateful services
  • Service-to-service communication (sync vs async)

Module 3: Database Scaling

  • Database Replication
    • Master-Slave Architecture
  • Database Sharding
  • Consistent Hashing
    • Problem with traditional hashing
    • Hash ring
    • Node addition/removal
    • Load distribution
    • Use in caching and distributed systems
  • Eventual Consistency
  • Gossip Protocol and Merkle Tree
  • Leader Election and Distributed Coordination
  • Data Backups and Disaster Recovery

Module 4: Database Internals (MongoDB Focused)

  • Internal working of MongoDB
  • Storage engine (high level)
  • Indexing deep dive

B+ Tree

  • Why B+ Tree is used in databases
  • Disk-based access optimization
  • Structure and traversal
  • Search complexity
  • Range queries efficiency
  • Query execution using indexes
  • Read vs write trade-offs
  • Replication and sharding (internal reasoning)

Module 5: Searching Systems and Elastic Search

  • Why databases fail for search use cases
  • Introduction to Elastic search

Inverted Index

  • Concept and structure
  • Tokenization and indexing
  • Mapping terms to documents
  • Query phase vs indexing phase
  • Ranking and relevance (intuition)
  • Distributed search
    • Shards and replicas
  • Syncing DB with search engine

Module 6: Caching and Distributed Caching

  • Revisiting caching at scale
  • Cache strategies (deep)
  • Cache invalidation challenges
  • Internals of Redis (high level)
  • Data eviction strategies (LRU, LFU, FIFO etc)

Module 7: Messaging Systems and Kafka Internals

  • Why messaging systems are required
  • Queue vs Pub/Sub model
  • Introduction to Apache Kafka

Kafka Internals

  • Topics and partitions
  • Producers and consumers
  • Consumer groups
  • Offset management
  • Message ordering guarantees
  • Log-based storage system
  • Partitioning strategy
  • Fault tolerance and replication
  • Why Kafka is highly scalable

Module 8: Advanced Rate Limiting

  • Revisiting rate limiting at scale

Algorithms (Deep)

  • Fixed Window
  • Sliding Window
  • Token Bucket
  • Leaky Bucket
  • Distributed rate limiting challenges
  • Storing counters in cache/datastore
  • Designing rate limiter for real systems

Module 9: System Design Patterns

  • Microservices vs Monoliths
  • Strangler pattern
    • Decomposition by Business Logic
    • Decomposition by Sub-Domains
  • SAGA Pattern
    • Choreography-based
    • Orchestration-based
  • CQRS Pattern (Command Query Responsibility Segregation)
  • Circuit breaker pattern

Module 10: Modern Design Infrastructure

  • Content Delivery Networks (CDN)
  • Object Storage (S3-like systems)
  • Media Processing Pipelines
  • Search Systems
  • Recommendation Systems

Module 11: Observability and Debugging

  • Logging systems
  • Metrics and monitoring
  • Distributed tracing (basic idea)
  • Debugging production systems

Module 12: Security in System Design

  • Secure system architecture
  • Authentication vs Authorization at scale
  • API protection strategies
  • Rate limiting as a security layer
  • Handling common attack patterns (high level)

Phase 5: Frontend Development (React, TypeScript, Tailwind)

Module 1: Frontend Architecture and React Introduction

  • Role of frontend in full-stack systems
  • SPA vs MPA
  • Why React
  • Virtual DOM
  • Project setup (Vite)
  • Folder structure

Module 2: React Fundamentals

  • JSX
  • Functional Components
  • Props
  • Conditional Rendering
  • Lists and Keys
  • Event Handling

Module 3: State and Component Thinking

  • What is state
  • useState
  • Controlled vs uncontrolled components
  • Lifting state up
  • Component communication

Module 4: Side Effects and Data Fetching

  • useEffect
  • Dependency array
  • API calls
  • Cleanup
  • Common mistakes

Module 5: Advanced Hooks

  • useRef
  • useMemo
  • useCallback
  • Custom hooks
  • Optimization basics

Module 6: Routing

  • Introduction to React Router
  • Dynamic routes
  • Protected routes
  • Navigation patterns

Module 7: API Integration and Auth Flow

  • Connecting to backend APIs
  • Handling loading and error states
  • JWT flow (login/logout)
  • Token storage basics

Module 8: Introduction to TypeScript

  • Why TypeScript
  • Basic types
  • Interfaces vs types
  • Functions with types
  • Type inference

Module 9: TypeScript with React

  • Typing props
  • Typing hooks
  • Forms and events
  • API response typing
  • Common pitfalls

Module 10: Styling with Tailwind CSS

  • Introduction to Tailwind CSS
  • Utility-first approach
  • Layout (flex, grid)
  • Responsive design
  • Reusable UI components

Module 11: State Management (Redux and Alternatives)

Why Global State?

  • Problem with prop drilling
  • When local state fails

Introduction to Redux

  • Core concepts
    • Store
    • Actions
    • Reducers

Using Redux Toolkit

  • Why Redux Toolkit simplifies Redux
  • Creating slices
  • Configuring store
  • Dispatching actions
  • Accessing state with hooks

Async State Management

  • Handling API calls with Redux
  • Loading, success, error states

Alternatives (Important for maturity)

  • Context API (when to use)
  • Why not always Redux

Module 12: Forms and Validation

  • Controlled forms
  • Form validation
  • Error handling
  • UX best practices

Module 13: Performance Optimization

  • Re-rendering behavior
  • Memoization
  • Lazy loading
  • Code splitting

Phase 6: Capstone Projects

Project 1: Cloud Video Storage System (S3-like)

What You Will Build:

  • Video upload system (large file handling)
  • Secure access using presigned URLs
  • Video processing pipeline (basic transcoding workflow)
  • Video streaming system (HLS-based playback)
  • Storage and metadata management
  • Basic CDN-style delivery (conceptual)

Tools & Technologies:

  • Backend: Node.js, Express.js
  • Database: MongoDB
  • Caching: Redis
  • Messaging / Queue: Apache Kafka
  • Streaming: HLS (implementation level)
  • Frontend: React + TypeScript + Tailwind CSS

Project 2: Quick Commerce Platform (Blinkit-style + AI)

What You Will Build:

  • Full e-commerce flow (products, cart, orders)
  • Real-time rider tracking on map
  • Order lifecycle management (state machine)
  • Inventory and product management
  • Search and filtering system
  • Multi-channel notification system

AI Features:

  • AI-powered product recommendations
  • Semantic product search using vector embeddings
  • AI agent for user assistance (chat/query handling)

Tools & Technologies:

  • Backend: Node.js, Express.js
  • Database: MongoDB
  • Caching: Redis
  • Real-time: WebSockets
  • Messaging: Apache Kafka
  • Search: Elasticsearch
  • Vector Search: Vector DB (for embeddings-based search)
  • AI Integration: LLM APIs / AI agent framework (basic usage)
  • Frontend: React + TypeScript + Tailwind CSS + Redux Toolkit

Phase 7: Deployment and Production Setup

Good catch — without Nginx + HTTPS (TLS) your deployment phase is incomplete.

Right now you’re teaching “how to deploy”, but not “how production systems actually serve traffic securely”.

Let’s upgrade Phase 7 properly, without bloating it.

Phase 7: Deployment and Production Setup (Final)

Module 1: Version Control (Git and GitHub)

  • Introduction to Git
  • Branching, merging, conflicts
  • Introduction to GitHub
  • Collaboration workflow

Module 2: Environment and Configuration

  • Environment variables (.env)
  • Secrets management
  • Dev vs Production setup

Module 3: Containerization

  • Introduction to Docker
  • Dockerfile
  • Containerizing backend and frontend
  • Running full-stack apps in containers

Module 4: Deployment Fundamentals

  • What happens when you “deploy”
  • Frontend vs Backend deployment
  • Domains, DNS basics
  • Build process

Module 5: Backend Deployment (AWS)

  • Deploying Node.js app on Amazon Web Services
  • EC2 basics (virtual server)
  • Running server in production
  • Connecting database

Module 6: Web Server and Reverse Proxy (Critical)

  • What is a web server
  • Why we don’t expose Node.js directly
  • Introduction to Nginx
  • Reverse proxy concept
  • Routing traffic to backend
  • Serving static frontend files
  • Load handling basics

Module 7: HTTPS and Security (TLS)

  • Why HTTP is not secure
  • What is HTTPS
  • Introduction to TLS (encryption basics)
  • SSL/TLS certificates
  • Setting up HTTPS using Let's Encrypt
  • Auto-renewal of certificates
  • Securing APIs and frontend

Module 8: Frontend Deployment

  • Building React app
  • Hosting frontend
  • Connecting frontend with backend over HTTPS

Loading...