Shodhana Limited · Course outline

React 19 & Next.js 15 Full-Stack Development

Explore JavaScript, TypeScript, React and Next.js through a detailed syllabus covering application architecture, data, testing and deployment.

15 modules · 326 listed topics

About this course

Explore JavaScript, TypeScript, React and Next.js through a detailed syllabus covering application architecture, data, testing and deployment.

Subject areas

JavaScript and TypeScript foundations, React components and state.
Next.js application structure and server-side development.
Data handling, testing, deployment and a final project outline.

Before booking

Read the syllabus below and contact Shodhana to confirm availability, delivery format, instructor, learning materials, access period, assessment requirements and support. The listed duration is an estimate. This page is a course outline and does not provide an instant-access purchase.

Course syllabus

15 modules · 326 listed topics.

Expand a module to read its listed topics. This is the syllabus outline; lesson delivery and access arrangements are confirmed before booking.

Module 1: Modern JavaScript & TypeScript Foundations25 listed topics

Chapter 1: ESNext Specification Roadmap & Modern JS Engine Internals
Chapter 2: Variable Declarations, Hoisting & Temporal Dead Zone (TDZ)
Chapter 3: Lexical Scoping, Closures & Execution Context
Chapter 4: Advanced Destructuring: Nested Objects, Default Aliasing & Array Slices
Chapter 5: Spread & Rest Operators: Shallow Copies vs Deep Cloning Pitfalls
Chapter 6: Modern String Manipulation & Tagged Template Literals
Chapter 7: Symbols, Well-Known Symbols & Metaprogramming in JS
Chapter 8: Iterators, Iterables & Custom Generator Functions
Chapter 9: WeakMap, WeakSet & Memory Management Optimization
Chapter 10: Array Functional Paradigms: map, filter, reduce & reduceRight
Chapter 11: High-Performance Array Methods: flat, flatMap, findLast, toSorted
Chapter 12: The JavaScript Event Loop: Microtasks, Macrotasks & Call Stack
Chapter 13: Promises Architecture, Thenables & Unhandled Rejection Guards
Chapter 14: Async/Await Deep Dive, Top-Level Await & Error Handling
Chapter 15: Concurrent Promises: Promise.all, allSettled, race & any
Chapter 16: Fetch API, AbortController & Request Cancellation Strategies
Chapter 17: JavaScript Modules (ESM) vs CommonJS (CJS) Interoperability
Chapter 18: TypeScript Foundations: Type Inference, Primitives & Any vs Unknown
Chapter 19: Interfaces vs Type Aliases: Declaration Merging & Extensibility
Chapter 20: Union, Intersection, Discriminated Unions & Pattern Matching
Chapter 21: Generics in Depth: Type Constraints & Generic Utility Functions
Chapter 22: TypeScript Built-in Utility Types: Partial, Pick, Omit, Record, Awaited
Chapter 23: Advanced Conditional Types, Template Literal Types & Key Remapping
Chapter 24: TypeScript Strict Mode Compiler Options for Production
Chapter 25: TypeScript Ambient Declarations & Declaring Global Types (.d.ts)

Module 2: React 19 Core Philosophy, Virtual DOM & JSX20 listed topics

Chapter 26: React Philosophy: Declarative UI vs Imperative DOM Manipulation
Chapter 27: Understanding JSX and What Modern Compilers (SWC/Babel) Output
Chapter 28: React Component Lifecycle & Pure Functional Architecture
Chapter 29: Virtual DOM & Reconciliation: The Diffing Algorithm Unpacked
Chapter 30: React Fiber Architecture: Fiber Nodes, Work In Progress & Commit Phase
Chapter 31: Props Passing, Readonly Immutability & Children Composition Pattern
Chapter 32: Conditional Rendering: Guard Clauses, Ternaries & Fragment Wrapping
Chapter 33: Rendering Lists & The Mechanics of Stable, Unique Keys
Chapter 34: React Synthetic Event System: Event Delegation & Native Event Interop
Chapter 35: Handling User Inputs: Controlled vs Uncontrolled Components
Chapter 36: React 19 Form Actions & Native Form Handling
Chapter 37: React.Fragment vs Shorthand Syntax & Layout Preservation
Chapter 38: StrictMode Checks: Double Invocations & Side Effect Verification
Chapter 39: Component Composition vs Inheritance in Enterprise Codebases
Chapter 40: Building Flexible Layout Components with Slots Pattern
Chapter 41: Error Boundaries: Catching UI Exceptions & Fallback Rendering
Chapter 42: Higher-Order Components (HOC) Pattern & Modern Alternatives
Chapter 43: Render Props Pattern: When to Use vs Modern Hooks
Chapter 44: Portals in React: Rendering Modals and Tooltips Outside the Root DOM
Chapter 45: Memory Profiling & Garbage Collection in React Web Applications

