Tanvi Chitnis
โ Enrolled๐ Mumbai, India โข UI Designer โ React 19, Hooks & Next.js
๐ Weekend SatโSun (6โ8 PM IST)
Launch full-screen from your iPhone / iPad Home Screen
Zero missing prerequisites: learn HTML5, CSS3 Flexbox/Grid, Tailwind CSS, JavaScript ES6+, and TypeScript 5 right inside the course before mastering React, Hooks, Router, RHF + Zod, Redux Toolkit, TanStack Query, Next.js fundamentals, Vitest, and live Vercel deployment.
Net: $36 + 18% GST ($7 ) โข ~$1 /Hr
โก $21 Lock + 1 ร $21
$21 Seat Lock + 1 Milestone Installments of $21 (0% Interest โ All-Inclusive)
๐ 30-Day 100% Tuition Credit Upgrade Bridge ($43 Credit)
Deduct 100% of your $43 fee when upgrading to Frontend Developer โ Industry-Ready Career Program (FDCP) within 30 days of batch start. FDCP โ
Every month concludes with measurable coding competency, a portfolio repository deliverable, and continuous DSA progression.
Complete web, Tailwind CSS, modern JS ES6+ async/DOM, and strict TypeScript 5 foundations tailored for React.
Outcome: Enter React with rock-solid layout, ES6+, and TypeScript fluency.
Deliverable: Responsive Tailwind Landing Page + Typed ES6/TS SDK.
DSA Focus: JS Arrays, Strings, Closures, Debounce & Promises.
Vite + React, JSX, Props/State, Hooks, React Hook Form + Zod, React Router, Protected Routes, and Axios.
Outcome: Build multi-page authenticated TypeScript + React dashboards.
Deliverable: React + TypeScript Employee Management Dashboard.
DSA Focus: Sortable Data Tables, Pagination & OTP/Tag Machine Coding.
Redux Toolkit, TanStack Query, Compound Components, Virtualization, Security, Core Web Vitals, Vitest/RTL, Next.js App Router basics, and Vercel deployment.
Outcome: Architect, test, and deploy a production React E-Commerce application.
Deliverable: Capstone: Deployed Production React + TypeScript + Redux E-Commerce Storefront.
DSA Focus: Autocomplete, Accessible Modal, Infinite Scroll & Virtualized List Machine Coding.
Practised continuously from Month 1 to Month 6 (Easy โ Medium โ Selected Hard) with constraints, sample I/O, Big-O analysis, and JavaScript ES6+ & React/TypeScript reference solutions and test cases inside the Student Coding Lab.
Arrays
4 Problems โข M1
Strings
4 Problems โข M1
Objects, Map & Set
4 Problems โข M1
JS Polyfills & Deep Utils
4 Problems โข M1
Closures & Functions
3 Problems โข M2
Promises & Async
2 Problems โข M2
Two Pointers
3 Problems โข M2
Sliding Window
1 Problems โข M2
React Machine Coding
15 Problems โข M2
Published transparently so students compare scope honestly before enrolling:
โ Correct Answer: A
Placing `<script type="module" src="...">` (deferred by default) so JavaScript never blocks first contentful paint.
Practice L1/L2 engineering questions across all 231 REAC topics. Our AI Interviewer speaks questions aloud and scores your spoken answer across Technical Depth, Clarity, Edge Cases & Confidence.
Every module and topic lists its exact technical subtopics, hands-on code labs, Mock Tests, MockAttempt AI interviews, and explicit What Topic Is Next โ progression so enrolled students and trainers always stay synchronized from Day 1 to Expert mastery.
Builds rock-solid fluency from Day-1 syntax and memory mechanics to testing, packaging, optimization, and live production delivery across 111 hours (~โน36/hr, ~โน25/topic).
Month 1 โ Stage 1: Built-In HTML5, CSS3/Tailwind, JavaScript ES6+ & TypeScript 5 Foundations (Weeks 1โ3)
Month 2 โ Stage 2: Core React, Hooks, Validated Forms, Routing & REST APIs (Weeks 4โ6)
Month 3 โ Stage 3: Redux Toolkit, TanStack Query, Next.js Basics, Testing & E-Commerce Capstone (Weeks 7โ10)
Module Learning & Hands-On Objectives
HTML parser -> DOM tree, CSS parser -> CSSOM tree, Render Tree construction, Layout (Reflow), Paint, and Composite layers, `<script defer>` vs `async`
`<!DOCTYPE html>` standards mode vs quirks mode, evolution to living HTML5 standard, W3C markup validation
`<html lang="en">`, `<meta charset="UTF-8">`, `<meta name="viewport" content="width=device-width, initial-scale=1.0">`, `<title>`, favicons, OpenGraph tags
Block-level flow (`p`, `section`, `ul`) vs phrasing inline (`span`, `a`, `strong`) vs self-closing void elements (`img`, `input`, `br`, `hr`, `meta`, `link`), conten...
Heading hierarchy `<h1>`โ`<h6>` (one logical `<h1>` per view), `<p>`, `<strong>` vs `<b>`, `<em>` vs `<i>`, `<mark>`, `<code>`, `<pre>`, `<blockquote>`, `<time datet...
`<a href>`, relative vs absolute URLs, in-page fragment skip links (`#main-content`), `mailto:` / `tel:`, `target="_blank"` with `rel="noopener noreferrer"`, descrip...
`<img src alt width height>`, meaningful `alt` vs decorative `alt=""`, preventing CLS layout shift with explicit `width`/`height`, `loading="lazy"`, `decoding="async...
`<ul>` (unordered navigation/features), `<ol>` (`start`, `reversed` step sequences), `<dl>` / `<dt>` / `<dd>` key-value specification pairs, nested lists
`<table>`, `<caption>`, `<thead>`, `<tbody>`, `<tfoot>`, `<th scope="col|row">`, `colspan`/`rowspan`, why tables are strictly for tabular data (never page layout!)
`display: flex` vs `inline-flex`, main axis vs cross axis mental model, `gap` property (replaces messy margin hacks!)
`flex-direction: row | column | row-reverse | column-reverse`, how switching to `column` swaps main and cross axes! Accessibility tab-order warning on `*-reverse`
Main-axis `justify-content` (`flex-start`, `center`, `space-between`), cross-axis `align-items` (`stretch`, `center`, `baseline`), per-item `align-self`, auto margin...
`flex-wrap: nowrap | wrap`, multi-line row/column `gap`, `align-content` for multi-line flex tracks
`flex: 1` (`1 1 0%`), `flex: 0 0 auto` (`shrink-0` icons!), and the critical `min-width: 0` fix when truncated text inside a flex item refuses to shrink!
2D layout control (rows AND columns simultaneously) vs 1D Flexbox, `display: grid`, explicit vs implicit grid tracks
Fractional free-space `1fr` unit, `minmax(0, 1fr)` (prevents wide code/pre blocks from blowing out `1fr` tracks!), `row-gap` / `column-gap` / `gap`
Mixed fixed + flexible tracks, `grid-auto-rows: minmax(8rem, auto)`, CSS `subgrid` awareness for aligning inner card headings/prices across sibling cards
Why co-located atomic utility classes eliminate dead CSS growth (`O(1)` production CSS size!) and naming bikeshedding in component frameworks
Installing Tailwind CSS + Vite plugin (`@tailwindcss/vite` / PostCSS), `@import "tailwindcss";` / `@theme` tokens, automatic unused-class tree-shaking in production...
4px base spacing scale (`p-4` = `1rem`), `space-y-*`, typographic scale (`text-sm`, `font-semibold`, `tracking-tight`, `leading-relaxed`), semantic slate/sky/emerald...
`flex items-center justify-between gap-4`, `shrink-0`, `min-w-0 flex-1`, `grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-6`, `col-span-full`
Mobile-first `sm:` (`640px`), `md:` (`768px`), `lg:` (`1024px`), `xl:` (`1280px`), `2xl:` (`1536px`), container queries `@container` / `@md:`
`hover:`, `focus-visible:outline-2 focus-visible:outline-sky-600`, `active:scale-98`, `disabled:opacity-50 disabled:cursor-not-allowed`, parent `group` / `group-hove...
Class/selector strategy (`[data-theme="dark"]` / `.dark`), `dark:bg-slate-950 dark:text-slate-100 dark:border-slate-800`, preventing white flash (FOUC) via inline `<...
Designing consistent Button variants (`primary`, `secondary`, `ghost`, `danger`), Input groups, Cards, Badges, and Section Shells; avoiding premature `@apply` bloat...
Design and build a fast, semantic, W3C-valid, mobile-first multi-page digital agency / SaaS business website from scratch using HTML5, CSS3 (Flexbox & Grid), Sass/SCSS variables, Bootstrap 5 / Tailwind CSS utilities, accessible forms, and responsive typography.
Module Learning & Hands-On Objectives
Index `for`, clean `for (const [idx, item] of arr.entries())` (supports `break`/`continue`/`await`!), vs `.forEach()` (cannot `break` or `await` properly!)
1-to-1 immutable projection returning a new array of identical length, transforming API DTOs into UI view-models, `["1","2"].map(Number)` vs `parseInt` radix trap!
Immutable subset selection based on boolean predicate, combining search keyword + category + inStock predicates, chaining `.filter(...).map(...)`
Accumulator folding `(acc, item, index) => nextAcc` with MANDATORY initial value (`0`, `{}`), cart grand totals, `groupBy` / ID lookup dictionary `{ [id]: item }`
Short-circuiting first matching element (`find` -> element or `undefined`) and index (`findIndex` -> index or `-1`; ES2023 `findLast`)
Existential short-circuit check (`true` as soon as AT LEAST ONE item matches; `false` on empty array `[]`)
Universal short-circuit check (`true` iff ALL items satisfy predicate; note vacuous truth `[].every(...) === true`!)
Default UTF-16 lexicographical sort trap, numeric `(a, b) => a - b`, locale strings `a.name.localeCompare(b.name)`, mutating `.sort()` vs non-mutating `[...arr].sort...
`arr.slice(start, end)` (`end` is exclusive!), negative indices `slice(-5)`, client-side pagination `items.slice((page - 1) * size, page * size)`
In-place delete/insert/replace `arr.splice(idx, delCount, ...added)` (returns removed items!) vs immutable ES2023 `arr.toSpliced(...)` for drag-and-drop reordering
Positional unpacking `const [first, second, ...rest] = items`, skipping slots `[, second]`, default values, variable swap `[a, b] = [b, a]`, React `const [count, set...
Object literals, dot `obj.key` vs computed bracket `obj[dynamicField]` access, `in` vs `Object.hasOwn(obj, key)`, shallow reference sharing
Memory Creation phase vs Code Execution phase, Variable Environment, Lexical Environment, `this` binding creation
LIFO stack frames, single-threaded execution, `RangeError: Maximum call stack size exceeded`, reading stack traces bottom-to-top
Environment Record + outer environment reference pointer walking outward to `null` at global root
Functions bundling their outer lexical environment; data encapsulation, `once(fn)`, `memoize(fn)`, `debounce(fn, wait)`, avoiding accidental detached-DOM retention
1) `new` binding -> new instance, 2) Explicit `call/apply/bind`, 3) Implicit `obj.method()` -> `obj`, 4) Default standalone `fn()` -> `undefined` in strict mode (plu...
Immediate invocation `fn.call(ctx, a, b)` & `fn.apply(ctx, [a, b])` vs permanent bound wrapper `const bound = fn.bind(ctx, presetArg)` (partial application)
`Object.getPrototypeOf(obj)`, how `[1,2].map` resolves to `Array.prototype.map` -> `Object.prototype` -> `null`, memory sharing across 10,000 instances
`Object.create(proto)`, constructor functions vs modern `class Child extends Parent`, property lookup vs own-property shadowing
Call Stack + Web APIs (timers, network, DOM) + Microtask Queue + Macrotask (Task) Queue + Render (`requestAnimationFrame` / Layout / Paint) cycle
`.then/.catch/.finally` continuations, `await` resumption, `queueMicrotask()`, why microtasks drain completely (including newly enqueued microtasks!) before the next...
Document -> Element -> Text -> Comment node hierarchy, live `HTMLCollection` vs static `NodeList`, how state-driven rendering relates to manual DOM mutation
Fast `document.getElementById`, CSS-powered `querySelector` / `querySelectorAll`, upward ancestor lookup `el.closest("[data-task-id]")` (essential for Event Delegati...
`document.createElement`, XSS-safe `el.textContent = userText` (vs dangerous `innerHTML`), `append`, `replaceChildren` (clears & mounts in 1 call!), `el.remove()`, `...
`getAttribute`/`setAttribute`/`removeAttribute`, boolean attributes `el.toggleAttribute("disabled", isSaving)`, camelCase `el.dataset.taskId` (`data-task-id`), synci...
`classList.add`, `remove`, conditional `classList.toggle("is-completed", task.completed)` (2nd boolean force arg!), `contains`, `replace`
Build a production-grade, zero-framework Vanilla JavaScript ES6+ Task & Sprint Management Application supporting full CRUD, priority/category tagging, due-date status indicators, debounced real-time search, multi-criteria filtering/sorting, analytics counters, keyboard shortcuts, and crash-safe `localStorage` persistence.
Module Learning & Hands-On Objectives
Compile-time structural type checking, IDE refactoring superpowers, complete type erasure at runtime (browsers still run emitted JS!)
`npm install -D typescript`, `npx tsc --noEmit` typecheck script in `package.json`, Vite fast esbuild transpilation + `tsc` type checking
`"strict": true`, `"target": "ES2022"`, `"moduleResolution": "bundler"`, `"noUncheckedIndexedAccess": true`, `"noUnusedLocals"`, `"isolatedModules"`
Lowercase primitive type names (`string`, NOT wrapper `String`!), `strictNullChecks` (`string | null`), optional `?` (`T | undefined`)
Why `any` disables the type checker (avoid!), safe top-type `unknown` (requires narrowing before use! โ ideal for `catch (err: unknown)` & raw JSON), bottom-type `ne...
`string[]` vs `Array<string>`, immutable `readonly Product[]` / `ReadonlyArray<Product>` preventing accidental `.push()`/`.sort()` mutation on props!
Fixed-length positional types `[lat: number, lng: number]`, `readonly [T, (next: T) => void]` custom hook return tuples (`as const`)!
Numeric enums (reverse-mapping pitfalls!), string `enum OrderStatus`, `const enum` caveats with bundlers, why `const STATUS = { ... } as const` + union `type Status...
Contextual typing in `.map((emp) => ...)` and event listeners, `let` widening (`"asc"` -> `string`) vs `const` literal narrowing (`"asc"`), `as const` deep readonly...
Annotating function parameters (always!), public return types (catches accidental return-shape drift!), empty arrays `const items: Product[] = []`, and nullable stat...
Function type expressions `(q: string) => Promise<Product[]>`, optional `page?: number`, callback `void` return rule, function overloads
Structural duck typing, excess property checking on fresh object literals, `readonly id: string`, index signatures `[key: string]: number`
`interface Employee extends Person, Auditable`, declaration merging (extending global `Window` or Express/Vite `ImportMetaEnv`!), clean error messages in IDEs
When ONLY `type` works: unions (`A | B`), primitives, tuples, mapped & conditional types; when `interface` shines: extensible object contracts & class `implements`
Discriminant literal tag (`status: "loading" | "success" | "error"`), how checking `if (state.status === "success")` automatically narrows `state.data` without optio...
Combining orthogonal capabilities `type WithPagination<T> = T & { page: number; pageSize: number }`, conflicting property type -> `never`!
Exact string/number/boolean literals (`size: "sm" | "md" | "lg"`), template literal types `` `/${string}` `` or `` `${Axis}-${Align}` ``
Control-flow narrowing via `typeof`, `instanceof`, `"data" in res`, `Array.isArray`, and user-defined type predicates `function isApiError(x: unknown): x is ApiError...
Why `as User` lies to the compiler if JSON doesnโt match, non-null `!` danger (avoid!), and TS 4.9+ `satisfies` (validates type compliance WITHOUT widening literal k...
Parameterized reusable contracts `ApiResponse<T>`, `PaginatedList<T>`, `groupBy<T, K extends PropertyKey>(items: readonly T[], keyFn: (item: T) => K)`
`function pluck<T, K extends keyof T>(items: readonly T[], key: K): T[K][]`, constraining `<T extends { id: string }>`
Deriving `CreateEmployeePayload = Omit<Employee, "id" | "createdAt">`, `UpdateEmployeePayload = Partial<CreateEmployeePayload>`, `Pick` summary cards, `Record<Role,...
Indexed lookup `Employee["department"]`, mapped `{ [K in keyof T]: boolean }` (e.g. `FormTouched<T>` & `FormErrors<T>`!), conditional `T extends Promise<infer U> ? U...
`import type { Employee } from "./types"` / `import { type Employee, formatSalary }`, guaranteeing zero runtime circular-import side effects (`verbatimModuleSyntax`)
Implementing interfaces (`class HttpEmployeeRepo implements EmployeeRepo`), `public`/`private`/`protected`/`readonly` constructor parameter properties (used heavily...
`DefinitelyTyped` (`@types/node`, `@types/react`), authoring `vite-env.d.ts` / `ambient.d.ts` (`declare module "*.svg"`, `Window` analytics globals)
Reading bottom-most nested TS assignability error lines first, browser `sourceMap: true` original `.ts` breakpoint debugging, incremental file-by-file `.js -> .ts` m...
Author a zero-`any` TypeScript 5 commerce & HR domain library modeling discriminated `ApiResult<T>` unions, generic repository helpers, type predicates, and utility types (`Partial`, `Pick`, `Omit`, `Record`).
Module Learning & Hands-On Objectives
Declarative `UI = f(state)` vs imperative DOM surgery, Virtual DOM tree diffing, one-way data flow, React 18/19 ecosystem
`npm create vite@latest app -- --template react-ts`, `createRoot(document.getElementById("root")!).render(<StrictMode><App /></StrictMode>)`, why `<StrictMode>` doub...
`index.html` mount root, hashed bundled imports from `src/assets` vs static unhashed root files in `public/` (`robots.txt`, `favicon.svg`)
Single root / `<>...</>` fragment rule, `className` & `htmlFor`, `{jsExpression}` (expressions, not `if`/`for` statements!), automatic HTML-entity escaping of `{user...
PascalCase naming (`function ProductCard()`), pure rendering (same props & state -> same JSX, zero side effects during render!), NEVER defining a component function...
Assembling complex pages from small focused `<PageHeader>`, `<FilterBar>`, `<DataGrid>`, and `<ModalShell>` building blocks
Read-only props passed parent -> child, lifting shared state to the closest common parent, child-to-parent communication via callback props `onDelete(id)`
Typing `interface ButtonProps extends ComponentPropsWithoutRef<"button">`, destructuring defaults `{ variant = "primary", isLoading = false }: ButtonProps`
`children: React.ReactNode`, named JSX slot props (`header?: React.ReactNode`, `footer?: React.ReactNode`), eliminating prop drilling via composition!
Ternary `isOpen ? <Panel /> : null`, early `if (!user) return <Skeleton />;`, and why `{items.length && <List />}` renders a literal `"0"` on screen when `items` is...
Mapping typed arrays to JSX elements, empty-array fallback `<EmptyState />`, derived filtered/sorted arrays before return
Why React needs stable sibling `key={item.id}` (or `crypto.randomUUID()` created at item-creation time, NEVER `Math.random()` during render!), why `key={index}` brea...
`React.MouseEvent<HTMLButtonElement>`, `React.ChangeEvent<HTMLInputElement>`, `React.FormEvent<HTMLFormElement>`, passing arguments cleanly `onClick={() => onRemove(...
Why mutating `let count = 0` doesnโt trigger a re-render, and why derived values (`const filtered = ...`, `const fullName = first + " " + last`) MUST be computed dur...
`const [user, setUser] = useState<User | null>(null)`, lazy initializer `useState(() => readExpensiveStorage())` (runs ONLY on initial mount, not every render!), bat...
Why `state.push(x); setState(state)` triggers ZERO re-render (`Object.is(prev, next)` sees the exact same reference!), functional updater `setCount(prev => prev + 1)...
Binding `value={email}` + `onChange={e => setEmail(e.target.value)}`, `checked={agreed}` on checkboxes, `<select value={role}>`, avoiding `"changing an uncontrolled...
`defaultValue` / `defaultChecked`, reading `new FormData(e.currentTarget)` on submit, file inputs (`<input type="file">` is ALWAYS uncontrolled in React!)
How functional components mount (initial render + commit), update (state/prop change -> re-render + commit), and unmount (cleanup), resetting component state cleanly...
CSS Modules (`Button.module.css`), Tailwind + `clsx`/`tailwind-merge` conditional classes, inspecting props/hooks/render-reasons in React Developer Tools, organizing...
Build a multi-component React + TypeScript Product & Expense Board featuring typed props, immutable `useState` updates, category filter chips, empty states, and stable `key` list rendering.
Module Learning & Hands-On Objectives
Call Hooks ONLY at top level (never inside `if`, `for`, or early returns!) and ONLY inside React functions/custom `use*` hooks โ because React tracks hooks by determ...
Grouping cohesive fields vs independent state variables, avoiding contradictory boolean flags via status union, resetting state cleanly
Post-paint execution timing, valid uses (timers, window listeners, WebSocket/DOM sync, data fetch with cleanup) vs invalid anti-patterns (computing derived state or...
No array (every render) vs `[]` (mount/unmount) vs `[dep1, dep2]` (`Object.is` comparison!), why lying to `exhaustive-deps` causes stale closure bugs, stabilizing ob...
When cleanup runs (BEFORE re-running the effect with new deps AND on unmount!), clearing `setInterval`/`setTimeout`, `removeEventListener`, `ctrl.abort()`, WebSocket...
`const inputRef = useRef<HTMLInputElement>(null)` (`inputRef.current?.focus()`), storing timer IDs / previous values without triggering re-renders, rule: never read/...
`createContext<AuthContextValue | null>(null)`, `<AuthContext.Provider>`, wrapping `useContext` in a custom `useAuth()` hook that throws a clear error if used outsid...
Pure `(state, action) => nextState` reducer + TypeScript Discriminated Union `Action` types, unit-testing complex cart/wizard reducers as plain TypeScript functions!
`const stats = useMemo(() => computeHeavyStats(rows), [rows])`, preserving referential equality for downstream memoized children/effects, when NOT to overuse `useMem...
`const handleDelete = useCallback((id: string) => setItems(prev => prev.filter(i => i.id !== id)), [])`, why `useCallback` matters ONLY when passed to `React.memo` c...
`use*` naming contract, how two components calling `useToggle()` get completely independent isolated state (hooks share *logic*, NOT state!), clean typed return cont...
Building higher-level domain hooks (`useProductSearch` composing `useDebouncedValue` + `useSearchParams` + `useFetch`)
Managing multi-input `values`, `touched`, `errors`, `isSubmitting` states, disabling duplicate submit clicks, accessible `aria-invalid` + `aria-describedby` wiring
Field-level vs cross-field validation (`confirmPassword === password`, `endDate >= startDate`), mapping backend `400/422` field errors onto specific inputs, focusing...
`useForm<FormValues>({ defaultValues, mode: "onTouched" })`, `{...register("email")}`, `handleSubmit(onValid)`, `formState: { errors, isSubmitting, isDirty }`, `rese...
`z.object({ email: z.string().trim().email(), salary: z.coerce.number().min(0) })`, `.refine()` cross-field checks, `type FormValues = z.infer<typeof schema>` (singl...
Catching uncaught rendering/lifecycle errors in subtree (`ErrorBoundary` / `react-error-boundary`), rendering a friendly fallback card with "Try Again" reset button...
`const AnalyticsPage = lazy(() => import("./pages/AnalyticsPage"))`, Vite automatic separate JS chunk emission, keeping initial landing bundle small and fast
`<Suspense fallback={<PageSkeleton />}>` coordinating lazy route/component loading states declaratively without manual spinner flags
Grouping sibling `<td>` cells or `<dt>`/`<dd>` pairs without inserting invalid wrapper `<div>`s into `<tr>` or CSS Grid/Flex parents! Using `<Fragment key={item.id}>...
`createPortal(modalJsx, document.body)` escaping parent `overflow: hidden` and `z-index` stacking contexts while preserving React event bubbling & Context tree inher...
Passing `ref` into custom `<Input>` components (React 19 `ref` as prop & `forwardRef` compatibility), splitting `StateContext` from `DispatchContext` & memoizing `va...
Create reusable `useDebounce`, `useLocalStorage`, and `useFetch` custom hooks powering a multi-step Employee Onboarding form built with React Hook Form and Zod schema validation.
Module Learning & Hands-On Objectives
How SPA routers intercept link clicks via History API without full HTML reloads, configuring SPA fallback (`rewrites` to `/index.html` on Vercel/Netlify/Nginx!)
`<BrowserRouter>` / `createBrowserRouter`, mounting router cleanly with global `<AuthProvider>` and `<ErrorBoundary>`
`<Routes>` & `<Route path element>`, index routes (`index`), wildcard `path="*"` `<NotFoundPage />` with recovery link
`/employees/:employeeId`, reading `const { employeeId } = useParams()`, validating undefined/malformed param before API calls
Parent `<DashboardLayout>` (Sidebar + Topbar + `<Outlet />`) wrapping child routes (`/dashboard`, `/employees`, `/settings`) without remounting the shell!
`<Link to="...">` (renders real crawlable `<a>` โ supports Cmd+Click new tab!), `<NavLink className={({ isActive }) => ...}>` (`aria-current="page"`!), programmatic...
`<ProtectedRoute>` wrapper checking `isBootstrappingAuth` (show loader!) -> `!isAuthenticated` (`<Navigate to="/login" state={{ from: location }} replace />`) -> `<O...
`<RequireRole allowedRoles={["ADMIN", "HR"]}>` returning a `<Forbidden403Page />` when an authenticated user lacks permission (plus reminding students backend APIs A...
Combining `React.lazy(() => import(...))` + `<Suspense>` per route so `/login` downloads in milliseconds without pulling heavy dashboard chart/table code
Separating HTTP transport (`apiClient.ts`) from domain endpoints (`employeesApi.ts`) from UI Hooks/Components; never hardcoding `fetch("http://localhost:8080/...")`...
Typed `fetch` helper, `AbortController` cleanup on unmount/query change, handling `204 No Content` empty body (`res.status === 204 ? null : await res.json()`!)
`axios.create({ baseURL, timeout: 10_000, headers })`, automatic JSON serialization, automatic rejection on non-2xx status codes, `AbortSignal` support
`apiClient.get<PaginatedResponse<Employee>>("/employees", { params, signal })`, automatic URL encoding of `params` object
`apiClient.post<Employee>("/employees", payload)`, disabling submit during in-flight request, navigating or updating list state on `201 Created`
Pre-populating edit forms (`reset(loadedEmployee)` in React Hook Form), full `PUT` vs partial `PATCH`, handling `409 Conflict` concurrent updates
Never deleting destructive records on a single accidental click! Confirming via accessible `<ConfirmDeleteModal>` (`role="alertdialog"`), disabling row during delete...
`Authorization: Bearer <accessToken>`, `Accept: application/json`, `X-Request-Id` correlation headers, why browsers block setting forbidden headers like `Host`/`Orig...
`apiClient.interceptors.request.use(...)` (inject token), `interceptors.response.use(...)` (normalize errors, handle `401` token refresh queue or clean logout redire...
Distinguishing offline network timeout (`!err.response`) from `400/422` field validation errors (`setError` on inputs!) vs `403` forbidden vs `500` server fault with...
Matching `<TableRowSkeleton />` dimensions to real rows to avoid layout shift, disabling submit buttons (`aria-busy="true"`), avoiding flicker on sub-150ms fast resp...
Distinguishing first-time empty collection (`"No employees yet -> + Add First Employee"`) from empty filtered search (`"No matches for 'xyz' -> Clear Filters"` butto...
Syncing `?page=2&size=10&dept=ENG&q=a` via React Router `useSearchParams()`, resetting `page` back to `1` whenever search or filter changes!
Combining `useDebouncedValue(searchInput, 300)` + `AbortController`, uploading employee avatars/resumes via `new FormData()` + `onUploadProgress` percentage bar & fi...
Login/Register/Logout flows, memory access token + `HttpOnly` refresh cookie best practice vs `localStorage` XSS trade-offs, `VITE_*` public env prefix rule (NEVER p...
Build a strictly typed single-page Employee & Department Management Dashboard using Vite, React 18+, TypeScript 5 (`strict: true`), React Router, React Hook Form + Zod, Axios REST API integration, Protected Routes, search/filters, pagination, and full CRUD workflows.
Module Learning & Hands-On Objectives
Trigger -> Render phase (pure virtual tree calculation) -> Commit phase (DOM mutations & `useLayoutEffect`) -> Browser Paint -> `useEffect`
Element type comparison (`div` vs `section` unmounts state!), component position identity, `key` reconciliation in dynamic lists, React 18 automatic state batching
Colocating local UI state (`isOpen`), lifting shared sibling state, URL search-param state (`?sort=price`), global client state, and remote server cache state
Creating typed contexts with `null` default + custom guard hook `useTheme()`, wrapping subtree `<Provider>`, reading context deeply without prop drilling
Component composition (`children` / slots) vs split State/Dispatch Contexts (`CartStateContext` + `CartDispatchContext`) to isolate re-renders
Single source of truth store, read-only state, pure reducer functions `(state, action) => nextState`, unidirectional dispatch -> reducer -> selector -> UI cycle, Red...
Installing `@reduxjs/toolkit` and `react-redux`, `configureStore`, `<Provider store={store}>`, typed `RootState` and `AppDispatch`, `useAppDispatch` and `useAppSelec...
Combining feature slices (`auth`, `cart`, `wishlist`, `ui`) in `configureStore({ reducer: { ... } })`, serializability check middleware rules
`name`, `initialState` with TypeScript interface, `reducers` with `PayloadAction<T>`, Immer safe "mutating" syntax (`state.items.push(...)`) compiling to immutable u...
Auto-generated action creators (`cartSlice.actions`), `prepare` callbacks for ID/timestamp generation outside reducers, `extraReducers` builder pattern
Colocated slice selectors, derived state calculation (subtotal, GST 18%, discount, grand total), memoizing derived arrays/objects with `createSelector`
Lifecycle actions (`pending`, `fulfilled`, `rejected`), `thunkAPI` (`rejectWithValue`, `signal`, `getState`), handling loading/error state in `extraReducers(builder...
`createListenerMiddleware` reactive side-effects (syncing cart to `localStorage`, firing analytics events on `orderPlaced`), custom logger middleware mechanics
Defining declarative API slices, `builder.query` & `builder.mutation`, auto-generated React hooks (`useGetProductsQuery`), `providesTags` & `invalidatesTags` automat...
Why server state is fundamentally different (remote ownership, asynchronous staleness, shared multi-user mutations, background revalidation, deduplication, paginatio...
`QueryClient` & `<QueryClientProvider>`, `useQuery({ queryKey, queryFn, staleTime, gcTime })`, hierarchical query keys `['products', { category, page }]`, `ReactQuer...
`useMutation({ mutationFn, onSuccess, onError })`, `queryClient.invalidateQueries({ queryKey: ['products'] })`, disabling submit buttons via `mutation.isPending`
`onMutate` snapshot (`cancelQueries` -> `getQueryData` -> `setQueryData`), instant heart/wishlist toggle feedback, automatic rollback in `onError`, final sync in `on...
`create<StoreState>()((set, get) => ({ ... }))`, fine-grained selector subscriptions `useStore(s => s.sidebarOpen)`, zero-provider ergonomic global UI stores
Persisting cart/theme/onboarding flags to `localStorage` with schema version migration & Zod parsing on hydration, cross-tab `storage` event sync
Practical decision matrix: Component `useState`/`useReducer` vs URL `SearchParams` vs React Context vs Zustand vs Redux Toolkit vs TanStack Query / RTK Query
Combine TanStack Query server-state caching (paginated products + optimistic wishlist toggle) with a typed Redux Toolkit store (`cartSlice`, `authSlice`, `toastSlice`, memoized `createSelector` totals, and `localStorage` listener sync).
Module Learning & Hands-On Objectives
Separating stateless UI primitives (`Button`, `Badge`, `Modal`), domain components (`ProductCard`), and data-connected feature views (`CatalogPage`)
Organizing large apps into `src/features/<feature>/{api,components,hooks,types,index.ts}` + `src/components/ui` + `src/lib` + `src/app` with public barrel boundaries
Design tokens (spacing, colors, radii, typography, z-index, elevation), variant recipes (`cva` / class-variance-authority pattern), `clsx` + `tailwind-merge` (`cn()`...
Styled libraries (MUI, AntD) vs Headless accessible primitives (Radix UI, Headless UI, Shadcn pattern) โ owning markup/Tailwind while delegating WAI-ARIA focus math
Implicit parent-child state sharing via scoped React Context (`<Tabs>`, `<Tabs.List>`, `<Tabs.Trigger>`, `<Tabs.Panel>`), flexible layout composition without 15 conf...
Function `(WrappedComponent) => EnhancedComponent`, prop forwarding, `displayName`, why Hooks replaced 95% of HOCs and how to maintain legacy enterprise HOCs
Inverting rendering control via `renderItem={(item) => ...}` or `children={({ isOpen, close }) => ...}` for headless data/virtualizer components
Encapsulating browser observers, SSR-safe `window` guards, stable callback refs (`useRef` latest-handler pattern), cleanup guarantees
Why components re-render (parent re-rendered, own state changed, consumed context changed), pushing state down (`SearchInput` isolation), lifting static JSX children...
Shallow prop comparison `Object.is`, when `React.memo` actually helps (expensive pure child rendered frequently with identical props), why inline objects/arrays defe...
Memoizing expensive CPU work (`O(n log n)` sorting/filtering 5,000 rows) AND preserving referential identity for downstream `memo`/`useEffect` dependencies
Preserving function identity across renders when passing callbacks to `React.memo` children or custom hook `useEffect` dependency arrays
Why a single monolithic `index.js` hurts First Contentful Paint & Time to Interactive, Vite automatic Rollup chunk generation on dynamic `import('./HeavyChart')`
Wrapping route groups and heavy modals in `<Suspense fallback={<PageSkeleton />}>`, avoiding layout jarring with dimension-matched skeletons, preloading on link hove...
Catching render/lifecycle errors in subtree (`getDerivedStateFromError`, `componentDidCatch`, `react-error-boundary`), retry reset keys, what Error Boundaries DO NOT...
`createPortal(children, document.body)`, escaping parent `overflow: hidden` / `transform` stacking contexts while preserving React event bubbling & Context access
Why mounting 10,000 DOM nodes freezes layout/scroll, rendering only the ~20 visible viewport rows + overscan buffer with translated container height
Implementing `debounce(fn, delay)` and `useDebouncedValue(value, 300)` from scratch with `setTimeout`/`clearTimeout` cleanup, cancelling stale network calls
Difference between Debounce (wait for silence) vs Throttle (execute at most once every `N` ms / `requestAnimationFrame`), cleanup on unmount
Sentinel `<div ref={loadMoreRef}>` + native `IntersectionObserver` (`rootMargin: '200px'`) + cursor/page `useInfiniteQuery`, preventing duplicate concurrent page loa...
Minimum character threshold (`>= 2`), trimmed normalized keys, cached query hits, `AbortController` race cancellation, keyboard arrow navigation (`combobox` ARIA), s...
`<input type="file" accept>`, drag-and-drop dropzone, MIME & max-size (`<= 2MB`) validation, `URL.createObjectURL` + `revokeObjectURL` preview, `FormData` upload pro...
Focus management (`autoFocus` return to trigger on modal close), `aria-expanded`, `aria-controls`, `aria-live="polite"` status toasts, `Escape` dismissal, keyboard p...
Build Compound `<Tabs>` and `<Accordion>`, a Portal focus-trapped `<Modal>`, `<ErrorBoundary>`, `IntersectionObserver` infinite scroll, debounced autocomplete, and a 10,000-row virtualized list.
Module Learning & Hands-On Objectives
Same-Origin Policy (scheme + host + port), untrusted client boundary, OWASP frontend risks (XSS, CSRF, Clickjacking, Open Redirects, Supply-chain npm packages)
Reflected, Stored, and DOM-based XSS; how React auto-escapes JSX `{text}` children; hidden XSS vectors (`dangerouslySetInnerHTML`, `href="javascript:..."`, `eval`),...
How ambient browser cookies auto-attach on cross-site requests, `SameSite=Lax`/`Strict` cookies, anti-CSRF tokens (`X-XSRF-TOKEN`) in cookie-authenticated SPAs
Why browsers enforce CORS, simple requests vs `OPTIONS` preflight (`Content-Type: application/json`, `Authorization`), `Access-Control-Allow-Origin`, Vite dev proxy...
`Content-Security-Policy` (`default-src 'self'`, `script-src`, `connect-src`, `frame-ancestors 'none'`), `Strict-Transport-Security` (HSTS), `X-Content-Type-Options:...
`HttpOnly; Secure; SameSite` cookies vs in-memory access token + `HttpOnly` refresh cookie vs risks of long-lived JWTs in `localStorage` under XSS
How Vite bundles `import.meta.env.VITE_*` directly into public static JS, keeping private API keys (OpenAI, Stripe Secret, DB URLs) strictly behind backend proxy end...
Why Zod/RHF client validation improves instant UX & accessibility while backend validation remains mandatory for security, trimming/normalizing payloads, open-redire...
Navigation Timing, TTFB, First Contentful Paint (FCP), Total Blocking Time (TBT), Speed Index, reading network waterfalls, Long Tasks (> 50ms on main thread)
Largest Contentful Paint (`<= 2.5s`), Interaction to Next Paint (`<= 200ms`), Cumulative Layout Shift (`<= 0.1`), `web-vitals` real-user monitoring (RUM) basics
Choosing SVG (icons/logos) vs WebP/AVIF (photos), responsive `srcset` + `sizes`, `<picture>` art direction, `loading="lazy"` below fold vs eager hero
Self-hosted `woff2` subsets, `<link rel="preload" as="font" crossorigin>`, `font-display: swap` / `optional`, metric-matched fallback font stacks
ES module static imports enabling Rollup/Vite tree-shaking (`import { format } from 'date-fns'` vs full `moment`), inspecting bundles with `rollup-plugin-visualizer`
Route-based splitting, on-demand modal/drawer chunk loading, Vite `build.rollupOptions.output.manualChunks` vendor separation (`react-vendor`)
Why Vite emits content-hashed filenames (`index-B7k9x2.js`), `Cache-Control: public, max-age=31536000, immutable` for `/assets/*` vs `no-cache` for `index.html`, `ET...
Performance flamecharts (identifying Long Tasks & forced synchronous layouts), Coverage tab (unused CSS/JS bytes), Memory heap snapshots (detached DOM leaks)
Running Lighthouse in Incognito against production preview builds, interpreting actionable diagnostics vs lab score variance
Testing across Chromium (Chrome/Edge), WebKit (Safari iOS `100dvh`, date inputs, flex/scroll quirks), and Gecko (Firefox), CanIUse & Autoprefixer
Testing Trophy / Pyramid for frontend (Static TypeScript -> Pure Unit Tests -> Component Integration Tests -> Critical E2E), Arrange-Act-Assert (`AAA`), deterministi...
Configuring `vitest` + `jsdom` + `@testing-library/jest-dom` (`toBeInTheDocument`, `toHaveTextContent`, `toBeDisabled`), `describe`/`it`/`expect`, `vi.useFakeTimers(...
`render(<Component />)`, accessible query priority (`getByRole`, `getByLabelText` over `getByTestId`), `queryBy*` (asserting absence), `findBy*` (waiting for async U...
`const user = userEvent.setup()`, `await user.type(...)`, `await user.click(...)`, `await user.keyboard('{Escape}')`, verifying Zod validation error messages & submi...
Network-level API mocking with Mock Service Worker (`msw` `http.get`/`HttpResponse.json`) vs `vi.spyOn`, testing loading -> success & `500` error states, coverage th...
Audit and harden a React storefront against XSS/open-redirects, tune LCP/CLS/bundle splitting to >= 90 Lighthouse scores, and write 20+ Vitest + React Testing Library (`userEvent` + mocked API) tests.
Module Learning & Hands-On Objectives
Why pure CSR SPAs send an empty `<div id="root">` initially vs Next.js pre-rendered HTML for SEO/LCP, when Vite React SPA is ideal (auth dashboards) vs Next.js (publ...
Scaffolding with TypeScript, ESLint, Tailwind CSS, `src/app` directory, `next.config.ts`, `npm run dev` / `npm run build` route output symbols (`โ Static`, `ฦ Dynami...
Folder segments (`app/products/page.tsx`), route groups `(marketing)` / `(shop)` without affecting URL paths, private `_components` folders
Root `app/layout.tsx` (`<html>` and `<body>`), nested section layouts preserving state across sibling route navigations
Dynamic folder `[slug]/page.tsx`, awaiting typed `params: Promise<{ slug: string }>` and `searchParams`, `notFound()` (`not-found.tsx`), `generateStaticParams` intro
`<Link href="...">` automatic viewport prefetching, `usePathname()` active nav styling, `useRouter()` (`next/navigation`, NOT legacy `next/router`!) programmatic nav...
Why App Router components are Server Components by default: zero client JS bundle cost, direct `async/await` data access on server, no browser hooks/events
Adding `'use client'` directive at file top when using `useState`, `useEffect`, event handlers (`onClick`), Redux/Query hooks, or browser APIs
Serializability rule for props crossing Server -> Client boundary (plain JSON/primitives, NO functions/classes!), passing Server Components as `{children}` into Clie...
Async Server Component `fetch()` + `Promise.all` parallel waterfalls prevention vs client-side TanStack Query/SWR for live interactive search/polling
Instant route transitions via `loading.tsx` and granular `<Suspense fallback={<ReviewsSkeleton />}>` streaming slow sections without blocking primary content
Creating `'use client'` `error.tsx` boundaries receiving `{ error, reset }`, recovering route segments without losing the persistent top navbar
Exporting `export const metadata: Metadata` and `export async function generateMetadata({ params })` for dynamic `<title>`, `description`, `openGraph`, and `alternat...
Difference between Vite dev server (native ESM) vs Rollup production build (`tsc -b` strict typecheck -> tree-shaking -> minification -> CSS extraction -> content-ha...
Path alias `@/* -> ./src/*` (synced in `tsconfig` + `vite.config.ts`), `build.sourcemap: 'hidden'` for Sentry without exposing source code publicly, chunk size warni...
Connecting GitHub repo for automatic `main` production deploys + PR Preview deployments, configuring `vercel.json` (`rewrites: [{ "source": "/(.*)", "destination": "...
Apex domain `A` record vs subdomain `CNAME` (`shop.yourdomain.com`), Letโs Encrypt automated TLS provisioning, HTTP -> HTTPS redirect & HSTS, updating backend CORS o...
Configuring separate `Development`, `Preview` (staging API), and `Production` environment variables in Vercel/Netlify dashboards; why build-time env changes require...
Authoring `.github/workflows/ci.yml` (`actions/checkout`, `actions/setup-node` with `cache: 'npm'`, `npm ci`, `npm run lint`, `npm run typecheck`, `npm test -- --run...
Architect, optimize, and test a production-style React + TypeScript E-Commerce Storefront featuring product catalog discovery, multi-facet filters, sorting, instant search, product variant details, Redux Toolkit cart & coupon engine, optimistic wishlist, authentication, validated multi-step checkout, order history, code-splitting, and automated Vitest + React Testing Library tests.
Verify your email OTP in 15 seconds to receive the live Zoom/Meet demo link, complete 10-module PDF, and personalized roadmap for Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript).
Semantic HTML5 & A11y
Semantic MarkupCSS3 & Tailwind CSS
Design SystemModern JavaScript ES6+
Web LanguageTypeScript 5
Typed LanguageReact 19, Hooks & Suspense
Frontend UINext.js 15 App Router
SSR & Full-StackVitest & Playwright E2E
Test AutomationGit, CI & Edge Deployment
Version ControlLeetCode Problem Solving
Trainer Coding PrepHackerRank Coding Prep
Trainer Coding PrepComplete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) teaches you how modern tech companies design, build, test, and deploy reliable Frontend & React Ecosystem software using HTML5 & Semantic A11y, CSS3, Flexbox & Grid, Tailwind CSS, JavaScript ES6+ & Async/DOM, TypeScript 5 (Strict) โ explained in clear everyday language before writing real production code.
Suitable for both complete beginners (guided step-by-step from Day 1 setup and core logic) and technical students/working professionals aiming for production architecture mastery.
Key Engineering Capabilities You Will Build:
Purpose: Directly required by Frontend & React Ecosystem engineering teams to ship reliable client systems.
Purpose: Directly required by Frontend & React Ecosystem engineering teams to ship reliable client systems.
Purpose: Directly required by Frontend & React Ecosystem engineering teams to ship reliable client systems.
Purpose: Directly required by Frontend & React Ecosystem engineering teams to ship reliable client systems.
Purpose: Automated HTML5 & Semantic A11y, CSS3, Flexbox & Grid, Tailwind CSS, JavaScript ES6+ & Async/DOM, TypeScript 5 (Strict) test suites โข Linting & static checks โข Mentor Git pull-request reviews โ ensuring your code never breaks silently when real users hit edge cases.
Purpose: Verify every single Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) topic through timed MCQ exams and spoken technical interviews before deploying your Live Client Project.
Student Learning Outcomes (By End of Course):
Baseline: HTML5, CSS3, ES2023+, TypeScript 5.x, Vite 5/6, React 18/19, Tailwind CSS, Redux Toolkit 2.x, TanStack Query 5.x & Vitest.Taught live by active Working IT Professionals between 7:00 AM and 8:00 PM IST (choose any slot based on trainer availability).
Batch Available (Sat โ Sun Only): 2 Hours / Day โข 7:00 AM to 8:00 PM IST (choose any slot based on trainer availability)
Mon โ Fri Guided Practice: Real GitHub repository builds, LeetCode/HackerRank coding & โฅ90% Mock/AI Interview gates.
Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) โ Live Cohort
Weekend Live (SatโSun โข 2h/Day โข 7 AMโ8 PM IST) โข 07:00 AM โ 08:00 PM IST Flexible Live Slots
Starts: 21 Nov 2026
๐ Live Client Production Project + Internship Letter
After completing all 14 progressive hands-on module projects during live classes, students join our mentor-led Client Production Sprint to build, test, and deploy "Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) โ Enterprise Client Production Platform" to live cloud production โ earning an Official Verified Internship Letter detailing their exact technical contributions.
Domain: Live Enterprise Frontend & React Ecosystem Client Engagement โข Infra: HTML5 & Semantic A11y, CSS3, Flexbox & Grid, Tailwind CSS, JavaScript ES6+ & Async/DOM, TypeScript 5 (Strict) โข Git CI/CD + Automated Testing + Live HTTPS Cloud Production
Certified on Your Official Internship Confirmation Letter:
1. Graduation Certificate
Certifies REAC module mastery, Mock/AI Viva scores & GitHub repos.
2. Client Internship Letter
Employer BGV-verifiable proof of live production deployment contributions.
See the exact job positions and realistic salary packages unlocked by Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript), plus which specialized MockAttempt Academy courses to pair next to qualify for higher-paying multi-stack engineering roles.
Hands-on module projects, topic-wise MCQ mocks, AI interviews & live client internship proof.
Production architecture, performance tuning & automated testing mastery.
Unlocked by combining this course with the recommended next courses below.
Why Learn Next (For What Purpose): Pair Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) with complementary specialist tracks or use your 30-Day 100% Tuition Credit toward our 6-Month Job-Guarantee* Career Program.
Every module, GitHub lab, 50-MCQ assessment, and 4-axis Spoken AI Viva in Complete React.js Developer Course (with HTML5, CSS3, Tailwind, JS & TypeScript) is reviewed quarterly against live enterprise hiring bars and taught in clear English on weekends by active Working IT Professionals.
No! Modules 1โ3 build your complete HTML5, CSS3 Flexbox/Grid, Tailwind CSS, Modern JavaScript ES6+ (closures, promises, async/await, DOM), and strict TypeScript 5 foundations right inside the course before advancing into React, Hooks, Redux Toolkit, TanStack Query, Next.js fundamentals, and Vitest testing.
โน3,999 All-Inclusive (Incl. 18% GST), payable upfront or in 2 ร โน2,000 splits, with 100% 30-day fee credit if you upgrade to our โน15,000 Frontend Developer Career Program (FDCP).
Yes โ you practice 40 curated JavaScript & React machine-coding problems and deploy a complete React + TypeScript + Redux Toolkit E-Commerce Storefront live on Vercel/Netlify.
Matching Career Roadmaps:
Weekend Live REAC Cohorts Across Top IT Hiring Hubs:
Book Free Live Demo or Reserve Batch Seat