Practice & Roadmap

Where you are right now

If you completed Phases 1–4 you can:

• ✅ Read and write any production TypeScript codebase.
• ✅ Build typed React components and APIs.
• ✅ Author your own utility types and .d.ts files.
• ✅ Configure tsconfig + ESLint for a real project.

What separates "knows TypeScript" from "great at TypeScript" is reps — solving problems and shipping projects. Below is the path.

Track 1 — Type-Challenges (must do)

[github.com/type-challenges/type-challenges](https://github.com/type-challenges/type-challenges) is the gym for the TS type system. Work through them in order:

Tier	Skill	What you practise
Easy (13)	Re-implement utility types	Pick, Readonly, First, Length, Includes
Medium (~80)	Mapped + conditional + infer	DeepReadonly, TupleToObject, Chainable
Hard (~40)	Recursive types, parser-style	Currying, Get, String to Number
Extreme (~10)	Arithmetic at the type level	Yes, you can multiply numbers in the type system

Goal: finish all 13 Easy + 20 Mediums. After that you've internalised the big ideas.

Track 2 — Refactor a real JS project to TS

Pick a 200–500-line JS project of yours (or a small open-source one) and convert it. The pattern:

1. Add tsconfig.json with allowJs: true. 2. Rename one file at a time .js → .ts. 3. Fix errors before moving to the next file. 4. Once everything compiles, turn on strict and clean up. 5. Remove allowJs.

You'll learn:

• Where types add real value (boundaries) and where they're noise.
• How third-party JS libs feel without types.
• The pain that a typed schema (zod) saves you from.

Track 3 — Build typed real-world tooling

Pick one mini-project. Each forces you to use a different part of the language:

a) A typed REST client

Generic fetcher(url: string): Promise with zod runtime validation. Practises generics + type narrowing + utility types.

b) A typed event emitter

class Emitter<T extends Record<string, unknown>> {
  on<K extends keyof T>(name: K, fn: (payload: T[K]) => void): void { /* … */ }
  emit<K extends keyof T>(name: K, payload: T[K]): void { /* … */ }
}

Practises generic constraints + keyof + indexed access types.

c) A typed Redux-style store

Slices, action types as discriminated unions, selectors. Practises union narrowing + mapped types.

d) A schema validator

Build a tiny z.string().min(3) clone. Practises method chaining with generics, branded types, and inference. Hardest of the four — most rewarding.

Track 4 — Interview classics

If you're prepping for jobs, drill these patterns until they're automatic:

Pattern	What to know
Discriminated unions	When and why; exhaustiveness with never
keyof + indexed access	"Get the type of the value at any key"
Generics + constraints	Why matters
infer in conditionals	Pulling pieces out of function/promise/array types
Mapped types with as	Generating one shape from another
Function overloading	When to use it vs union of params
unknown vs any	The single most common interview gotcha
as const	Inferring narrow literal types

Track 5 — Read great code

The best TS in the wild:

• zod — schema builder. Beautiful inference. Read src/types.ts.
• tRPC — end-to-end type-safe APIs. Borderline magical types.
• react-hook-form — generics + paths into nested objects.
• @tanstack/query — generic, deeply-typed cache.
• type-fest — a library of utility types worth grepping through when you need one.

Spend 30 minutes a week reading a single file from one of these. Worth more than another tutorial.

Habits that matter

• ✅ tsc --noEmit in CI. Always.
• ✅ Avoid any. If you must, leave a comment explaining when it can be removed.
• ✅ Define types at the boundaries (API responses, form inputs, env vars). The middle of your code can usually infer.
• ✅ Use unknown for parsed JSON until you validate.
• ✅ Lean on inference. If you can delete a type annotation and the code still works, often you should.
• ✅ Hover over things in your editor — half of TS learning is reading what the compiler infers.

Roadmap timetable (suggested)

Week	Goal
1	Easy Type-Challenges (all 13)
2	Convert one JS project to TS
3	Build the typed event emitter
4	Medium Type-Challenges (10)
5	Build the typed REST client + zod
6	Read zod source for an hour
7	Medium Type-Challenges (10)
8	Schema validator mini-project

Eight weeks of this and you're meaningfully better than 80% of TS developers.

You're done with the curriculum 🎉

Sixteen topics, four phases, every quiz, every practice link. From here it's all reps. Go ship something typed.