Module 3: React Hooks Deep Dive30 listed topics

Chapter 46: Rules of Hooks & Internal Linked-List State Storage in Fiber
Chapter 47: useState: Primitive, Complex Object State & Functional Updaters
Chapter 48: Automatic Batching in React 18/19 Across Async Callbacks
Chapter 49: useEffect: Synchronization Mental Model vs Lifecycle Methods
Chapter 50: Dependency Array Rules, ESLint Exhaustive Deps & Stale Closures
Chapter 51: useEffect Cleanups: Canceling Network Subscriptions & Event Listeners
Chapter 52: Common useEffect Anti-Patterns: Derived State & Sync Chains
Chapter 53: useRef: Accessing Real DOM Elements & Persisting Mutable References
Chapter 54: useRef vs useState: When to Avoid Unnecessary Component Rerenders
Chapter 55: useMemo: Expensive Computation Caching & Granular Dependencies
Chapter 56: useMemo Overuse: Measuring Overhead vs Actual Performance Gains
Chapter 57: useCallback: Stable Function Signatures for Child Prop Equality
Chapter 58: useContext: Context Propagation & Eliminating Prop Drilling
Chapter 59: Context Splitting Pattern: Separating Dispatch from State Values
Chapter 60: useReducer: Managing Complex State Machines & Transition Logic
Chapter 61: useReducer vs Redux: When Built-in State Architecture Suffices
Chapter 62: useId: Generating Collision-Free Accessible IDs Across SSR/CSR
Chapter 63: useLayoutEffect: Synchronous DOM Measurements Before Screen Paint
Chapter 64: useImperativeHandle: Customizing Parent Ref Handles Safely
Chapter 65: useDebugValue: Enhancing Custom Hook Inspection in React DevTools
Chapter 66: React 19 use() Hook: Reading Promises Directly in Render
Chapter 67: React 19 use() Hook: Conditional Context Reading Support
Chapter 68: React 19 useActionState: Handling Pending Transitions & Form Errors
Chapter 69: React 19 useOptimistic: Immediate Client-Side State Feedback
Chapter 70: Custom Hook: useLocalStorage with Cross-Tab Broadcast Synchronization
Chapter 71: Custom Hook: useDebounce and useThrottle for High-Frequency Events
Chapter 72: Custom Hook: useFetch with Stale Cache & Request Invalidation
Chapter 73: Custom Hook: useIntersectionObserver for Dynamic Lazy Content
Chapter 74: Custom Hook: useMediaQuery for Fluid Responsive JavaScript
Chapter 75: Custom Hook: useClickOutside & useEventListener for Modal UI

Module 4: React Performance Optimization & Concurrent Mode20 listed topics

Chapter 76: Profiling React Apps with Chrome Performance Tab & React DevTools
Chapter 77: Identifying Rendering Bottlenecks & Wasted Rerenders
Chapter 78: React.memo: Shallow Prop Comparison & Custom Equal Functions
Chapter 79: Code Splitting with React.lazy and Suspense Boundaries
Chapter 80: Nested Suspense Boundaries & Graceful Progressive Loading
Chapter 81: Concurrent Rendering: Interruptible Rendering Principles
Chapter 82: useTransition: Marking Non-Urgent UI Work & isPending States
Chapter 83: useDeferredValue: Deferring Heavy Value Computations Smoothly
Chapter 84: Virtualizing Infinite Data Lists with TanStack Virtual
Chapter 85: Windowing Large Datagrids: Measuring Dynamic Element Heights
Chapter 86: Optimizing Heavy SVG & Canvas Rendering in React
Chapter 87: Passive Event Listeners & Scroll Performance Optimization
Chapter 88: Debouncing User Inputs vs Concurrent Transitions
Chapter 89: Memory Leak Detection: Detached DOM Nodes & Event Listener Leaks
Chapter 90: Tree Shaking Verification & Minimizing Third-Party Bundle Weight
Chapter 91: Dynamic Imports with Webpack / Vite Chunk Splitting
Chapter 92: Analyzing Bundle Visualizer Treemaps & Identifying Bloat
Chapter 93: Font Optimization & Zero Cumulative Layout Shift (CLS) in React
Chapter 94: Web Vitals in React: Tracking LCP, INP & CLS Real-Time
Chapter 95: Building High-Frame-Rate UI (60fps) Animations in React

