What is the difference between a type and an interface in TypeScript?

Both define object shapes, but they differ in key ways. Interfaces can be extended with declaration merging — if you declare the same interface twice, TypeScript merges them. Types cannot be merged this way. Interfaces use extends for inheritance, while types use intersection (&). Types are more powerful for computed and conditional shapes (union types, mapped types, conditional types). In practice: use interfaces for public API contracts and class shapes (they produce cleaner error messages), and use types for computed types, unions, and aliases. The choice is largely a matter of team convention for straightforward object shapes.

What is the infer keyword in TypeScript and when do I use it?

The infer keyword extracts a type variable from within a conditional type. It tells TypeScript: "match this pattern, and whatever type is here — capture it as a variable." The most common use is extracting return types, promise resolutions, or array element types: type ReturnType = F extends (...args: any[]) => infer R ? R : never. Here, if F is a function, R captures its return type. Without infer, you cannot express "the type that goes here." It is only valid inside the extends clause of a conditional type.

What are discriminated unions and why are they better than optional properties?

A discriminated union uses a shared literal property (the discriminant, typically "type" or "status") to distinguish between variants. Each variant has a different literal value for the discriminant, allowing TypeScript to narrow the type in switch statements. This is superior to optional properties because it makes invalid states unrepresentable: with discriminated unions, you cannot have a "success" state with an error field, or a "loading" state with data. Optional properties (status?: string, data?: T, error?: string) allow any combination and force you to handle null/undefined for every field in every code path. Discriminated unions encode the business logic directly in the type system.

When should I use keyof and typeof in TypeScript?

keyof T produces a union of string literal types representing all keys of type T: keyof { id: number; name: string } is "id" | "name". typeof expr captures the type of a runtime value at compile time. Combined, keyof typeof obj gives you the keys of an object literal. Common uses: (1) type-safe property access: function get (obj: T, key: K): T[K]; (2) deriving types from constants: const ROLES = ["admin", "user"] as const; type Role = typeof ROLES[number]; (3) building enum-like patterns from plain objects instead of enums, which have better tree-shaking and work with const assertions.

What is a branded type and why would I use one?

A branded type adds a phantom type property to a primitive to make it structurally distinct from other primitives of the same underlying type. For example: type UserId = string & { readonly _brand: "UserId" }; type OrderId = string & { readonly _brand: "OrderId" }. Now TypeScript prevents you from accidentally passing an OrderId where a UserId is expected, even though both are just strings at runtime. Branded types are useful for: IDs (preventing mixing different entity IDs), validated inputs (a ValidatedEmail type that only comes from a validation function), units (preventing mixing meters and feet). Create them with a cast function: function asUserId(id: string): UserId { return id as UserId }.

Engineering·8 min read·June 21, 2026

🔷 TypeScript Advanced Patterns for Engineers

Master TypeScript's most powerful type-level features: generic constraints, conditional types, mapped types, template literal types, discriminated unions, and utility types — with real production code examples for each pattern.

📖Full-Stack SaaS with Next.js, Supabase & Groq AI (Full Access)

View →

Why Advanced TypeScript Pays Off

TypeScript's basic types — string, number, boolean, interfaces — eliminate most runtime type errors. But the advanced type system allows you to encode business logic at the type level: making invalid states unrepresentable, auto-completing API shapes, and catching contract violations at compile time rather than in production logs. This guide covers the patterns that distinguish TypeScript power users from beginners.

Topics covered

TypeScript advanced patternsTypeScript genericsconditional types TypeScriptmapped types TypeScripttemplate literal typesdiscriminated unions TypeScriptTypeScript utility typesinfer keyword TypeScriptTypeScript type guardsTypeScript keyof typeofTypeScript satisfies operatorTypeScript const assertionTypeScript record typeTypeScript extract excludeTypeScript ReturnTypeTypeScript engineering patternsnarrowing TypeScriptTypeScript branded types