How long is the Full Stack Web Development course?

150 hours of live instructor-led training (lectures + hands-on lab practice), across weekday-evening or weekend batches.

Do I need prior experience to join?

No prior experience required. Basic computer literacy is enough - HTML/CSS familiarity helps but is taught from scratch.

Is the training online or classroom?

Both. Classroom batches run at our Mumbai campus; the same batch streams live for online students across India. Both get identical lab access.

Are the labs hands-on?

Yes - this is a lab-intensive course practiced on real equipment, with 24/7 remote lab access through Skillopia, our own lab platform, for practice between classes.

What comes after this course?

Pair with Data Structures & Algorithms for product-company interviews, or add our DevOps track to become a full lifecycle engineer.

Software Development

Full Stack Web Development with AI Integration (TypeScript, React, Node.js)

RST Forum's Full Stack Web Development course in Mumbai is an instructor-led program that takes you from your first HTML page to a production event-ticketing platform you build yourself. You learn HTML and CSS, JavaScript and TypeScript, React, Node.js and Express, Postgres, MongoDB and Redis - and then spend the back half of the course building FiRSTRow, a real application with seat maps, payments, live updates and an AI assistant. In the last phase you build an AI assistant into the product itself - a local model that answers from the organiser's own policies, searches events by meaning rather than keywords, and drafts listings - and you make it safe against prompt injection. That is AI integration as a working feature, not an API key pasted into a tutorial.

Duration: 150 hours
Training mode: Classroom & online
Course fees: ₹30,000
Level: Beginner

Course details verified 14 Oct 2026

Please note that the course fees exclude the certification cost.

Overview

Who should attend

Beginners who want one continuous path into web development rather than a pile of tutorials, and working developers who can build a front end but have never taken an application all the way to payments, concurrency and deployment. No prior programming experience is assumed; the course starts at how the web works and does not skip steps.

Roles this leads to

Typical India salary

Full Stack Developer (MERN)₹4–10 LPA
Frontend Developer (React)₹4–9 LPA
Backend Developer (Node.js)₹5–11 LPA
Product Engineer (startups)₹6–14 LPA

Outcomes

Skills you'll gain

HTML
CSS
JavaScript
Values & Variables
Conditionals
Arrays & Objects
Loops
Functions
Array Callback Methods
Special JavaScript Features

Objectives

What you'll be able to do

The course objectives, as the vendor's own blueprint states them.

Write semantic, accessible HTML and lay pages out with Flexbox and CSS Grid
Work fluently in modern JavaScript - closures, the event loop, promises and async/await
Use TypeScript properly: generics, unions, type guards and making illegal states unrepresentable
Build React applications with hooks, context, routing and sensible performance work
Build REST APIs in Node.js and Express with validation, error handling and structured logging
Design and query relational data in Postgres, and know when a document store is the better answer
Use Redis for caching and for state that must expire on its own
Implement authentication and authorization with hashed passwords, refresh tokens and role-based guards
Take payments with Stripe, handle webhooks, and make the whole flow idempotent
Push real-time updates over WebSockets and keep them correct across multiple server instances
Build an AI feature into a real application: retrieval over your own documents, semantic search, streaming answers and prompt-injection defence
Containerise an application, wire up CI, and deploy it
Diagnose a concurrency bug instead of hoping it goes away

Included

What you get

Taught live, in a classroom or online - not a video library you watch alone.
TypeScript throughout, not JavaScript with types added at the end.
One capstone built over eleven phases: FiRSTRow, an event ticketing platform with seat maps, payments and live updates.
You build a feature the beginner way first, feel why it hurts, then refactor it in five deliberate moves into controllers, services, repositories and dependency injection.
Concurrency taught by breaking it: fire fifty simultaneous purchases at one seat, watch it double-book, then fix it with transactions and row locks.
Three databases, each for what it is good at - Postgres for anything that must never be wrong, MongoDB for documents, Redis for holds that expire.
You build an AI feature, not a demo: an assistant inside the product that answers from the organiser's own documents, searches events by meaning, and drafts listings - running on a local model, with prompt-injection defence and no write access.
Every topic is taught at the moment the project first needs it.

Credential

Certification details