Module 5: Modern UI Systems, Styling & Tailwind CSS20 listed topics

Chapter 96: Modern CSS Strategies: Utility-First vs CSS Modules vs CSS-in-JS
Chapter 97: Why Modern Frontend Is Moving Away from Runtime CSS-in-JS
Chapter 98: Tailwind CSS v4 Engine: Zero-Config & Lightning CSS Integration
Chapter 99: Tailwind Class Composition & Responsive Design Breakpoints
Chapter 100: Container Queries in Tailwind CSS for Component-Level Responsiveness
Chapter 101: Building a Scalable Tokenized Design System with CSS Variables
Chapter 102: Light & Dark Mode Architecture: Class Strategy & OS Preference Sync
Chapter 103: Headless UI Principles: Separating Behavior from Presentation
Chapter 104: Radix UI Primitives: Building Bulletproof Accessible Menus & Modals
Chapter 105: Shadcn UI Architecture: Code Ownership vs Black-Box NPM Packages
Chapter 106: Customizing Shadcn UI with Tailwind Variants (cva) and clsx
Chapter 107: Building an Accessible Accessible Data Table with TanStack Table
Chapter 108: Framer Motion Core: Motion Components, Initial, Animate & Exit
Chapter 109: Framer Motion Springs, Easing & Choreographing Staggered Children
Chapter 110: Shared Layout Transitions with AnimatePresence and layoutId
Chapter 111: Scroll-Linked Animations & Interactive Parallax with Framer Motion
Chapter 112: Micro-Interactions: Button Renders, Ripple Feedback & Loading Spinners
Chapter 113: Form Styling & Accessible Validation States (Error, Focus-Visible)
Chapter 114: Building Toast Notification Systems with Sonner
Chapter 115: Designing Keyboard-Navigable Focus Traps for Complex Dialogs

Module 6: Advanced Client & Server State Management20 listed topics

Chapter 116: Client State vs Server Cache: Establishing Mental Models
Chapter 117: Why Traditional Redux Boilerplate Is Often Replaced in Modern Apps
Chapter 118: Zustand Fundamentals: Tiny, Fast & Scalable State Management
Chapter 119: Zustand Store Slices Pattern for Large-Scale Enterprise Apps
Chapter 120: Zustand Middleware: Persisting to LocalStorage & Redux DevTools
Chapter 121: TanStack Query (React Query) Architecture & Core Concepts
Chapter 122: Query Keys Strategy: Organizing Cache Keys Hierarchically
Chapter 123: Fetching & Transforming Remote Data with useQuery
Chapter 124: Data Mutations with useMutation & Imperative Query Invalidation
Chapter 125: Optimistic UI Updates with TanStack Query: Rollback on Error
Chapter 126: Pagination Patterns: Keep Previous Data & Infinite Query Scrolling
Chapter 127: Prefetching Strategies on Route Hover & Route Transitions
Chapter 128: Handling Stale Data: staleTime, gcTime & Background Refetching
Chapter 129: Offline Mutation Queuing & Network Reconnection Sync
Chapter 130: Synchronizing Remote URL State: nuqs for Query Param State
Chapter 131: Form State Management: React Hook Form Architecture
Chapter 132: Zod Schema Validation: Safe Parsing & Type-Safe Form Inputs
Chapter 133: Async Form Validation & Debounced Username Availability Checks
Chapter 134: Complex Nested Form Arrays with useFieldArray in React Hook Form
Chapter 135: Global Error Management: Sentry Integration & Fallback Components

Module 7: Next.js 15 Foundations & App Router Architecture25 listed topics

