Question 1

Explain Generics in TypeScript and write a generic utility function.

Accepted Answer

Generics allow components and functions to work with multiple types rather than a single type, creating reusable code that maintains type safety. You pass the type parameter using angle brackets:
```typescript
function getFirstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}
```
This ensures that if you pass an array of numbers, the return type is checked as a number, and if you pass strings, it is treated as a string.

Question 2

What are Type Guards in TypeScript? Write a custom type guard.

Accepted Answer

Type Guards narrow the type of a variable within a conditional block. A custom type guard uses a type predicate (`parameterName is Type`) as its return type:
```typescript
interface User { name: string; email: string }

function isUser(obj: any): obj is User {
  return obj && typeof obj.name === 'string' && typeof obj.email === 'string';
}
```
When called inside an `if` block, TypeScript automatically assumes the variable is a `User` inside that scope.

Question 3

Explain TypeScript Utility Types: Partial, Required, Pick, and Omit.

Accepted Answer

TypeScript includes built-in utility types to transform types: - `Partial` makes all properties of `T` optional. - `Required` makes all properties of `T` required. - `Pick` creates a type by selecting a specific set of keys `K` from `T`. - `Omit` creates a type by removing a specific set of keys `K` from `T`.

Question 4

What is mapped type in TypeScript? Write an example.

Accepted Answer

Mapped types allow you to create new types based on the properties of an existing type, iterating over keys using `keyof`:
```typescript
type ReadOnlyUser<T> = {
  readonly [P in keyof T]: T[P];
};
```
This maps over each key `P` in type `T` and appends the `readonly` flag.

Question 5

Explain index signatures and Record types.

Accepted Answer

Index signatures define type boundaries for objects where key names are unknown: `interface Settings { [key: string]: boolean }`. The `Record` utility is a shortcut for the same pattern: `const config: Record = { debug: true }`.

Question 6

Explain how to test TypeScript components using mock type interfaces.

Accepted Answer

In tests, you assert values against typed mock structures. Use utility types like `DeepPartial<T>` to create incomplete mocks of large interfaces without compiler errors, and check return structures against target signatures.

Question 7

What are index access types and keyof operations?

Accepted Answer

`keyof` extracts a union of keys from an object type: `type UserKeys = keyof User`. Index access types extract the type of a specific property: `type Age = User['age']`, which helps share nested type references.

Question 8

How does TypeScript perform type compatibility checks?

Accepted Answer

TypeScript uses structural typing (duck typing). Two types are compatible if they share the same structure, regardless of nominal declarations. If an object has all properties required by an interface, it is compatible.

Question 9

Explain how to debug TypeScript compilation speeds.

Accepted Answer

To profile slow builds, run compilation with `--diagnostics` or `--generateCpuProfile`. This outputs parser and checker durations, helping locate complex recursive types or excessive import paths.

Question 10

What are conditional types in TypeScript?

Accepted Answer

Conditional types select types based on a condition: `Type extends OtherType ? TrueType : FalseType`. They enable creating dynamic type mappings that resolve based on parameter types.

Question 11

Explain how to configure path aliases in tsconfig.json.

Accepted Answer

Set the `baseUrl` property and specify patterns under `paths`. This maps modules (e.g. `@services/*` to `./src/services/*`), keeping imports clean and independent of relative folder levels.

Question 12

What is the difference between type guard and type assertion?

Accepted Answer

A type guard performs checks at runtime to narrow types inside conditional blocks safely. A type assertion is a compile-time cast that forces the compiler to trust your type, bypassing safety checks.

Question 13

Explain template literal types in TypeScript.

Accepted Answer

Template literal types construct custom types by combining string components using template syntax: `type Event = `on${'Click' | 'Hover'}``. This yields the union `'onClick' | 'onHover'`.

Question 14

What is the readonly array modifier?

Accepted Answer

The `ReadonlyArray<T>` type defines an immutable array. Modifying elements or calling mutator methods (like `push`, `pop`, `reverse`) throws compiler errors, preventing state mutation bugs.

Question 15

How do you define types for third-party JS modules without types?

Accepted Answer