You graduate with an RST Forum certificate of completion and a deployable portfolio: real front-end and back-end projects built during the course.

The stack covered - JavaScript, Node.js, modern front-end and databases - maps directly to the MERN roles that dominate web-development hiring in India.

After the course

Placements & outcomes

Placement assistance is included: CV preparation, interview drills with real scenario questions, and referrals through our alumni network of 1 million+ engineers trained since 1997.

Proof

What students say

Drag to read more →

I learned programming concepts and coding under the guidance of Vivek sir, and I must say RST Forum is the best class for software courses in Mumbai.

BBhavesh Khandarevia UrbanPro

Learning path

Where this course takes you

This course is one stage of the Full Stack Development path - 8–12 months end to end, beginner → professional. Here is what comes before it, and what comes after.

Full Stack Web Development with AI IntegrationYou are hereFull Stack Developer · 3–4 months
Python ProgrammingAutomation Engineer · 2–3 months
DevOps (DevSecOps, AIOps, LLMOps)Product Engineer · 3–4 months

Next up: Python Programming - Every backend team keeps Python in reach - scripts, services and the AI tooling ecosystem.

See the full Full Stack Development path

17 modules

Full syllabus

Every module below is taught live and practiced hands-on - nothing here is a slide-only topic.

How the Web Works, HTML and Accessibility

How the Web Works

What Are HTML, CSS & JS?
How the Web Works
How Browsers Render a Page
Tools & Setup

HTML Document Structure

Your First HTML Page
Elements, Tags & Attributes
The Document Skeleton
The <head>: Page Metadata

Text Content

Headings & Paragraphs
Text Formatting & Inline Elements
Quotes, Code & Preformatted
Breaks, Rules & Whitespace
HTML Entities & Symbols

Lists & Tables

Lists: Ordered, Unordered & Description
Tables: Rows & Cells
Advanced Tables

Links & Images

Links & Anchors
Link Paths, Targets & Types
Images
Figures & Responsive Images

Media & Embeds

Video & Audio
Iframes & Embeds

Forms

Form Basics
Input Types
Labels, Fieldsets & Structure
Select, Textarea & Datalist
Buttons & Submission
Built-in Form Validation

Semantic HTML

Why Semantic HTML?
Layout Landmarks
Sectioning: section, article & aside
Time, Address, Details & More

Metadata & Accessibility

Global Attributes & data-*
SEO & Social Metadata
Accessibility Basics
ARIA Roles & Attributes

CSS: Styling, Flexbox, Grid and Responsive Design

CSS Foundations

What Is CSS?
Three Ways to Add CSS
Anatomy of a CSS Rule
How CSS Is Applied

Selectors & Specificity

Basic Selectors
Grouping & Combinators
Attribute Selectors
Pseudo-classes
Pseudo-elements
Specificity, Cascade & Inheritance

The Box Model

The Box Model
Padding, Border & Margin
box-sizing & Dimensions
The display Property

Colors & Backgrounds

Colors
Backgrounds
Gradients
Shadows, Opacity & Filters

Typography

Font Properties
Text Properties
Web Fonts
Advanced Text & Overflow

Units & Values

Units: px, em, rem, %
Viewport & Content Units
calc(), min(), max() & clamp()

Flexbox

Flexbox: The Concept
Flex Container Properties
Flex Item Properties
Centering & Alignment
Common Flexbox Patterns

CSS Grid

CSS Grid: The Concept
Defining Rows & Columns
Placing Items on the Grid
Grid Template Areas
Sizing: minmax, auto-fit & auto-fill
Alignment & Gaps

Positioning

The position Property
Relative & Absolute
Fixed & Sticky
z-index & Stacking Context

Responsive Design

Responsive Design
The Viewport Meta Tag
Media Queries
Mobile-First Workflow
Responsive Layout Patterns

Best Practices

Organizing CSS & Naming (BEM)
Resets & Sensible Defaults
Debugging CSS & DevTools

JavaScript Foundations

Orientation

What Is JavaScript?
What Is TypeScript?
How JS & TS Fit Together
Tools & Setup

First Steps & The Console

Using the Console
Comments & Editor Shortcuts

Variables, Data Types & Operators

