Every TypeScript project starts with the same questions: why add types to JavaScript, and how do you get the compiler running? This track answers both. You will install TypeScript, run tsc for the first time, and see how it catches mistakes before your code ever executes. You will learn the basic types — string, number, boolean, arrays, and tuples — and how TypeScript's type inference often figures out the type for you without any annotation at all. You will also configure a tsconfig.json file, understanding the key options like strict mode and target that shape how your project behaves. By the end you will have a working TypeScript setup and the core vocabulary to read any typed codebase.

TypeScript's real power shows up once you go beyond basic types. This track covers union types, which let a value be one of several types, and literal types, which pin a value to an exact string or number. You will create type aliases to name and reuse complex types, and practice narrowing — the techniques TypeScript uses to figure out which member of a union you actually have at a given point in your code. You will also learn the crucial differences between any, unknown, and never, and when each one is the right — or dangerous — choice. Finally you will use type assertions to tell the compiler what you know that it does not. By the end you can model precise, real-world data shapes instead of settling for loose, error-prone types.

Functions are where TypeScript pays off every day, and this track makes you fluent in typing them well. You will type parameters and return values, work with optional and default parameters, and use function overloads to describe a function that behaves differently depending on its inputs. Then you will move into generics — the single most powerful tool in the type system — learning to write functions and types that work safely across many different data shapes without losing type information. You will practice generic constraints to limit what a generic type can be, so your code stays both flexible and safe. By the end you can write reusable, typed functions and generic utilities that catch mistakes at compile time instead of at runtime.

Real applications are built from objects, and TypeScript gives you two complementary ways to describe their shape. This track starts with interfaces, the standard way to define what an object should look like, and shows how they differ from type aliases. You will then move into classes, learning constructors, properties, and methods, plus the access modifiers — public, private, and protected — that control what other code can touch. You will practice extends and implements to build class hierarchies and enforce contracts, and see how TypeScript's structural typing means two unrelated types are compatible as long as their shape matches, unlike the nominal typing you may know from other languages. By the end you can model real-world entities with interfaces and classes that are both expressive and safely typed.

This final track takes you from confident TypeScript user to someone who understands the tooling and advanced type features behind the scenes. You will use utility types like Partial, Pick, Omit, and Record to transform existing types instead of rewriting them, then go further with mapped types and conditional types, which let you generate new types programmatically based on other types. You will learn how modules work in TypeScript, including import and export syntax and module resolution, and how declaration files describe the types for plain JavaScript libraries so you get autocomplete and safety even without rewriting them. Finally you will look at the build tooling — the compiler options and pipelines that turn your TypeScript into the JavaScript that ships to production. By the end you can navigate a real TypeScript project's configuration and advanced types with confidence.