Create a local declaration file (e.g. `declarations.d.ts`) and declare the module: `declare module 'untyped-library';`. This prevents compilation errors and types imports from it as `any`.

Question 16

What is the difference between keyof and typeof?

Accepted Answer

`typeof` extracts a type representation from a JavaScript variable value: `type UserType = typeof userObj`. `keyof` extracts a union of keys from a TypeScript type definition.

Question 17

How do you enforce strict type checking in configurations?

Accepted Answer

Enable `strict: true` in `tsconfig.json`. This turns on checks like `noImplicitAny`, `strictNullChecks`, and `strictFunctionTypes` to guarantee strict type safety.

Question 18

Explain the Parameters and ReturnType utility types.

Accepted Answer

- `Parameters` extracts parameter types from a function type `T` as a tuple. - `ReturnType` extracts the return type of function type `T`, which is useful when mapping async actions.

Question 19

What is compile-time type-safety vs runtime type-safety?

Accepted Answer

TypeScript ensures compile-time safety; types are stripped at compilation and do not exist at runtime. Runtime safety requires executing code validators (like Zod) to check variables.

Question 20

How do you debug TypeScript types using compiler utility options?

Accepted Answer

Use options like `noImplicitReturns` and `noUnusedLocals` in `tsconfig.json` to highlight structural errors and clean up unused code imports automatically during builds.

Question 21

Explain Advanced TypeScript Generics, specifically conditional types and the 'infer' keyword.

Accepted Answer

Conditional types allow you to write type-level logic: `T extends U ? X : Y`. The `infer` keyword can only be used within the extends clause of a conditional type, allowing you to dynamically capture and reference a type parameter from a larger type structure. Here is how you would write a custom utility type to extract the resolved value of a Promise using `infer`: ```typescript type UnpackPromise = T extends Promise ? U : T; type ResolvedString = UnpackPromise>; // Resolves to string ``` This allows architects to build highly dynamic APIs where return types are calculated based on input functions.

Question 22

How do you design type-safe state patterns using discriminated unions?

Accepted Answer

Discriminated unions use a common literal property (like `type` or `status`) to distinguish between types. By checking this shared key, TypeScript automatically narrows the union to the correct type branch inside switch blocks:
```typescript
type NetworkState = 
  | { status: 'loading' }
  | { status: 'success'; data: string }
  | { status: 'error'; error: Error };
```
This prevents accessing `data` when status is `loading`, guaranteeing safety at compile time.

Question 23

Explain how to write recursively mapped types for deep immutability.

Accepted Answer

Standard `Readonly` only locks top-level properties. To make nested properties recursively readonly, write a recursively mapped type: ```typescript type DeepReadonly = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly : T[K]; }; ``` This type checks if a property is an object. If it is, it applies `DeepReadonly` recursively, preventing deep state updates in stores.

Question 24

How do you optimize compiler speeds for large enterprise TypeScript codebases?

Accepted Answer

To speed up compilation in large codebases:
1. Enable project references: Divide code into separate modular packages using `tsconfig.json` project references.
2. Skip type checking: Enable `skipLibCheck` to skip checking `.d.ts` files of dependencies.
3. Avoid complex utility types: Avoid deep recursive mappings. Prefer nominal definitions and explicit interfaces over infinite utility layers.

Question 25

Explain how to write custom decorators in TypeScript and their compiler implications.

Accepted Answer

Decorators are functions that can be attached to classes, methods, or properties to modify their behaviors. They use ES Experimental Decorators or modern TC39 Stage 3 standard specifications. They intercept class creation and method overrides, and require setting `experimentalDecorators: true` in configurations.

Question 26

How do you build custom utility types using template literal type mapping?

Accepted Answer

Template literal types can be mapped dynamically. To transform object keys (e.g. converting `name` to `getName`), combine mapped types with string utilities: ```typescript type GetterName ~~= `get${Capitalize~~}`; type Getters = { [K in keyof T as GetterName]: () => T[K]; }; ```~~~~

Question 27

Explain brand types (nominal typing) and how to implement them.

Accepted Answer

