For a client's TypeScript repo, Matt Pocock's chapter 14 comes first
Total TypeScript Essentials is free to read online; the similarly named Pro Essentials course, with more than 200 exercises, is the part you pay for.
In brief
- The 16-chapter book is free to read; the paid Pro Essentials course has more than 200 exercises and assumes no prior TypeScript.
- For an FDE, the value lies in the chapters on tsconfig, declaration files and TypeScript's oddities.
- The course's exercises are graded by tests, which builds the feedback loop you need when fixing real code.
Matt Pocock has given almost the same name to two different things. Total TypeScript Essentials is a 16-chapter book, free to read on the Total TypeScript site. The paid course that goes with it is called Pro Essentials: more than 200 exercises, with no prior TypeScript required.
The book also exists in print. No Starch Press published it on April 14, 2026, at 432 pages, written by Matt Pocock with Taylor Bell, and the publisher calls it “a workshop on paper”. The label fits. This is material to work through; skimming it yields little.
For a Forward Deployed Engineer the question is narrower: how much TypeScript is enough to work inside a client’s code? You will inherit repos written by other people, configured according to the client team’s habits, and you will need to fix them within days.
What you need is to read compiler errors quickly, understand where types come from and recognize which problems are caused by configuration. A few chapters of this book answer exactly those questions.
Three chapters to read first
The book’s page describes it as aimed at developers of every level, teaching advanced type manipulation alongside real-world development patterns. The 16 chapters run from setting up the environment to configuring the compiler and designing types. Most of it is groundwork, but three chapters, judging by their titles alone, bear directly on taking over a client’s repo.
Chapter 14, “Configuring TypeScript”, is devoted to configuration: the tsconfig file that decides how strictly the compiler checks and how it resolves modules. That is the skill you need on day one with a client’s repo, before you read a single line of code, so this chapter deserves to come first.
The title “Modules, Scripts, and Declaration Files” signals a chapter on modules and declaration files, the two things you must understand when types come from external packages. “The Weird Parts”, as the name suggests, is where to look up the language’s oddities before concluding that the client team got something wrong.
Take a familiar situation. You receive a client’s repo, run the compiler and see a wall of errors around an internal JavaScript package that ships without types. You open tsconfig and find this:
{
"compilerOptions": {
"strict": true,
"module": "NodeNext",
"moduleResolution": "NodeNext"
}
}
The strict: true line switches on a whole group of strict checks, including noImplicitAny. So when you import that untyped JavaScript package, the compiler raises TS7016: it cannot find a declaration file for the module.
The two NodeNext lines require relative imports in ESM files to spell out the extension, ./utils.js rather than ./utils. Missing extensions add a second batch of module resolution errors that look like code bugs but are rooted in configuration.
The first instinct is usually to fix the code line by line. The better instinct is to read the configuration as above, then write a .d.ts file declaring types for the internal package and add file extensions according to the rules. Very often a single declaration file or one line of configuration clears a whole batch of errors.
When is the paid course worth it?
The product page calls Pro Essentials a complete self-paced workshop of more than 200 exercises, running from beginner to expert. The goal is stated plainly: to turn a good JavaScript developer into a good TypeScript developer, starting with IDE setup. If you have written JavaScript for years while avoiding TypeScript, you are the learner the course has in mind.
The difference lies in the exercise repo on GitHub, total-typescript/pro-essentials-workshop. It encourages active learning and self-directed exploration, and you know you have got it right when the tests pass. The book gives you the concepts; the course makes you type until the compiler and the tests both agree.
That feedback loop mirrors work at a client site. Nobody grades you there; there is only a green or red build and the client team’s tests.
Getting used to the rhythm of edit, run, read the error, edit again on small exercises makes you calmer when facing a large codebase. The course price may have changed since launch, so check the official page before buying.
Three ideas to take to a client site
The first is the order in which to read a repo. The tsconfig tells you how much looseness the client team tolerates, which environment they compile for, and whether the errors you see stem from configuration. Five minutes with this file saves an afternoon of guesswork.
The second is to always ask where a type comes from. When a value carries an odd type, the answer usually lies in a declaration file, in how a module is declared, or in a third-party package. Tracing that chain lets you fix the root cause instead of casting your way past it, a debt the client team would carry after you leave.
The third is to let tests be the referee. The way the course grades exercises reinforces a habit worth keeping: before you fix anything, have a failing check, and work until it passes. For a client, that evidence persuades more than any explanation in a meeting.
The order to read it in
If you are new to TypeScript, read the book from the start in its 16-chapter sequence, then consider the course when you want hands-on practice. If you already write TypeScript daily, jump straight to chapter 14, then the chapter on modules and declaration files, then The Weird Parts; save the type design chapters for when you need to write a shared library.
On the career side, do not just write “proficient in TypeScript” on your CV. Write one specific sentence: which repo you took over, what configuration problem you found, which package you added types for and how many build errors you eliminated.
FDE work revolves around code other people wrote, so you should have an example ready that proves the skill. A pull request like that on an open-source project is something you can attach to an application for the interviewer to open and inspect.
The free book is enough to read a client’s repo with understanding. The paid course earns its price when you need to practice until fixing type errors becomes reflex.
Was this article useful?
Thanks for the feedback!