Modern TypeScript Patterns

Level: Intermediate to Experienced

As of March 9, 2026 — Applicable to TypeScript 5.x and newer

Prerequisites

This article assumes familiarity with TypeScript basics including types, interfaces, generics, and asynchronous programming. You should have a working knowledge of ES2015+ JavaScript features as TypeScript closely aligns with these standards.

Ensure you are using TypeScript 5.x or later to fully leverage recent language features such as decorator metadata enhancements, symbol key capabilities, and improved template literal types. With the fast evolution of TypeScript, features discussed here mostly come from stable releases.

Hands-on Steps: Patterns to Boost Reliability and Maintainability

1. Discriminated Unions for Exhaustive Type-Safety

Discriminated unions remain a cornerstone for modelling variant types with exhaustive checking. By defining a union of interfaces with a common literal property (the discriminator), TypeScript can narrow types precisely in control flow.


// Define variants with a discriminator key
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rectangle"; width: number; height: number }
  | { kind: "square"; size: number };

// Exhaustive function using never for safe checks
function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rectangle":
      return shape.width * shape.height;
    case "square":
      return shape.size ** 2;
    default:
      // Ensures all cases are handled at compile time
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

When to choose discriminated unions: preferred for finite variant sets where all variants are known at compile time. Versus classes or inheritance for polymorphism in runtime-heavy or OOP styles.

2. Template Literal Types to Encode Domain-Specific Syntax

Introduced in TypeScript 4.1, template literal types allow precise compile-time string pattern checks, useful for enforcing consistent domain-specific formats.


// Define allowed events with dynamic string patterns
type EventName = `on${Capitalize}`;

function addListener(event: EventName, handler: () => void) {
  // ...
}

addListener("onClick", () => console.log("Clicked!")); // ✅
addListener("onclick", () => {}); // ❌ Type error: must start with 'on' and capitalized

When to choose: Use template literal types when you want type-level string pattern validation. Avoid over-complicating simple string enums or union literals.

3. Branded Types for Nominal Typing

TypeScript nominal typing can be simulated via branding to prevent unintentional mix-ups of structurally similar types.


// Brand utility type
type Brand = K & { __brand: T };

// Define distinct ID brands
type UserID = Brand;
type OrderID = Brand;

function createUserId(id: string): UserID {
  return id as UserID;
}

function createOrderId(id: string): OrderID {
  return id as OrderID;
}

function getUserOrders(userId: UserID) {
  // ...
}

// This will error if IDs are mixed
const userId = createUserId("user123");
const orderId = createOrderId("order456");

// getUserOrders(orderId); // ❌ Type error
getUserOrders(userId); // ✅

When to choose branding: Ideal to avoid accidental misuse of primitive types that represent distinct entities, especially where IDs or tokens have the same underlying type.

4. Utility Types with Conditional Types for Flexible APIs

Leverage conditional and mapped types to create highly reusable, adaptable utility types.


// Create a utility type that makes certain keys optional conditionally
type PartialIf = Condition extends true ? Partial : T;

// Example usage
interface User {
  id: number;
  name: string;
  email: string;
}

function saveUser(
  user: PartialIf,
  isNew: C
) {
  if (isNew) {
    // user.id is optional here
  } else {
    // user.id must exist
  }
}

When to choose: Use conditional types for APIs needing compile-time adaptation based on parameterised flags or type literals. Avoid excessive complexity that harms readability.

Common Pitfalls

Overusing advanced types: Complex conditional or template literal types can reduce code clarity and increase maintenance cost.
Ignoring exhaustive checks: Omitting exhaustive switch handling on discriminated unions leads to runtime bugs.
Confusing branding with runtime constructs: Branded types exist only at compile time; do not attempt runtime enforcement without extra logic.
Excessive any or unknown use: Avoid wide use of any which defeats TypeScript’s type safety guarantees.
Mixing structural and nominal typing: Rely on branding or opaque types carefully to avoid subtle type incompatibility.

Validation

Validate your patterns by enabling strict compiler options in tsconfig.json, especially:

strictNullChecks
noImplicitAny
strictBindCallApply
alwaysStrict
strictPropertyInitialization

These settings help catch common mistakes and enforce rigorous typing discipline.

Use the TypeScript Language Service in supported editors (like VS Code) to get immediate feedback on pattern correctness and exhaustiveness.

Checklist / TL;DR

Prefer discriminated unions for clear variant modelling and exhaustive type safety.
Use template literal types to enforce domain-specific string formats at compile time.
Brand primitive types to create nominal type distinctions and prevent ID mix-ups.
Apply conditional and mapped types for adaptive reusable utility types.
Validate with strict TypeScript compiler flags and tooling.
Avoid over-complexity; balance type safety with code readability and maintainability.