Chapter 136: The Paradigm Shift: From React Single Page Apps to Hybrid Full-Stack
Chapter 137: Next.js 15 Under the Hood: Turbopack, SWC & Modern Bundling
Chapter 138: Pages Router vs App Router: Key Architectural Differences
Chapter 139: File-System Routing: page.tsx, layout.tsx, and template.tsx
Chapter 140: Nested Layouts: State Preservation Across Route Transitions
Chapter 141: Loading UI: loading.tsx & Instant Suspense Skeleton Fallbacks
Chapter 142: Error Handling: error.tsx, 'use client' Boundary & Reset Triggers
Chapter 143: Global Errors: Handling Root Layout Failures with global-error.tsx
Chapter 144: 404 Not Found Handling: not-found.tsx and programmatic notFound()
Chapter 145: Dynamic Route Segments: [id], [slug], and Optional Parameters
Chapter 146: Catch-All Routes: [...slug] and Optional Catch-All [[...slug]]
Chapter 147: Route Groups: (marketing), (dashboard) for Clean Domain Separation
Chapter 148: Parallel Routes: Named Slots (@analytics, @feed) for Dashboards
Chapter 149: Conditional Parallel Routes Based on User Role or Authentication
Chapter 150: Intercepting Routes: (.)modal, (..)feed for Photo Modals & Overlays
Chapter 151: Combining Parallel & Intercepting Routes for Contextual Overlays
Chapter 152: Route Handlers (route.ts): Replacing API Routes with Web Standard Request/Response
Chapter 153: Handling HTTP Verbs: GET, POST, PUT, DELETE, PATCH in App Router
Chapter 154: Streaming Response Bodies with TransformStream in Route Handlers
Chapter 155: Next.js Middleware: Edge Request Interception & Path Rewriting
Chapter 156: Geolocation & Device Detection via Next.js Edge Middleware
Chapter 157: Configuring Redirects, Rewrites & Custom Security Headers in next.config.ts
Chapter 158: Next.js Environment Variables: Public vs Secret Runtime Environment Rules
Chapter 159: Draft Mode for Headless CMS Previews in App Router
Chapter 160: Static Export Configuration (output: 'export') When SSR Is Not Needed

Module 8: React Server Components (RSC) & Server Actions25 listed topics

Chapter 161: React Server Components Philosophy: Zero Client Bundle Cost
Chapter 162: The 'use client' Directive: Defining the Boundary, Not Client-Only
Chapter 163: When to Choose Server Components vs Client Components Decision Tree
Chapter 164: Composing RSC and Client Components: Interleaving Composition Patterns
Chapter 165: Passing Server Data to Client Components: Serialization Rules & Limitations
Chapter 166: Streaming Server Components with React Suspense & Chunked HTTP Transfer
Chapter 167: Server Actions Explained: The 'use server' Directive for Remote Procedures
Chapter 168: Progressive Enhancement: Form Submissions Working Without JavaScript
Chapter 169: Validating Server Action Payloads with Zod Schemas
Chapter 170: Returning Typed Server Action Responses: Errors, Success Payloads
Chapter 171: Revalidating Server Data: revalidatePath vs revalidateTag Architecture
Chapter 172: Handling Cookies & Request Headers Inside Server Actions
Chapter 173: Optimistic UI Updates Combining useOptimistic and Server Actions
Chapter 174: Server Action Rate Limiting & CSRF Security Defenses
Chapter 175: Calling Server Actions from Custom Hooks and Event Handlers
Chapter 176: Preventing Waterfall Data Fetching in Nested Server Components
Chapter 177: Server-Only Code Protection: import 'server-only' Guard Package
Chapter 178: Client-Only Code Protection: import 'client-only' Guard Package
Chapter 179: Understanding React Taint API: taintObjectReference & taintUniqueValue
Chapter 180: Handling Server Component Rendering Errors Gracefully
Chapter 181: Streaming AI Responses in Server Actions to Client UIs
Chapter 182: Server Component State Persistence Patterns Across Revalidations
Chapter 183: Server Actions in Forms: Pending State Indication with useFormStatus
Chapter 184: Server Action File Structure & Domain Separation Best Practices
Chapter 185: Building a Production CRUD Feature Entirely with RSC & Server Actions

Module 9: Data Fetching, Caching & Rendering Strategies25 listed topics

