12 free chapters and a certificate anyone can verify.
Read the guide: How to learn TypeScript: a roadmap for JS developers
Direct Answer: Turn the bugs you currently find in production into red squiggles you find while typing — inference, unions, generics, and the patterns that make a large codebase safe to change.
What a type checker actually buys you, how to configure tsc properly, and where annotations belong.
Interfaces, type aliases, unions, intersections, and the discriminated-union pattern that makes bad states impossible.
How TypeScript follows your control flow, how to teach it about runtime checks, and what unknown, any, and never are for.
Writing code that works over many types without losing type information, and deriving types instead of duplicating them.
Async code, untrusted API data, declaration files, and typing React components and hooks.
Conditional types, infer, template literals, key remapping, branded types, and satisfies — the tools for the last mile of precision.
Reading the errors tsc actually gives you, keeping check times survivable as a project grows, and testing types so a regression fails the build.
Making the schema at each boundary the single source of truth, so what the checker believes about incoming data matches what actually arrives.
The assignability rules behind every error you get, every error you do not get, and the handful of places TypeScript is unsound on purpose.
Designing state, failure, and invariants so the compiler enforces the rules of the business instead of leaving them to convention and code review.
What changes when your types become a public artefact, from inference and error messages to declaration emit, module resolution, and versioning.
Driving TypeScript's own API to refactor, enforce, and extend types across a codebase far too large to change by hand.
Topic checks
Each one opens the next topic
Chapter quizzes
Each one opens the next chapter
50-question final
50 of 100 marks to pass
Certificate
Issued instantly, verifiable
One attempt, 60 minutes. If you don't pass, you can retake once after 30 days.
The fastest answer to how to learn TypeScript is to stop treating it as a new language. It is JavaScript with a checker that reads your code before it runs. So learn it in this order: turn on strict mode in a real project, learn to describe the shapes of your data with unions, let the checker narrow those unions for you, then learn generics, and only after that touch the clever type level features. If you already write JavaScript comfortably, you can be productive in TypeScript within a couple of weeks and genuinely good at it within a couple of months.
This guide walks through that roadmap step by step, lists the mistakes that keep people stuck at "TypeScript is just annoying", and explains what our free TypeScript for JavaScript Developers course covers, chapter by chapter.
TypeScript adds nothing at runtime, so every confusing moment is either a JavaScript problem or a types problem, and you need to tell them apart. Be comfortable with:
async/awaitimport and export)If several feel shaky, spend a few weeks on plain JavaScript first through full stack web or frontend engineering.
Here is the kind of bug that ships every week in JavaScript:
function totalPrice(order) {
return order.items.reduce((sum, i) => sum + i.price * i.qty, 0);
}
totalPrice({ items: [{ price: '', qty: 2 }] }); // 0, a blank price is silently free
No crash, no stack trace, just a wrong number in your database. With a two line type, the editor flags it before you save the file:
type Item = { price: number; qty: number };
type Order = { items: Item[] };
// totalPrice({ items: [{ price: '', qty: 2 }] })
// Type 'string' is not assignable to type 'number'.
Types catch typos and renames, missing values (the endless "Cannot read properties of undefined") and wrong shapes across a function boundary. They do not catch wrong business logic, and they do not check data arriving from outside your program unless you make them.
| Stage | What to learn | You are done when |
|---|---|---|
| 1. Setup | tsc, tsconfig.json, strict: true | a small project compiles with zero errors in strict mode |
| 2. Shapes | type aliases, interfaces, unions, optional properties | you can type an API response by hand |
| 3. Narrowing | typeof, in, discriminated unions, unknown | a switch over a union errors when you forget a case |
| 4. Generics | type parameters, keyof, utility types | you write one generic helper instead of three copies |
| 5. Real code | async types, .d.ts files, React props and hooks | a real feature ships in TypeScript with no any |
| 6. Precision | conditional types, branded types, satisfies | you can read a library's types without fear |
Install TypeScript, run tsc --init, and set "strict": true. Do not start without it. Strict mode switches on strictNullChecks, which is the single flag that removes most undefined errors, and noImplicitAny, which stops values quietly losing their types. Learning TypeScript with strict mode off teaches you a weaker language and leaves you with habits to unlearn.
Then learn when not to annotate: annotate function parameters and exported return types, and let inference handle local variables.
Learn type and interface (they overlap a lot; pick one style and stay consistent), optional properties, and above all union types. The most useful pattern in the entire language is the discriminated union:
type RequestState =
| { status: 'loading' }
| { status: 'error'; message: string }
| { status: 'done'; data: User[] };
With this, "loading but also has data" simply cannot be written. Bad states become unrepresentable.
TypeScript follows your if statements. After if (req.status === 'error'), it knows message exists. Learn type guards, predicates and assertion functions for when the built in checks are not enough. Learn the difference between unknown (a value you must check before using) and any (a value the checker stops caring about). Use never to make a switch fail to compile when someone adds a new case and forgets to handle it.
Generics are parameters for types. Start with first<T>(items: T[]): T | undefined, then learn keyof, typeof, indexed access and the weekly utility types: Partial, Pick, Omit, Record, ReturnType. The goal is deriving types instead of copying them.
Most tutorials stop too early here. Type async functions and API responses (res.json() hands you any), write a declaration file for an untyped package, type React components and hooks, and migrate a JavaScript project gradually. If you are on the backend side, pairing this stage with a Node.js backend project works well; our guide on how to learn Node.js backend shows the API you could build.
Conditional types, infer, template literals, branded types and satisfies are powerful, and they are where beginners lose weeks writing types nobody can read. Learn them after shipping real code.
Reaching for any whenever an error appears. Every any is a hole that spreads: whatever touches it loses its type too. Use unknown and narrow it.
Using as to silence the checker. An assertion says "trust me", and usually hides the bug the error was pointing at.
Trusting types at the boundary. A type annotation on JSON.parse output is a promise, not a check. Data from an API, a form or an environment variable must be validated at runtime, with a schema library such as Zod or your own guards, before the type means anything.
Not reading the error. TypeScript errors look long, but the most specific line is often the last one in the chain, so try reading from the bottom up.
TypeScript for JavaScript Developers is an intermediate, text based course built around the roadmap above. It has 12 chapters with four lessons each, a quiz after every topic, and a final exam. Each chapter is meant to leave you able to fix a specific real failure.
| Chapter | What you learn |
|---|---|
| 1. Why Types, and Getting Them Running | what types catch, tsc, tsconfig and strict mode, inference, type checking JavaScript with JSDoc |
| 2. Describing Shapes | interfaces vs type aliases, unions and intersections, literal types and discriminated unions, when to avoid enums |
| 3. Narrowing, Guards, and the Edges of the Type System | control flow analysis, type guards and assertion functions, unknown, any and never, escape hatches |
| 4. Generics and Type Transformations | generics from first principles, keyof and typeof, utility types, function overloads |
| 5. TypeScript in a Real Codebase | typing async code and API responses, declaration files, React components and hooks, migrating a JS project |
| 6. Types That Compute | conditional types and infer, template literal types, branded types and satisfies, recursive types |
| 7. Keeping a Large Codebase Fast and Green | reading type errors, build speed and project references, testing types, upgrading TypeScript safely |
| 8. Where Types Meet Real Data | parse, don't validate, schemas as the single source of truth, typed config and env, generated types from OpenAPI, GraphQL and SQL |
| 9. Why the Checker Says Yes | how assignability works, excess property checks, variance, the unsound corners |
| 10. Modelling a Domain in Types | failure as data, state machines the compiler enforces, readonly, domain types vs wire types |
| 11. Shipping Types Other People Depend On | APIs that infer for the caller, readable error messages, ESM, CJS and module resolution, versioning types |
| 12. Programming the Compiler Itself | the compiler API, codemods with ts-morph, type aware lint rules, language service plugins |
Chapters 1 to 5 are what most working developers need. Chapters 6 to 12 are for people maintaining large codebases or publishing libraries.
The course is for people who already write JavaScript: frontend developers moving a React app to TypeScript, Node developers tired of runtime surprises, and students whose internship codebase turned out to be TypeScript. It is not a first programming course. If you are still choosing a first language, read which programming language to learn first instead.
The suggested pace is 6 weeks. The reading is roughly ten and a half hours, but typing the examples into an editor, breaking them and watching the errors change is where TypeScript sticks. With an hour or so a day, six weeks is realistic.
Each topic has a minimum reading time of 90 seconds before its quiz opens, and you need 70 percent on that quiz to unlock the next topic. Chapter quizzes are practice with instant feedback.
The certificate comes from the final exam: 50 questions, 60 minutes, one timed attempt, and you pass with 50 out of 100 marks. If you do not pass, a retake opens 30 days later with the questions and options reshuffled. Pass, and you get a free certificate with a verification code and a QR code anyone can check. Keep it in proportion: a reviewer will learn more from a repository with strict mode on and no stray any than from any certificate, ours included.
Ready to start? Open TypeScript for JavaScript Developers, switch on strict mode in a project you already have, and work through Chapter 1 this week. The red squiggles are the point.
05 questions
Yes. TypeScript is JavaScript plus a type checker, so every runtime behaviour, from closures to promises, is still JavaScript. Learn the language first, then add types. You will understand the errors much faster.
If you already write JavaScript, the everyday parts (strict mode, unions, narrowing, basic generics) take a couple of weeks of real use. Comfort with declaration files, React typing and the advanced type features takes a couple of months. Our course suggests 6 weeks for the full twelve chapters.
The basics are not. Most difficulty comes from turning strict mode off, escaping errors with `any`, or jumping to advanced type tricks too early.
Neither requires it, but many teams use it for both because it makes large codebases safer to change.
Yes. The lessons, quizzes, final exam and certificate are all free. You need an account to track your progress and sit the exam.