How much TypeScript do you already have?
Be honest — nobody is watching. This only decides which chapters come first; every chapter stays open to you either way.
“I can type a real function.”
Start with the compiler and the basic type vocabulary — primitives, objects, functions and classes with real types on them.
- You know JavaScript comfortably
- You've seen TypeScript in a codebase but never configured it yourself
- You want the vocabulary — types, interfaces, generics by name — once, in order
“I can design a real type.”
You know the vocabulary. Now learn to shape it: narrowing, generics, the utility types everyone uses, and a tsconfig that fits a real project.
- Comfortable with interfaces, unions and basic generics
- You've written `as any` to make an error go away and known it was wrong
- You want types that describe your actual data, not just satisfy the compiler
“I can design a type system.”
Conditional and recursive types, the compiler API, and the judgment calls behind migrating a real codebase or shipping a type-safe library.
- You can already design generic, narrowed modules
- You read library .d.ts files for fun, or at least without flinching
- You want the why under template literal types and the compiler itself
Not sure? Start at Beginner — every path opens at the section people usually skip.
Full syllabus
Everything each level eventually covers — ticked sections are written, the rest are still on the desk.
Beginner0 / 8 sections written
- Setup & the compilercoming soon
tsc, tsconfig.json basics, strict mode (surface level) · ts-node and running TypeScript directly
- Basic typescoming soon
Primitives, arrays, tuples · any, unknown, never — and why they're different · Type inference: when you don't need to annotate
- Functionscoming soon
Parameter and return types, optional and default params · Function overloads (surface level)
- Interfaces & type aliasescoming soon
Object shapes, readonly, optional properties · interface vs type — when it matters
- Union & intersection typescoming soon
Union & intersection types, basic usage
- Enums & literal typescoming soon
Enums, const enums, string/number literal types
- Classes in TypeScriptcoming soon
Access modifiers, readonly fields · implements, abstract classes (surface level)
- Working with the DOM & JSONcoming soon
Typing DOM APIs, event handlers · Typing JSON data, JSON.parse and unknown
✅ Checkpoint: you can add TypeScript to a small JS project, type its functions and objects, and get real compiler errors instead of runtime surprises.
Intermediate0 / 11 sections written
- Structural typing & inference in depthcoming soon
Structural vs nominal typing, excess property checks · Contextual typing, inference in generics
- Narrowingcoming soon
typeof/in/instanceof guards, custom type guards · Discriminated unions
- Runtime validation with Zodcoming soon
Why types disappear at runtime — the compile-time/runtime gap · Zod schemas, z.infer, parsing vs validating · Validating API responses and form input at the boundary
- Genericscoming soon
Generic functions, interfaces and classes · Constraints, default type parameters
- Utility typescoming soon
Partial, Pick, Omit, Record, ReturnType and friends
- Mapped & conditional typescoming soon
Mapped types, conditional types, the basics of infer
- Modules, namespaces & declaration filescoming soon
ESM/CJS module typing, namespaces (when they still matter) · Writing a .d.ts file
- Configuring tsconfig for real projectscoming soon
target/module/lib/paths, strict family flags one by one
- Working with third-party typescoming soon
@types packages, module augmentation, ambient declarations
- Typing async codecoming soon
Typing promises, async functions, error handling patterns
- Testing typed codecoming soon
ts-jest/Vitest with TypeScript, type-checking in CI
✅ Checkpoint: you can design a generic, narrowed, well-typed module that a teammate can use without reading its implementation.
Advanced0 / 10 sections written
- Advanced genericscoming soon
Variance (surface level), the infer keyword
- Conditional & recursive typescoming soon
Template literal types, recursive type definitions
- Type-level programmingcoming soon
Branded/opaque types, building a type-safe API surface
- Decorators & metadatacoming soon
Decorators, reflect-metadata (surface level)
- Structural vs nominal typing tradeoffscoming soon
When structural typing bites, simulating nominal types
- Type-checking performancecoming soon
Project references, incremental builds, why builds get slow
- Monorepo & multi-package setupscoming soon
Shared tsconfigs, path aliases, package boundaries
- Migrating a JS codebase to TypeScriptcoming soon
allowJs, checkJs, incremental adoption strategy
- The TypeScript compiler APIcoming soon
Writing a simple transform or codemod
- End-to-end type safetycoming soon
TypeScript across React, Node and GraphQL boundaries
✅ Checkpoint: you can design a small type-safe library with conditional/mapped types, explain a gnarly inference error, and defend a migration plan from JS to TS.
- Narrowing and discriminated unions are where most people actually start writing idiomatic TypeScript instead of fighting the compiler — they sit early in intermediate on purpose.
- Utility and mapped types get asked about constantly in interviews, but they only click once generics already do — that's why generics comes first.
- The compiler API and migrating a real JS codebase are the deepest, least-common layer — most working TS developers never touch them, but the advanced tier doesn't skip them.