Become the TypeScript Wizard at Your Company

A comprehensive production-grade TypeScript training by Matt Pocock

The feature’s working. The tests are passing.But your IDE is a sea of red lines. TypeScript’s not happy again.

You move on to the next error:

“What on earth is this?”

you think to yourself.

Element implicitly has an ‘any’ type because expression of type ‘string’ can’t be used to index type ‘{ string: string | undefined; }’

No index signature with a parameter of type ‘string’ was found on type ‘{ string: string | undefined; }’

It’s impossible to Google. Every search result is either "here’s 100 lines of complex code" or "here's a solution that doesn't work”

You contemplate the absurd amount of hours you spend solving these problems.

You'd rather give up than deal with another:

The intersection 'User & PublicUser' was reduced to 'never' because property 'email' has conflicting types in some constituents.


Return type of exported function has or is using name 'User' from external module 'sdk' but cannot be named.

Your time is precious. You have bigger fish to fry.

You could spend that time building new features or bugfixes. You could be providing value. Instead, you're fighting TypeScript.

These days, TypeScript is an industry default. If you’re starting an enterprise app today, you’ll need a good reason NOT to use TypeScript.

So you keep on pushing - all the time feeling like you’re working against TypeScript, not with it.

The truth is that you never truly learned TypeScript, at least not in depth. That's the source of your pain.

You never developed a systematic approach to solving type errors.

You never developed a mental model for understanding when to use any.

You never understood the power of generics.


You never learned the underlying principles and patterns of being an effective TypeScript engineer.

You deserve so much better

You deserve a practical, systematic approach to learning TypeScript in depth.

That's why I'm creating Total TypeScript.

It combines everything I've learned leading TypeScript teams and as an OSS maintainer for XState.

This course will be massive. Comprehensive. Total.

We'll start right at ground-level. You won’t need any prior TypeScript knowledge to take this course.

But also, it’s going to be the most advanced TypeScript course on the market. We’ll show you the techniques used by the most complex OSS libraries.

It will turn you into your company's resident TypeScript Wizard:

  • the one that can unblock others and raise their velocity
  • the one that leads large-scale Typescript refactors
  • the one who knows instinctively what TypeScript is doing

You are indispensable.

A systematic approach for learning TypeScript


Getting good at TypeScript is all about understanding the compiler. It can feel like an evil schoolteacher: peering over your code and marking it with squiggly red lines.

But like all good teachers, it’s hard on you because it wants the best for you.

It’s helping you out with autocomplete.

It’s showing you how to use external libraries without needing docs.

And it’s much smarter than you give it credit for.

All you need to learn is:

  • How to use your IDE to get the most out of TypeScript
  • How to read TypeScript’s long error messages
  • How to give TypeScript hints using type annotations


Next, we’ll master debugging with TypeScript. The errors that really hurt come from how your code interacts with external modules.

We’ll learn how to deep-dive node_modules and TypeScript’s own declaration files.

We’ll learn about advanced patterns in external modules, like namespaces, function overloads and interface augmentation.

We’ll learn how to solve type errors at source, not just plastering over them with any.


Now, it’s time to go fast.

We’ll look at techniques for DRY-ing up TypeScript code by:

  • Inferring from runtime code using typeof
  • Building incredible inference using generics
  • Generating TypeScript types from external sources

TypeScript can enable some amazing DX for your team. But learning how to pick the right abstraction can be tough.

We’ll be learning how the builder pattern and functional programming can enable some amazing API’s.

Make TypeScript work for you, not against you

What’s the thing that separates TypeScript wizards from the rest?


To them, TypeScript doesn’t feel like magic. It feels simple, predictable and malleable.

They can bend it to their will, and use its power for amazing DX.

This course is all about building that understanding at a deep level. When you’ve completed Total TypeScript, you’ll reach a point of mastery where very little surprises you any more.

You’ll have less fear when approaching nasty TypeScript errors, more confidence when typing dynamic signatures, gain velocity by cutting lines of code, and so much more.

If that sounds good, consider signing up for exclusive content and early-release workshop offerings below.

Become a TypeScript Wizard

I respect your privacy. Unsubscribe at any time.