Variables & Constants
Data Types - Primitives
Primitive vs Reference
Type Conversion
Type Coercion
Operators

Strings, Numbers, Math & Dates

Working With Strings
Working With Numbers
The Math Object
Dates & Times
Formatting Dates & Numbers

Arrays & Objects

Creating Arrays
Basic Array Methods
Nesting, Concat & Spread
Object Literals
Object Spread & Methods
Destructuring & Renaming
JSON Intro

Functions, Scope, Control Flow and Iteration

Functions, Scope & Execution

Function Basics
Parameters & Arguments
Global & Function Scope
Block Scope
Nested Scope & the Scope Chain
Declarations, Expressions & Hoisting
Arrow Functions
Immediately Invoked Functions (IIFE)
Execution Context
The Call Stack

Control Flow & Logic

If Statements
If, Else & Nesting
Switch Statements
Truthy & Falsy
Logical Operators
Logical Assignment Operators
The Ternary Operator

Loops & Iteration

The For Loop
Break & Continue
While & Do...While
For...Of
For...In
Array.forEach
Array.map
Array.filter
Array.reduce

Project: Shopping List

TypeScript: Types, Interfaces, Generics and the Compiler

TypeScript Foundations

Why TypeScript, Really
Installing & Using TypeScript
Running Compiled JS with Node
Type Inference vs Annotation
Typing Function Params & Returns
The any Type
Union Types
Arrays & Types
Tuples
Object Types
The Record Type
Enums
Literal Types
Type Aliases & Custom Types
void & never
Functions as Types
null, undefined & Narrowing
Optional Chaining & Non-null Assertion
Type Casting (Assertions)
The unknown Type
Optional Values & Nullish Coalescing

The TS Compiler & tsconfig

Creating a tsconfig.json
Target & Libs
Controlling Files & Emission
Strict Type Checking
Code-Quality Checks
Compiling & Watch Mode
Installing @types Packages

Interfaces & Type Modeling

Introducing Interfaces
Interfaces as Object Types
Interfaces vs Type Aliases
Interfaces for Function Types
Implementing Interfaces
Extending Interfaces
Intersection Types
Type Guards & Discriminated Unions
Type Guards via instanceof
Custom Type Guards & Predicates
Function Overloads
Index Signatures
as const
The satisfies Keyword

Generics

A Generic We Already Know: Array<T>
Understanding Generic Types
Creating Generic Types
Generic Functions & Inference
Multiple Type Parameters
Generic Constraints (extends)
Constraints with Multiple Types
Generic Classes & Interfaces

Advanced Types

The typeof Type Operator
keyof
Indexed Access Types
Mapped Types
Readonly & Optional Modifiers
Template Literal Types
Conditional Types
The infer Keyword
Built-in Utility Types

Decorators

What Are Decorators?
The Decorator Types
Building a First Decorator
Class Decorators That Modify
Decorator Execution Order
Method & Accessor Decorators
Field & Parameter Decorators
Configurable Decorators (Factories)

Modern JavaScript, the DOM and Events

Modern JS/TS Syntax

let & const, Typed
Arrow Functions, Typed
Default Parameters
The Spread Operator
Rest Parameters
Destructuring, Typed
How Code Gets Compiled

The DOM

Intro to the DOM
Document & Element Properties
Selecting Single Elements
Selecting Multiple Elements
Traversing the DOM - Elements
Traversing the DOM - Nodes
Create & Append Elements
innerHTML vs createElement
Insert Elements, Text & HTML
Replace Elements
Remove Elements
Styles & Classes

Events

Event Listeners
Mouse Events
The Event Object
Keyboard Events
Input & Change Events
Form Submission & FormData
Event Bubbling
Event Delegation
Page & Window Events

Asynchronous JavaScript, Promises and Fetch

Async Foundations

The Thread of Execution
How Async Works: The Event Loop
setTimeout & clearTimeout
setInterval & clearInterval
Callbacks
HTTP Request Crash Course
AJAX & the XHR Object
Callback Hell
Promises
Promise Chaining
Promise.all, allSettled, race, any

Fetch & Async/Await

Fetch Basics
Fetch Options: Method, Body, Headers
Fetch Error Handling
async & await
try...catch
async/await Error Handling
Typing Fetch with Interfaces & Generics