TypeScript typing is structural. If you want nominal typing (e.g. preventing assigning a generic `string` to a `UserId`), implement Brand types using intersection types: ```typescript type Brand = K & { __brand: T }; type UserId = Brand; ``` This prevents runtime mixups by requiring explicit type casts before assignment.

Question 28

How do you type and validate dynamic configurations inside a monorepo?

Accepted Answer

Configure shared configurations inside a central package. Export Zod validation schemas along with TypeScript interfaces, and run Zod validators during server startup to crash if environment variables fail checks.

Question 29

Explain the compiler trade-offs of using declarations (declaration: true).

Accepted Answer

Enabling `declaration: true` generates `.d.ts` files during builds. This allows library consumers to access types, but increases compilation times. To optimize, ensure compiler settings use `composite` and incremental caches.

Question 30

How do you type dynamic event emitters with variable payload signatures?

Accepted Answer

Define event maps as types, and use generics on the emitter class: ```typescript class TypedEmitter> { on(event: K, listener: (payload: T[K]) => void): void; emit(event: K, payload: T[K]): void; } ```

Question 31

How do you debug circular references in TypeScript compilations?

Accepted Answer

Circular module imports increase compiler memory usage and can cause runtime crashes where imports evaluate to `undefined`. Locate them using bundler analysis tools (like `dependency-cruiser` or Webpack circular dependency plugins).

Question 32

What is type-level programming and write an Fibonacci type mapping.

Accepted Answer

Type-level programming involves using TypeScript's type engine (conditional, mapped, and tuple types) to perform computations during compile-time. For example, you can calculate tuple lengths recursively to simulate arithmetic addition.

Question 33

How do you prevent type-narrowing bugs when handling dynamic data?

Accepted Answer

Never cast untrusted data using `as`. Instead, parse incoming payloads using runtime validation libraries (like Zod or Superstruct). This ensures that if the shape changes, validation throws immediately.

Question 34

Explain the architecture of declaration maps (declarationMap: true).

Accepted Answer

Declaration maps link compiled `.d.ts` files back to their original `.ts` source files. Enabling this lets developers Ctrl+Click symbols inside IDEs to jump directly to TS source code rather than compiler types.

Question 35

How do you write a utility type to extract parameters from a nested path?

Accepted Answer

Write a recursive template literal parser: ```typescript type ExtractParams ~~= S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractParams : S extends `${string}:${infer Param}` ? Param : never; ```~~

Question 36

How do you profile memory leaks inside the tsc compiler?

Accepted Answer

TSC compile processes run on V8. Run compiler runs using `node --max-old-space-size=4096 node_modules/typescript/bin/tsc --diagnostics` to trace checker allocation and garbage collection sizes.

Question 37

Explain compiler differences between target configurations (ES5 vs ESNext).

Accepted Answer

The `target` option in `tsconfig.json` dictates how features (like async/await, classes, or generator functions) are transpiled. Targeting ES5 generates helper code that bloats bundles, while ESNext retains modern syntax.

Question 38

How do you write a type-safe dynamic middleware chain loader?

Accepted Answer

Define a middleware type that passes a generic context object. Chain middlewares by intersecting context modifications, returning a single, type-safe request handler with fully merged properties.

Question 39

Explain the difference between namespace and module systems.

Accepted Answer

Namespaces (`namespace MyScope`) are a legacy TS-specific scoping system compiled into global closures. Modules (`import/export`) are the standard modern ES6 system. Modern projects should avoid namespaces.

Question 40

How do you type custom array operations on complex objects?

Accepted Answer

Use generic array extensions and type definitions. Define methods on the global `Array` interface to extend it, and map array generic parameters to filter return types correctly.

Senior TypeScript Interview Questions (5+ Years Experience) (2026)

What is TypeScript and Why is it Critical in Modern Engineering?

TypeScript Lifecycle Visualizer

Core Architectural Concepts in TypeScript

Static Type Checking

Generics & Constraints

Union & Intersection Types

Utility Types (Partial, Pick)

Type Guards & Assertions

check_circleWhy Modern Companies Choose TypeScript

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Architecture