Chapter 186: Rendering Paradigms: SSR, SSG, ISR and Dynamic Server Rendering
Chapter 187: Static Rendering: Generating Pre-built HTML at Next.js Build Time
Chapter 188: Dynamic Rendering: On-Demand Execution for Per-User Dynamic Data
Chapter 189: Incremental Static Regeneration (ISR): On-Demand & Time-Based Revalidation
Chapter 190: The Next.js 15 Caching Architecture: Request Memoization
Chapter 191: The Data Cache: Persisting Fetch Requests Across Server Requests
Chapter 192: The Full Route Cache: Storing Pre-rendered HTML & RSC Payloads
Chapter 193: The Router Cache: In-Memory Client-Side Cache on Route Transitions
Chapter 194: Next.js 15 Cache Updates: Uncached by Default Fetch Semantics
Chapter 195: Opting Out of Caching: noStore(), cache: 'no-store', and dynamic export
Chapter 196: Tag-Based Revalidation: Organizing Cache Invalidation Tags
Chapter 197: unstable_cache API: Caching Database Queries & Heavy Calculations
Chapter 198: generateStaticParams: Pre-generating Dynamic Routes at Build Time
Chapter 199: Partial Prerendering (PPR): Blending Static Shells with Dynamic Streams
Chapter 200: PPR Architecture: How It Works Under the Hood in Next.js 15
Chapter 201: SEO Optimization: Metadata API (Title, Description, Robots, Canonical)
Chapter 202: Dynamic Metadata Generation via generateMetadata() for Blog & Products
Chapter 203: OpenGraph & Twitter Card Generation for Maximum Social Sharing Engagement
Chapter 204: Dynamic Image Generation: @vercel/og and ImageResponse API
Chapter 205: Generating sitemap.xml and robots.txt Programmatically
Chapter 206: Structured JSON-LD Schema Markup in Next.js for Rich Google Snippets
Chapter 207: Handling 301/308 Canonical Redirects for Clean SEO URL Structures
Chapter 208: Pagination & Infinite Scroll SEO Strategies in App Router
Chapter 209: Multi-language (i18n) URL Routing & Hreflang Tag Implementations
Chapter 210: Monitoring Core Web Vitals on Real Production Traffic

Module 10: Next.js Built-in Optimizations & Assets20 listed topics

Chapter 211: next/image Architecture: Automatic WebP/AVIF Modern Formats Conversion
Chapter 212: Image Sizing Strategies: fill, sizes, priority & Preventing Layout Shifts
Chapter 213: Remote Image Loading: Configuring remotePatterns in next.config.ts
Chapter 214: next/font Deep Dive: Self-Hosting Google Fonts with Zero Layout Shift
Chapter 215: Using Local Custom Fonts (.woff2) with next/font/local
Chapter 216: Variable Fonts Configuration & Dynamic CSS Variable Integration
Chapter 217: next/script: Loading Third-Party Analytics Safely (GA4, PostHog, Hotjar)
Chapter 218: Script Loading Strategies: beforeInteractive, afterInteractive, lazyOnload
Chapter 219: next/link Optimization: Automatic Background Viewport Prefetching
Chapter 220: View Transitions API in Next.js: Smooth App-Like Page Transitions
Chapter 221: Bundle Analyzer Configuration: Diagnosing Heavy Node Modules
Chapter 222: Serverless Bundle Size Optimization for AWS Lambda / Vercel Edge
Chapter 223: Managing Static Assets: Public Directory Best Practices & Caching Headers
Chapter 224: Next.js Turbopack Flags & Optimizing Local Dev Server Startup Speed
Chapter 225: Modularize Imports & Compiler Optimization for Heavy Icon Libraries
Chapter 226: Managing Audio & Video Assets in Next.js Applications
Chapter 227: Content Security Policy (CSP) Headers with Nonce Support in Next.js
Chapter 228: Compression: Brotli and Gzip Configurations in Edge Infrastructure
Chapter 229: Analyzing Network Waterfalls with Next.js DevTools & Chrome DevTools
Chapter 230: Production Readiness Checklist for Next.js Deployments

Module 11: Enterprise Authentication & Authorization20 listed topics

