Chapter 44: TypeScript Syllabus
TypeScript Syllabus written exactly as if I am your personal teacher sitting next to you in Hyderabad, explaining how a serious, production-oriented TypeScript learning path looks in early 2026.
I divided it into 8 logical levels (not “weeks” — because people learn at very different speeds). Each level contains:
- main topics
- realistic time estimate (assuming 5–10 hours/week)
- why this order matters
- key learning outcomes
- 2–4 small real-world-ish example tasks you should be able to do after the level
You can use this as a 3–12 month roadmap depending on your starting point and daily time.
Level 0 – Prerequisites (skip if you already know modern JavaScript well)
Time: 0–4 weeks Focus: Make sure JavaScript foundations are solid — TypeScript builds directly on them.
Must-know before serious TS:
- let vs const vs var
- Arrow functions + lexical this
- Destructuring (object & array)
- Spread / rest operators
- Template literals
- Default parameters
- Modules (import / export)
- Promises + async / await
- Array methods (map, filter, reduce, find, some, every)
- Modern object syntax (Object.fromEntries, optional chaining ?., nullish coalescing ??)
Mini-check tasks after Level 0
JavaScript
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Can you instantly understand & fix these? const data = { name: "Sara", age: 28 }; const { name, ...rest } = data; async function fetchAndProcess() { const res = await fetch("/api"); return res.ok ? await res.json() : null; } const doubled = [1,2,3].map(x => x * 2); |
Level 1 – TypeScript Hello World (first 2–4 weeks)
Goal: Understand what TS actually does (and does not do) at runtime.
Topics:
- Why TypeScript exists (type safety, editor experience, refactoring, documentation)
- tsc vs tsc –noEmit vs tsc –watch
- Basic annotations (: string, : number, : boolean, : any, : unknown)
- Type inference (when TS guesses the type for you)
- Arrays & tuples
- Objects (inline & interface)
- Union types (string | number)
- Literal types (“active” | “inactive”)
- as const for literal narrowing
- Functions (parameter & return types)
After Level 1 you should be able to comfortably write:
TypeScript
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
type Size = "xs" | "sm" | "md" | "lg" | "xl"; const sizes = { xs: "0.5rem", sm: "0.75rem", md: "1rem" } as const satisfies Record<Size, string>; function getPadding(size: Size): string { return sizes[size]; } console.log(getPadding("md")); // ok // getPadding("xxl"); // error |
Level 2 – Everyday Types & Narrowing (next 4–8 weeks)
Topics:
- null vs undefined vs optional properties (?)
- Type guards (typeof, instanceof, in, equality checks)
- Discriminated unions + kind / type / status pattern
- Narrowing with if, switch, custom type predicates (is)
- unknown vs any in catch blocks
- Non-null assertion (!) — when to use & when to avoid
- Type aliases vs interfaces (when to choose which)
After Level 2 you should write clean code like:
TypeScript
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
type ApiResponse<T> = | { status: "success"; data: T } | { status: "error"; message: string }; function processResponse<T>(res: ApiResponse<T>): T | never { if (res.status === "success") { return res.data; } throw new Error(res.message); } |
Level 3 – Generics & Utility Types (2–3 months in)
Topics:
- Generic functions & generic interfaces
- extends constraints
- keyof, indexed access types T[K]
- Built-in utility types everyone uses daily:
- Partial<T>
- Required<T>
- Readonly<T>
- Pick<T, K>
- Omit<T, K>
- Record<K, T>
- ReturnType<T>
- Parameters<T>
- Awaited<T>
- satisfies operator (game changer since 4.9)
After Level 3 you should be able to write:
TypeScript
|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
function pick<T, K extends keyof T>(obj: T, ...keys: K[]): Pick<T, K> { return keys.reduce((acc, k) => { acc[k] = obj[k]; return acc; }, {} as Pick<T, K>); } const user = { id: 1, name: "Sara", email: "sara@example.com" }; const preview = pick(user, "id", "name"); // { id: number; name: string } |
Level 4 – Advanced Types & Real Patterns (3–6 months in)
Topics:
- Conditional types (T extends U ? X : Y)
- infer keyword
- Mapped types ({ [K in keyof T]: … })
- Key remapping with as clause
- Template literal types
- Recursive types (DeepPartial<T>, Paths<T>)
- Branded / nominal types for IDs, slugs, emails
- never, void, unknown deep understanding
After Level 4 you should build things like:
TypeScript
|
0 1 2 3 4 5 6 7 8 9 10 11 |
type Paths<T> = T extends object ? { [K in keyof T]: K extends string | number ? `${K}` | (T[K] extends object ? `${K}.${Paths<T[K]>}` : never) : never }[keyof T] : never; |
Level 5 – Ecosystem & Tooling Mastery
Topics:
- tsconfig best practices (strict flags, paths, bundler vs nodenext)
- Declaration merging & module augmentation
- JSDoc-powered TypeScript in legacy JS projects
- @types/* vs built-in types
- ESLint + typescript-eslint recommended rules
- tsc –noEmit in CI + pre-commit hooks
- Vite / Next.js / Node.js specific tsconfig
Level 6 – Frameworks & Real Projects
Choose 1–2 according to your stack:
- React + TypeScript (hooks, context, generics in components)
- Next.js App Router + Server Components
- Node.js / Express / NestJS backend
- tRPC / Zod / TanStack Query patterns
Level 7 – Library Author Level (optional – 9–18 months in)
- Publishing .d.ts files
- Dual package (CJS + ESM)
- Generics + conditional types in public APIs
- Branded types + inference helpers
- Writing your own utility types (DeepReadonly, Mutable, UnionToIntersection)
Suggested weekly rhythm (realistic)
- Mon–Fri: 45–90 min theory + exercises
- Weekend: refactor one real file in your project using new concepts
- Every 2–3 weeks: solve 5–10 quiz questions
- Every 4–6 weeks: build one small typed mini-project (CLI, React component library, API client…)
Where are you right now (roughly)?
- Just starting (Level 1–2)
- Comfortable with basics but struggling with generics/unions (Level 3–4)
- Already using TS daily but want to go deeper / cleaner (Level 5+)
Tell me your current feeling and I’ll suggest the next 5–7 exercises that will give you the biggest improvement right now 😄