Project: Flixx Movie App

Objects, Classes, Modules and Build Tooling

OOP & Prototypes

What Is OOP?
The Four Principles of OOP
Object Literals & this
Constructor Functions
Literals vs Built-in Constructors
Working with Object Properties
Prototypes & the Prototype Chain
Adding Methods to the Prototype
Object.create
Prototypal Inheritance & call()

Classes

ES6 Classes
Class Inheritance
Static Methods & Properties
bind() & Defining this
Getters & Setters
Getters & Setters with defineProperty
Private Property Convention
ES2022 Private Fields (#)
Property Flags & Descriptors
Sealing & Freezing Objects
TS: public, private, protected, readonly
TS Parameter-Property Shortcut
TS Abstract Classes

Modules

What Are Modules?
CommonJS Modules
NPM Packages
ES Modules
TS Modules: Namespaces vs ES Modules
Import/Export Syntaxes & Re-exports
type Imports & Module Execution

Build Tooling with Vite

The Problem with tsc Alone
Build Tools Overview
Introducing Vite
Using Vite: Dev Server & Build
TypeScript Per-Project
Making Sense of .d.ts Files
Importing non-TS Files

Project: Tracalorie
Project: Drag & Drop Manager

Data Structures, Algorithms and Testing

Iterators, Generators, Sets & Maps

Symbols
Iterators
Generators
Sets
Maps

Data Structures

Stacks
Queues
Linked Lists

Algorithms & Testing

What Are Algorithms?
What Is Unit Testing?
Getting Started with Vitest
Grouping Tests with describe()
Algorithms: Reverse & Palindrome
Algorithms: Chunk & Anagram

Node.js Built-in Modules

Node.js Recap & Modules
The FS Module
The Path Module
The OS Module
The URL & Query String Modules
The HTTP Module: A Basic Server

React Fundamentals: Components, Props and State

Introduction to React

What Is React?
Imperative vs Declarative UI
SPAs & Where React Fits
The React Mental Model

Setup with Vite

Creating a React App with Vite
The Project Structure
The Entry Point: main.tsx
StrictMode & React DevTools

JSX In Depth

What Is JSX?
JSX Behind the Scenes
Embedding Expressions
Attributes & Props in JSX
Children & Fragments
JSX Rules & Gotchas

Elements & Components

React Elements
Elements vs Components vs Instances
The Element Tree
From Elements to the DOM

Virtual DOM & Reconciliation

The Virtual DOM
Reconciliation & Diffing
The Diffing Heuristics
The Fiber Architecture
Render Phase & Commit Phase
Concurrent Rendering

How Rendering Works

What Triggers a Re-render?
Re-render Propagation
Rendering Must Be Pure
State as a Snapshot

Components & Props

Function Components
Props: Passing Data Down
The children Prop
Typing Props with TypeScript
Composition over Configuration

Lists & Keys

Rendering Lists with map()
Keys In Depth

Conditional Rendering

Conditional Rendering
Conditional Patterns & Pitfalls

Events

Handling Events
The Synthetic Event System

State with useState

useState: Adding State
Updating State Immutably
Updater Functions & Batching
Structuring State
Lazy Initial State

Forms

Controlled Components
Uncontrolled Components & Refs
Working With All Inputs
Many Inputs, One Handler
Form Actions (React 19)

Sharing State

Lifting State Up
Prop Drilling (and the Problem)

React Hooks, Context and Performance

The Rules of Hooks

What Are Hooks?
The Rules of Hooks
How Hooks Work Internally

useEffect

useEffect: Side Effects
The Dependency Array
Cleanup Functions
Mount, Update & Unmount
useEffect Pitfalls
You Might Not Need an Effect

useRef

useRef: Accessing the DOM
useRef for Mutable Values
Forwarding Refs (ref as a prop)
useImperativeHandle

useContext

The Problem Context Solves
createContext & Provider
Consuming with useContext
Context Patterns & Performance

useReducer

useReducer: Complex State
useReducer vs useState
Reducer + Context

Memoization & Performance

Referential Equality
useMemo
useCallback
React.memo
An Optimization Strategy

Concurrent Features

useTransition
useDeferredValue
useLayoutEffect
useId, useSyncExternalStore & More

Custom Hooks

Building Custom Hooks
Custom Hook Patterns
Sharing Logic, Not State

React 19, Routing, Data Fetching and Production

React 19 New Features

What's New in React 19
Actions & useActionState
useFormStatus & useOptimistic
The use() API
The React Compiler
Server Components (Concept)

Suspense & Lazy Loading

lazy() & Suspense
Suspense for Data Fetching

Error Boundaries

Error Boundaries
Practical Error Handling

React Router

React Router: Setup
Routes, Links & Navigation
Nested Routes & Layouts
URL Params, Loaders & Actions

Data Fetching

Fetching Data: The Landscape
TanStack Query (React Query)
Mutations & Cache Updates

State Management

Choosing State Management
Zustand
Redux Toolkit

Styling in React

Styling Options Overview
CSS Modules & Conditional Classes
Tailwind CSS in React

TypeScript with React

Typing Components & Props
Typing Hooks
Typing Events, Refs & Generics

Testing React

Testing with Vitest & RTL
Testing Interactions

Performance & Production

Profiling & Bottlenecks
Performance Techniques
Building & Deploying

Node.js: the Runtime, Modules and Core APIs

Introduction to Node.js

What Is Node.js?
Why Node.js?
Node vs the Browser
Installing & Running Node

The Runtime & Event Loop

V8 & Node's Architecture
Single-Threaded, Non-Blocking I/O
The Event Loop
The Event Loop in Practice

Modules & npm

CommonJS Modules
ES Modules in Node
npm & Packages
The Module Ecosystem

Globals & the process Object

Node Globals
The process Object
Environment Variables & Config
Building CLI Apps

Asynchronous Node

Async in Node: The Big Picture
Callbacks & the Error-First Pattern
Promises & async/await in Node
Async Pitfalls & Best Practices

Events & EventEmitter

Events & the EventEmitter
Custom Emitters & Error Events

The File System

Reading & Writing Files
Directories & Paths
Streaming Files

Streams & Buffers

Understanding Streams
Piping & Backpressure
Buffers & Binary Data

The HTTP Module

Creating an HTTP Server
Handling Requests & Responses
Building a Simple Router
Making HTTP Requests

Other Core Modules

path, os & url
The crypto Module
child_process & worker_threads

Express, REST APIs and Databases

Introduction to Express

Introduction to Express
Your First Express App
Express vs Raw Node

Routing

Routing Basics
Route Params & Query Strings
Modular Routes with express.Router

Middleware

What Is Middleware?
Using Middleware
Writing Custom Middleware

Request & Response

The Request Object
The Response Object

Building REST APIs

REST API Principles
Building a CRUD API
REST API Best Practices

Error Handling

Error Handling in Express
Centralized Error Handling

Validation, Static & Views

Input Validation
Static Files & Templating

Databases Overview

Databases: SQL vs NoSQL
Connecting Your App to a DB

MongoDB & Mongoose

MongoDB Basics
Connecting with Mongoose
CRUD with Mongoose
Schemas, Validation & Types
Relationships & Population

SQL with Postgres & Prisma

Relational Databases & SQL
Prisma: A Modern ORM
CRUD & Relations with Prisma

Authentication, Security, Testing and Deployment

Authentication

Authentication Concepts
Hashing Passwords with bcrypt
JWT Authentication
Sessions & Cookies

Authorization

Authorization & Roles (RBAC)
Putting Auth Together

Security

Security Essentials
Common Vulnerabilities

Config & Logging

Configuration & Environments
Logging

Testing

Testing Node & Express
Testing APIs with Supertest

Real-time

Real-time with WebSockets
Real-time with Socket.IO

File Uploads

Handling File Uploads

Performance & Scaling

Performance & Scaling
Caching with Redis

Deployment

Deploying a Node App
Docker & CI/CD Basics

Authentication & Security

Web Authentication Overview
OAuth 2.0 & OpenID Connect
OWASP Top Risks
HTTPS, TLS & Secrets
API Security

Docker, CI/CD, Caching, Queues and Architecture

Containers & Docker

What Are Containers?
Images & Containers
Writing a Dockerfile
Docker Compose
Docker Best Practices

CI/CD

What Is CI/CD?
GitHub Actions
Building a Pipeline
Deployment Strategies

Caching, Queues & Scaling

Caching Strategies
CDNs & the Edge
Message Queues
Scaling Applications
Rate Limiting & Resiliency

Real-time & API Design

WebSockets
SSE & Polling
Webhooks
API Design
API Documentation

Architecture & Observability

Monolith vs Microservices
System Design Basics
Databases at Scale
Observability: Logs, Metrics, Traces
The Twelve-Factor App
Monorepos & Tooling

Next.js and the Capstone: FiRSTRow

Next.js App Router: pages, layouts, dynamic routes
Server and client components, and when each is right
Data fetching, caching and revalidation
Server actions, forms and mutations
Route handlers, middleware and authentication
Image, font and metadata optimisation, then deployment
FiRSTRow - an event ticketing platform, built over 11 phases
Monorepo, Docker Compose, Postgres, MongoDB, Redis and Ollama
One feature built the beginner way, then refactored in five moves: controllers, services, the repository pattern, dependency injection, Zod at the boundary
SQL and MongoDB crash courses, taught when the project needs them
Seat booking, the deliberate double-booking, and fixing it with transactions and row locks
Redis holds with TTLs, and why Postgres stays the source of truth
Stripe payments, webhooks, idempotency and an append-only ledger
WebSockets: a live seat map, presence and reconnection
Signed QR tickets and single-use door check-in
A local LLM with Ollama: streaming, RAG over real policies with pgvector, semantic search, and prompt-injection defence
Integration tests with Testcontainers, rate limiting, observability and CI

124 labs

Hands-on labs

Structured labs on real equipment, with 24/7 lab-on-cloud access through Skillopia - our own lab platform.

How the Web Works & HTML

Trace a Request From Address Bar to Pixels

Build a Page With Nothing but Semantics

The Document Head: Title, Meta, Social Card

Text, Lists, Links & Media

Mark Up an Article Properly

A Product Table That Still Reads on a Phone

Responsive Images Without the Layout Jump

Forms & Accessibility

A Checkout Form That Validates Itself

Label Everything: Fix an Inaccessible Form

Keyboard-Only: Navigate Your Own Page

CSS Foundations & the Box Model

Specificity Showdown

Debug a Broken Box Model

Flexbox, Grid & Responsive Design

Rebuild a Navbar Three Ways

A Dashboard Layout in CSS Grid

One Layout, Three Breakpoints

Organise a Stylesheet Someone Else Can Read

Getting Started with JavaScript & TypeScript

Set Up Your Machine

Ten Minutes in the Console

Hello From Two Places

Variables & Data Types

Declare, Reassign, Break It

Prove It: Copy vs Share

Operators, Conversion & Coercion

The Conversion Bench

Operator Detective

Numbers & the Math Object

The Dice Roller

Money Maths Without Bugs

Dates, Times & Formatting

Build a "Member Since" Line

Localised Price Tag

Working with Strings

The Username Formatter

Receipt Line Builder

Arrays: Storing Many Values

The Playlist Manager

Seating Chart

Scope, the Scope Chain & Execution

Trace the Stack by Hand

Make a Private Counter

Control Flow & Logic

The Ticket Price Gate

Flatten the Nest

Loops & Iteration

The Sales Report

Draw a Pattern

Array Iteration Methods

The Bookshop Dashboard

Rewrite the Loops

Objects, Destructuring & JSON

Model a Bookshop Order

Round-Trip Through JSON

Functions

Build a Formatting Toolkit

Refactor to Guard Clauses

Refactor the Duplication

TypeScript: Getting Started

Your First TypeScript File

Type the Toolkit

TypeScript: Aliases, Function Types & Special Types

Type the Callbacks

TypeScript: The Core Type System

Model the Bookshop Data

Tuples & Records in Practice

TypeScript: Generics & Advanced Types

Write a Generic Store

Narrow It Down: Unions and Type Guards

Make an Illegal State Unrepresentable

The Compiler & Project Setup

Read a tsconfig Line by Line

Turn On Strict and Fix the Fallout

The DOM & Events

Build a To-Do List With No Framework

One Listener for a Hundred Buttons

Project: Shopping List

Asynchronous JavaScript

Callback Hell, Then Promises, Then async/await

Fetch With Loading, Error and Empty States

Race, All, AllSettled: Pick the Right One

Project: Flixx Movie App

Objects, Classes & Modules

Walk a Prototype Chain

Model a Library With Classes

Split a File Into Modules and Bundle It With Vite

Project: Tracalorie

Project: Drag & Drop Manager

Data Structures, Algorithms & Testing

Implement a Stack, a Queue and a Linked List

Sets and Maps for Problems Arrays Make Hard

Write the Tests First, Then the Function

React Fundamentals

Your First Component Tree

Props Down, Events Up

Render a List Without the Key Warning

Conditional Rendering Three Ways

State & Forms in React

A Counter That Explains Re-rendering

A Controlled Form With Validation

Lift State Up to Share It

Hooks in Depth

useEffect: Fetch, Clean Up, and Avoid the Infinite Loop

useRef for the Things State Should Not Hold

Replace Prop Drilling With useContext

useReducer for a Form That Grew Up

Write Your Own Custom Hook

Performance & Concurrent React

Profile a Slow List, Then Fix It

memo, useMemo, useCallback: Prove Each One Earns Its Place

Suspense, Lazy Loading and an Error Boundary

Routing, Data & React in Production

Multi-Page App With React Router

Fetch, Cache and Invalidate

Type a Component Properly

Test a Component Like a User Would

Node.js Runtime & Core Modules

Prove the Event Loop to Yourself

A Command-Line Tool That Reads Files

Stream a Large File Without Eating the Memory

An HTTP Server With No Framework

Express, Routing & Middleware

From node:http to Express

Write Your Own Middleware

A REST API With Real Status Codes

One Error Handler to Rule Them All

Databases

Model and Query a MongoDB Collection

The Same Data in Postgres, With Joins

Migrations: Version the Schema Like Code

Find the Missing Index With EXPLAIN

Authentication, Authorization & Security

100

Hash a Password Properly

101

Access and Refresh Tokens With httpOnly Cookies

102

Role-Based Route Guards

103

Attack Your Own API, Then Fix It

Testing, Config, Logging & Deployment

104

Validate Your Config at Boot and Fail Fast

105

Structured Logs With a Request ID

106

Integration-Test an API Endpoint

107

Deploy the API and Watch It Serve Traffic

Docker, CI/CD & Scale

108

Containerise the App and Compose the Stack

109

A Pipeline That Blocks a Broken Commit

110

Add a Cache and Measure the Difference

111

Put a Slow Job on a Queue

112

Rate-Limit an Endpoint and Prove It Holds

Capstone: FiRSTRow, an Event Ticketing Platform

113

Phase 0 - Monorepo, Docker Compose and a Server That Boots Honestly

114

Phase 1 - Build the Events API Badly, Then Refactor It in Five Moves

115

Phase 2 - MongoDB for Content, and the Next.js Storefront Appears

116

Phase 3 - Auth: Tokens, Cookies, Roles and the localStorage Mistake

117

Phase 4 - Venues, Seat Maps and Thousands of Seats in One Transaction

118

Phase 5 - Fire 50 Purchases at One Seat, Watch It Double-Book, Fix It

119

Phase 5b - Move Seat Holds to Redis With a TTL

120

Phase 6 - Stripe Payments, Webhooks, Idempotency and a Ledger

121

Phase 7 - WebSockets: a Live Seat Map Across Two Browser Windows

122

Phase 8 - Signed QR Tickets and Single-Use Door Check-In

123

Phase 9 - A Local LLM: Streaming, RAG Over Real Policies, Semantic Search

124

Phase 10 - Testcontainers, Observability, CI and Deployment

Reserve your seat

Watch a real class. Meet your instructor. Then decide.

Hold a place on the next batch and sit in on the opening session. See the teaching, the racks and the labs exactly as students do, then enrol if it's right for you.

Reserve my seat Chat on WhatsApp

1 million+

engineers trained

1997

training since

24/7

Skillopia lab access

Keep exploring

View the full Software Development track

Fee

₹30,000

Reserve a seat