Chapter 231: Modern Web Authentication Paradigms: Cookies vs Bearer Tokens
Chapter 232: NextAuth.js v5 (Auth.js) Architecture for Next.js 15 App Router
Chapter 233: Configuring OAuth Providers (GitHub, Google, Apple Login)
Chapter 234: Credentials Provider: Secure Password Hashing with Argon2id
Chapter 235: Session Strategy: JWT-based Tokens vs Persistent Database Sessions
Chapter 236: Protecting Routes with Edge Middleware & Session Validation
Chapter 237: Securing Route Handlers and Server Actions with Identity Guards
Chapter 238: Role-Based Access Control (RBAC): SuperAdmin, Manager, Member, Viewer
Chapter 239: Multi-Tenant Architecture: Organization Scoping & Tenant Isolation
Chapter 240: CSRF Protection in Next.js Forms and Server Actions
Chapter 241: Handling Expired Tokens & Automatic Silent Token Refresh Flows
Chapter 242: Two-Factor Authentication (2FA / TOTP) Implementation
Chapter 243: Alternative Modern Auth: Supabase Auth Deep Integration in App Router
Chapter 244: Alternative Modern Auth: Clerk Integration with User Profile Components
Chapter 245: Magic Links & Passwordless Email Login Workflows with Resend
Chapter 246: Rate Limiting Login Endpoints to Prevent Brute-Force Attacks
Chapter 247: Session Revocation & Single Device Logout Mechanisms
Chapter 248: Auditing Security Logs: Tracking Failed Logins & Suspicious IP Blocks
Chapter 249: Cookie Security Attributes: HttpOnly, Secure, SameSite=Strict / Lax
Chapter 250: End-to-End Authentication Testing with Playwright & Mock Sessions

Module 12: Database Integration, ORMs & Persistence20 listed topics

Chapter 251: Connecting Databases in Next.js Serverless & Edge Environments
Chapter 252: Connection Pooling Challenges: Solving Exhaustion with PgBouncer / Neon
Chapter 253: Prisma ORM Setup: Schema Definition, Models, Relations & Enums
Chapter 254: Prisma Client Generation & Singleton Instantiation in Development
Chapter 255: Prisma Migrations Workflow in Production CI/CD Environments
Chapter 256: CRUD Operations with Prisma in React Server Components
Chapter 257: Drizzle ORM: Lightweight SQL-First Alternative with Zero Overhead
Chapter 258: Drizzle Schema Declaration, Relations & Type Safety
Chapter 259: PostgreSQL on Supabase: Row Level Security (RLS) & Direct SQL Queries
Chapter 260: Transactions in PostgreSQL: Ensuring Atomicity in E-Commerce Checkout
Chapter 261: Database Indexing Strategies: B-Tree, GIN, Partial & Composite Indexes
Chapter 262: Optimizing Heavy N+1 Queries with Data Loaders and Joins
Chapter 263: Database Seeding Scripts for Reproducible Development Environments
Chapter 264: Full-Text Search with PostgreSQL tsvector and pg_trgm
Chapter 265: Vector Databases & pgvector for AI Embeddings in Next.js
Chapter 266: Soft Deletes vs Hard Deletes in Enterprise Database Design
Chapter 267: Auditing Database Changes with Trigger Functions and Timestamps
Chapter 268: Connecting Redis (Upstash) for Edge Key-Value Caching
Chapter 269: Database Disaster Recovery, Automated Backups & Point-in-Time Restore
Chapter 270: Writing Integration Tests for Database Queries with Testcontainers

Module 13: Interactive In-Browser Code Playground Architecture20 listed topics

Chapter 271: Architecture of Modern Code Playgrounds (CodeSandbox, StackBlitz, Replit)
Chapter 272: Why Interactive In-Browser Code Playgrounds Accelerate Learning
Chapter 273: Browser Sandbox Security: iframe Isolation & sandbox Attributes
Chapter 274: PostMessage Protocol: Secure Communication Between Parent and Playground
Chapter 275: Integrating Monaco Editor (VS Code Engine) in React Components
Chapter 276: Monaco Editor Configuration: IntelliSense, TypeScript Types & Themes
Chapter 277: Lightweight Alternative: CodeMirror 6 Architecture & Extensions
Chapter 278: Syntax Highlighting with Shiki and WebAssembly TextMate Grammars
Chapter 279: In-Browser Transpilation with @babel/standalone for JSX & TypeScript
Chapter 280: Executing Untrusted User Code Safely inside Dedicated Web Workers
Chapter 281: Virtual File System: Managing Multi-File Sandboxes in Browser Memory
Chapter 282: Intercepting console.log, console.error & Rendering Interactive Console
Chapter 283: Live React Component Preview: Real-Time Component Mounting and Unmounting
Chapter 284: Error Boundary Wrapping in Playground: Catching Runtime Exceptions Elegantly
Chapter 285: Live CSS Preview: Injecting Scoped Styles Without Leaking to Parent App
Chapter 286: Interactive Quizzes: Validating Student Code Output Against Automated Test Cases
Chapter 287: Stateful Playground: Persisting Student Code Snippets to LocalStorage
Chapter 288: Cloud Sync: Saving Student Playground Projects to PostgreSQL Database
Chapter 289: Exporting Playground Code Directly to GitHub Repo or CodeSandbox
Chapter 290: Building a Complete Reusable <CodePlayground /> React Component

