Hero roadmap: the whole course on one page

All 100 lessons

This page maps the full arc of the course in one place, from first types to three finished capstones. Use it as a checklist and mark each lesson as you complete it.

Lessons 1 through 90 live on the TypeScript course index, so the list below points there by number. Lessons 91 through 100 carry full links with exact titles.

Lessons 1 to 10

• Lesson 01: What is TypeScript and where it runs
• Lesson 02: Install TypeScript
• Lesson 03: Your first program
• Lesson 04: tsconfig.json
• Lesson 05: Basic types
• Lesson 06: any, unknown, never
• Lesson 07: Arrays and tuples
• Lesson 08: Type aliases
• Lesson 09: Interfaces
• Lesson 10: Unions and literals

Lessons 11 to 20

• Lesson 11: Function types
• Lesson 12: Parameters
• Lesson 13: Overloads
• Lesson 14: Generics
• Lesson 15: Constraints
• Lesson 16: Return types
• Lesson 17: Arrow functions
• Lesson 18: Callbacks
• Lesson 19: Narrowing
• Lesson 20: Assertions

Lessons 21 to 30

• Lesson 21: Classes
• Lesson 22: Constructors
• Lesson 23: Modifiers
• Lesson 24: implements
• Lesson 25: Abstract classes
• Lesson 26: static
• Lesson 27: Getters and setters
• Lesson 28: Enums
• Lesson 29: ES modules
• Lesson 30: Decorators

Lessons 31 to 40

• Lesson 31: Discriminated unions
• Lesson 32: Intersections
• Lesson 33: Mapped types
• Lesson 34: Conditional types
• Lesson 35: infer
• Lesson 36: Template literal types
• Lesson 37: keyof and typeof
• Lesson 38: Utility types
• Lesson 39: satisfies
• Lesson 40: const assertions

Lessons 41 to 50

• Lesson 41: tsc CLI
• Lesson 42: tsconfig deep dive
• Lesson 43: Strict mode
• Lesson 44: Source maps
• Lesson 45: Declaration files
• Lesson 46: Linting
• Lesson 47: Formatting
• Lesson 48: Debugging
• Lesson 49: Project references
• Lesson 50: Publishing packages

Lessons 51 to 60

• Lesson 51: Run with Node
• Lesson 52: npm scripts
• Lesson 53: argv and env
• Lesson 54: Files with fs
• Lesson 55: path and os
• Lesson 56: JSON IO
• Lesson 57: Dates
• Lesson 58: Crypto random
• Lesson 59: Timers
• Lesson 60: process

Lessons 61 to 70

• Lesson 61: Callbacks to promises
• Lesson 62: Promises
• Lesson 63: async and await
• Lesson 64: Promise.all
• Lesson 65: Promise.race
• Lesson 66: HTTPS client
• Lesson 67: Abort and timeouts
• Lesson 68: Async error handling
• Lesson 69: Sequential vs parallel
• Lesson 70: Event loop

Lessons 71 to 80

• Lesson 71: Tests with assert
• Lesson 72: Test layout
• Lesson 73: Fixtures
• Lesson 74: Test doubles
• Lesson 75: CI tests
• Lesson 76: DOM basics
• Lesson 77: DOM events
• Lesson 78: Fetch in browsers
• Lesson 79: Forms
• Lesson 80: Web storage

Lessons 81 to 90

• Lesson 81: Npm packages
• Lesson 82: Bundling concept
• Lesson 83: SPA concepts
• Lesson 84: Typed API client
• Lesson 85: Hand-rolled validation
• Lesson 86: Iterators and generators
• Lesson 87: Mixins
• Lesson 88: Branding nominal types
• Lesson 89: Result types
• Lesson 90: Options objects

Lessons 91 to 100

• Lesson 91: Builder
• Lesson 92: Event emitters
• Lesson 93: Streams
• Lesson 94: Workers
• Lesson 95: Deserialization
• Lesson 96: Capstone: todo CLI
• Lesson 97: Capstone: JSON API
• Lesson 98: Capstone: utils library
• Lesson 99: Modern TypeScript tour
• Lesson 100: Hero roadmap: the whole course on one page

How to practice

Type every snippet by hand instead of copying it. Short programs with one new idea per file build muscle faster than long reading sessions.

After each lesson, break the example once and read the error. Fixing a red squiggle teaches more than ten clean compiles.

const today: string = "one lesson"; const nextStep: string = "one experiment"; console.log(today); console.log(nextStep);

Three capstones, revisited (96-98)

The course ends with three builds: a todo CLI, a JSON API, and a utils library. Each one reuses the same core of parsing, guarding, and testing.

Rebuild all three from memory in this order: CLI first, then library, then API. The second pass always runs faster and reveals which ideas stuck.

const order: Array<string> = ["cli", "lib", "api"]; console.log(order.length);

Where to go next

Strong next steps are async patterns, testing runners, and a first published package. Each direction builds directly on the capstones above.

Refresh the JavaScript runtime model and the promises flow before adding frameworks. A solid runtime picture makes every later tool easier.

Next: TypeScript course

Article author: Arthur Isaev