Module 14: Automated Testing & Continuous Integration20 listed topics

Chapter 291: The Modern Testing Philosophy in React: Testing Behavior, Not Implementation
Chapter 292: Unit Testing Pure Functions & React Hooks with Vitest
Chapter 293: Setting Up React Testing Library (RTL) & Jest-DOM Matchers
Chapter 294: Query Priority in RTL: getByRole vs getByText vs testId
Chapter 295: Simulating Real User Interactions with @testing-library/user-event
Chapter 296: Mocking Network Requests with Mock Service Worker (MSW)
Chapter 297: Testing Server Components & Streaming Suspense Boundaries
Chapter 298: Mocking Server Actions and Testing Form Validation States
Chapter 299: End-to-End (E2E) Testing Architecture with Playwright
Chapter 300: Configuring Playwright for Chromium, Firefox & WebKit Engines
Chapter 301: Writing Robust E2E Tests: Locators, Assertions & Auto-Waiting
Chapter 302: Testing Authentication Flows & Persisting Storage State Across Tests
Chapter 303: Visual Regression Testing with Playwright Screenshots
Chapter 304: Automating Accessibility (a11y) Audits with axe-core in CI
Chapter 305: GitHub Actions CI/CD Pipeline: Linting, Type Checking & Running Tests
Chapter 306: Running Parallel Playwright Tests in Headless Docker Containers
Chapter 307: Code Coverage Reports & Setting Minimum Coverage Thresholds
Chapter 308: Testing Error Boundaries and Offline Recovery Scenarios
Chapter 309: Performance Regression Testing with Lighthouse CI in Pipeline
Chapter 310: Smoke Testing Production Preview Deployments Before Merging

Module 15: Security, Production Deployment & DevOps16 listed topics

Chapter 311: OWASP Top 10 Security Defenses for Modern Full-Stack Web Apps
Chapter 312: Preventing Cross-Site Scripting (XSS) in Dynamic React Renderings
Chapter 313: Preventing Cross-Site Request Forgery (CSRF) & Clickjacking Defenses
Chapter 314: Sanitizing Untrusted HTML & Rich Text with DOMPurify
Chapter 315: Rate Limiting API Endpoints with Upstash Redis and Sliding Window Algorithm
Chapter 316: Deploying Next.js to Vercel: Preview Environments, Domains & Edge Network
Chapter 317: Self-Hosting Next.js with Multi-Stage Dockerfile and Node.js Alpine
Chapter 318: Configuring Nginx Reverse Proxy with HTTP/2, Gzip & SSL Certificates
Chapter 319: Environment Variables Management & Secret Rotation in Cloud Providers
Chapter 320: Production Observability: Real-Time Error Tracking with Sentry
Chapter 321: Structured Logging with Pino & Log Draining to Datadog / BetterStack
Chapter 322: Application Performance Monitoring (APM): Tracing Slow Database Queries
Chapter 323: Automated Database Migrations in Continuous Deployment Workflows
Chapter 324: Zero-Downtime Deployment Strategies: Blue/Green & Rolling Updates
Chapter 325: Final Capstone Project Architecture: Production Next.js 15 SaaS Application
Chapter 326: Final Assessment & Course Completion Assessment

Course completion certificate

A Shodhana completion certificate may be issued when the agreed completion and assessment requirements are met. It includes a certificate number and issued date. It is a course completion record, not a claim of external accreditation or professional licensing.

Certificate records and verification are private. Contact us for certificate assistance.