Top 40 TypeScript Interview Questions and Answers for 2025

TypeScript has evolved from a niche JavaScript superset into a core language for modern web development. 

In my experience working on web applications, I have seen firsthand how strong typing and maintainability can significantly reduce bugs and improve collaboration across teams. 

TypeScript provides all of this, which is why it has become an industry standard for modern development.

From Microsoft (its creator) to Google, Airbnb, and Netflix, many organizations rely on TypeScript to power products written in frameworks such as React, Angular, and Node.js. 

In my work, I have often seen job postings where TypeScript proficiency is listed as a core requirement, and not an optional skill.

Having used TypeScript myself, it is safe to say that understanding its types, interfaces, and advanced features is essential for any developer preparing for technical interviews.

Basic TypeScript Interview Questions

Let’s now look at some common TypeScript interview questions and how they relate to code safety and clarity.

1. Why use TypeScript over JavaScript?

TypeScript adds static typing and compile-time error checking, which helps developers detect bugs early and make codebases more predictable.

This ensures better maintainability and scalability.

2. What problems does TypeScript solve?

TypeScript addresses JavaScript’s weaknesses in type safety, scalability, and readability.

Enforcing clear type definitions prevents subtle runtime bugs and makes refactoring safer.

3. What are the main benefits of using static typing in TypeScript?

Static typing improves code reliability, auto-completion, and developer productivity.

It helps with early detection of type errors and allows IDEs to provide richer tooling support.

4. What are type annotations and why are they useful?

Type annotations allow developers to declare variable types explicitly.

This improves code readability and reduces runtime errors.

Here is an example:

let username: string = "DataCamper";
let age: number = 25;
let isAdmin: boolean = true;

In the above code, the compiler ensures that only the correct type can be assigned to each variable.

For example, if you try to assign a string to age, TypeScript will throw an error, which helps catch mistakes early.

Explicit typing is especially important for function parameters, return types, and API contracts, as it communicates expectations to other developers.

5. What is type inference in TypeScript?

TypeScript can automatically infer types based on assigned values.

This means you don’t always need to explicitly declare a type. TypeScript figures it out for you.

Here is an example:

let count = 10;  // inferred as number
count = "hello"; // Error: Type 'string' is not assignable to type 'number'

In this example, TypeScript infers that count must be a number based on its initial value, so assigning a string later causes a compile-time error. 

Best practices for type inference include:

• Use explicit types for exported functions, classes, and interfaces to provide clear contracts.
• Allow inference for local variables when the type is obvious.
• Avoid using any unless absolutely necessary, as it bypasses TypeScript’s safety features.

6. How does TypeScript handle arrays, tuples, and enums?

TypeScript allows developers to enforce strict types on arrays, tuples, and enums to improve clarity and prevent runtime errors.

Here is a typed array example:

let scores: number[] = [95, 80, 85];
scores.push(100); // OK
scores.push("A+"); // Error

Typed arrays ensure that all elements in the array follow the same type.

Here is a tuple example:

let user: [string, number] = ["Don", 25];

Tuples define fixed-length arrays with specific types for each position.

They are useful for structured data where the order and type of elements matter.

Here is an enum example:

enum Status {
  Active,
  Inactive,
  Pending,
}
let currentStatus: Status = Status.Active;

Enums provide named constants, improving readability and reducing invalid values.

They are especially useful for status codes, roles, and configuration options.

7. What is the difference between any, unknown, and never types?

The following table highlights the key differences between the any, unknown, and never types in TypeScript.

Here is an example:

function fail(): never {
  throw new Error("Something went wrong");
}

A tip would be to prefer unknown over any to maintain type safety while retaining flexibility.

8. What is the difference between null and undefined in TypeScript?

The key differences between null and undefined are:

• undefined means a variable has been declared but not assigned a value.

• null is an explicit value meaning no value.

TypeScript's strictNullChecks mode treats them as separate types, which prevents accidental null-related bugs.

Here is an example:

let a: string | null = null;
let b: string | undefined = undefined;

9. What does the strict compiler option do?

The strict flag enables all of TypeScript’s strict type-checking rules, such as:

• strictNullChecks: Prevents null and undefined values from being assigned to variables unless explicitly allowed, helping avoid runtime null reference errors.

• noImplicitAny: Requires all variables to have explicit types or inferred types, preventing TypeScript from defaulting to any.

• strictFunctionTypes: Enforces stricter rules for function type compatibility, catching mismatches in function parameter and return types.

• strictBindCallApply: Ensures that the bind, call, and apply methods are used with the correct argument types for functions.

It ensures safer, more predictable code and catches subtle bugs early.

TypeScript Type System Interview Questions

Let’s now look at some key TypeScript type system concepts commonly discussed in technical interviews.

10. What is the difference between interfaces and type aliases in TypeScript?

Both interfaces and type aliases describe the shape of objects, but they serve slightly different purposes.

Interfaces can be extended using extends, which makes them ideal for hierarchical object models.

Type aliases can represent unions, intersections, primitives, and more complex composite types.

Here is an example:

interface Person {
  name: string;
  age: number;
}

type Employee = {
  name: string;
  department: string;
};

Use interfaces when defining object shapes or class contracts.

Use type aliases when you need flexible, composable types like unions or intersections.

11. What are union and intersection types in TypeScript?

Union types allow a variable to hold multiple possible types, while intersection types combine multiple types into one.

Here is a union example:

let id: string | number;
id = ‘abc’; // OK
id = 123; // OK

Here is an intersection example:

type Admin = { name: string };
type Permissions = { canEdit: boolean };
type AdminUser = Admin & Permissions;

Union types are often used in function parameters.

Intersection types are common in complex object compositions.

12. What is type narrowing, and how do type guards work?

Type narrowing lets TypeScript infer a more specific type based on control flow.

Here is an example:

function printId(id: string | number) {
  if (typeof id === "string") {
    console.log(id.toUpperCase());
  } else {
    console.log(id.toFixed());
  }
}

Type guards ensure safe runtime operations by verifying the type before performing specific actions.

You can use:

• typeof: for primitives

• instanceof: for classes

• Custom type guards: using the param is Type syntax

Type guards improve type safety and reduce runtime errors.

13. What are literal types and discriminated unions in TypeScript?

Literal types restrict a variable to a specific set of predefined values.

Here is an example:

let direction: "up" | "down" | "left" | "right";

Discriminated unions combine literal types with object variants for pattern matching.

Here is an example:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  if (shape.kind === "circle") return Math.PI * shape.radius ** 2;
  return shape.side ** 2;
}

Discriminated unions allow safe branching on object types and simplify logic in complex applications.

14. What are keyof, typeof, and in in TypeScript?

These operators provide powerful type-level reflection.

• Keyof: gets the property names of a type

• typeof: gets the type of a value

• in: used in mapped types

Here is an example:

type Keys = keyof User; // "name" | "age"
const person = { name: "Alice", age: 25 };
type PersonType = typeof person; // { name: string; age: number }

15. What are index signatures in TypeScript?

Index signatures allow objects with dynamic keys.

Here is an example:

interface Errors {
  [key: string]: string;
}

const messages: Errors = {
  email: "Invalid email",
  password: "Required"
};

These are used for dictionaries, map-like objects, or dynamic configuration patterns.

16. What is structural typing in TypeScript?

Structural typing (duck typing) means types are compatible based on their structure, not their name.

Here is an example:

interface Point { x: number; y: number; }
let p = { x: 10, y: 20, z: 30 };
let q: Point = p; // OK because structural match

This makes TypeScript flexible and works well with JavaScript patterns.

17. What is declaration merging in TypeScript?

Declaration merging happens when TypeScript combines multiple declarations with the same name.

Here is an example merging two interfaces:

interface User { name: string; }
interface User { age: number; }
const u: User = { name: "Rob", age: 30 }; // merged

This is useful when extending third-party types or augmenting libraries.

Advanced TypeScript Interview Questions

Here are advanced TypeScript interview questions and answers.

18. What are generics in TypeScript, and why are they useful?

Generics allow you to write reusable, type-safe functions and classes that work with multiple data types.

Here is a generic function example:

function identity<T>(value: T): T {
  return value;
}

let output = identity<string>("DataCamp");
let outputNumber = identity<number>(42);

Here is a generic class example:

class Box<T> {
  content: T;
  constructor(content: T) {
    this.content = content;
  }
  getContent(): T {
    return this.content;
  }
}

let stringBox = new Box("Hello");
let numberBox = new Box(123);

Best practices include:

• Use descriptive names like <T>, <K, V>, or domain-specific names.

• Avoid unnecessary complexity.

• Use constraints (extends) to restrict acceptable types.

Generics improve code reusability by reducing duplication and enforcing consistent typing.

19. What are TypeScript utility types, and how are they used?

TypeScript provides built-in utility types to manipulate and transform existing types efficiently.

Here is an example:

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type PartialTodo = Partial<Todo>; // all properties optional
type RequiredTodo = Required<Todo>; // all properties required
type TodoPreview = Pick<Todo, "title" | "completed">; // select specific properties
type TodoWithoutDescription = Omit<Todo, "description">; // exclude properties

These are especially useful when working with API responses, forms, or component props.

A tip would be to leverage utility types whenever possible to simplify code and enforce type consistency.

20. What are conditional and mapped types in TypeScript?

Conditional types let you define logic within types based on relationships between them.

Here is an example:

type IsString<T> = T extends string ? "yes" : "no";
type Result1 = IsString<string>; // "yes"
type Result2 = IsString<number>; // "no"

Mapped types allow you to transform all properties of a type at once.

Here is an example:

type ReadonlyTodo = {
  readonly [K in keyof Todo]: Todo[K];
};

type OptionalTodo = {
  [K in keyof Todo]?: Todo[K];
};

The key differences are:

• keyof extracts the property names of a type.
• typeof gets the type of a variable or object. Combining them allows dynamic type manipulation and safer refactoring.

21. What is the infer keyword used for in TypeScript?

infer lets you extract (infer) a type inside a conditional type.

Here is an example:

type ReturnType<T> =
  T extends (...args: any[]) => infer R ? R : never;

type R = ReturnType<() => number>; // number

Often used in advanced utilities and generic type transformations.

22. What are template literal types?

Template literal types construct string types using interpolation.

Here is an example:

type Event = ${string}Changed;
let e: Event = "nameChanged"; // OK

This is useful for:

• Event naming
• CSS class patterns
• API route patterns

23. What are satisfies and as const in TypeScript?

satisfies ensures a value satisfies a type but preserves its own literal type. 

For example:

const config = {
  mode: "dark",
  version: 1
} satisfies { mode: string; version: number };

as const makes all properties read-only and literal. 

For example:

const directions = ["up", "down"] as const;
// type is readonly ["up", "down"]

Both satisfies and as const are useful in React, config objects, and discriminated unions.

TypeScript Functions and Objects Interview Questions

In this section, we will explore TypeScript interview questions related to functions and objects.

24. How does function overloading work in TypeScript?

Function overloading allows you to define multiple function signatures for different argument types or patterns.

Here is an example:

function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any): any {
  return a + b;
}

let sumNumbers = add(5, 10); // 15
let sumStrings = add("Hello, ", "World"); // "Hello, World"

Best practices include:

• Declare all possible overloads before the implementation.
• Use type guards to handle multiple types safely.

25. What are optional and rest parameters in TypeScript?

Optional and rest parameters make functions more flexible and expressive.

Here is an example:

function greet(name: string, age?: number) {
  console.log(Hello ${name}, age: ${age ?? "unknown"});
}

function sum(...numbers: number[]) {
  return numbers.reduce((a, b) => a + b, 0);
}

The key rules for using optional and rest parameters are:

• Use ? for optional parameters.

• Use ... for rest parameters (variadic arguments).

These are often tested in interviews to evaluate how well you handle dynamic function inputs.

26. What is the difference between readonly and const in TypeScript?

const applies to variables, while readonly applies to object properties.

Here is an example:

interface User {
  readonly id: number;
  name: string;
}

const user: User = { id: 1, name: "Bob" };
// user.id = 2; // Error: Cannot assign to 'id'

const { id, name } = user;
console.log(User ${name} has ID ${id});

Some best practices for using readonly and const are:

• Use readonly for objects that should not be changed, such as data returned from an API.
• Use const for variables that should not be reassigned.
• Combine destructuring with type annotations for cleaner, self-documenting code.

27. What is function type variance (covariance and contravariance)?

Function type variance describes how TypeScript decides if one function type can safely replace another, based on its parameter types and return types.

Return types: Covariant

A function is allowed to return a more specific type than what the caller expects. For example:

type Animal = { name: string };
type Dog = Animal & { bark: () => void };

let f: () => Animal;
let g: () => Dog = () => ({ name: "Rex", bark() {} });

f = g; // OK: Dog is a subtype of Animal

Parameter types: Contravariant

A function is allowed to accept more general parameter types than expected. For example:

type Dog = { name: string; bark: () => void };
type Animal = { name: string };

type HandleDog = (dog: Dog) => void;
type HandleAnimal = (animal: Animal) => void;

let handleDog: HandleDog = d => console.log(d.bark());
let handleAnimal: HandleAnimal = a => console.log(a.name);

// A function that accepts an Animal is more general,
// so it can stand in for one that accepts a Dog
handleDog = handleAnimal; // OK

28. What are this types in TypeScript?

this types let methods return the same type as the class, useful for fluent APIs:

class Builder {
  setName(name: string): this {
    // ...
    return this;
  }
}
new Builder().setName("Test"); // chaining works

TypeScript OOP Interview Questions

The following questions cover key TypeScript OOP concepts frequently discussed in technical interviews.

29. How does TypeScript support object-oriented programming (OOP)?

TypeScript supports OOP principles such as classes, inheritance, and access modifiers.

Classes define reusable blueprints for objects, and inheritance allows one class to extend another to share properties and behaviors.

Here is an example:

class Animal {
  constructor(public name: string) {}

  move(distance: number) {
    console.log(${this.name} moved ${distance}m.);
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof!");
  }
}

const dog = new Dog("Buddy");
dog.bark();       // Woof!
dog.move(10);     // Buddy moved 10m.

Access modifiers include:

• public: accessible anywhere
• protected: accessible in the class and its subclasses
• private: accessible only within the declaring class

A tip would be to use access modifiers to ensure encapsulation, which prevents unintended modification of internal class logic or state.

30. What is the difference between abstract classes and interfaces in TypeScript?

Both abstract classes and interfaces define contracts for objects or classes, but they serve different purposes.

Abstract classes can include shared implementation and abstract methods.

Interfaces only describe structure, not implementation.

Here is an example:

abstract class Shape {
  abstract getArea(): number; // must be implemented
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

Best practices include:

• Use abstract classes when you need shared logic across related classes.
• Use interfaces for flexible type contracts and decoupled code design.

31. What is the difference between private, protected, and public modifiers?

Here is a comparison of TypeScript’s access modifiers and what they control:

Using the correct access modifier promotes encapsulation, which ensures that internal state and logic cannot be accessed or changed unexpectedly.

32. What is the difference between implements and extends?

extends inherits behavior and properties, whereas implements enforces a contract but does not provide implementation

Here is an example:

interface Logger { log(msg: string): void; }

class Base { foo() {} }

class MyClass extends Base implements Logger {
  log(msg: string) {}
}

33. How do mixins work in TypeScript?

Mixins allow multiple reusable class components.

Here is an example:

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
  };
}

class User {}
const TimestampedUser = Timestamped(User);

Useful when you need multiple inheritance patterns.

Practical TypeScript Interview Questions

These questions focus on real-world applications of TypeScript that often come up in interviews.

34. How would you migrate a JavaScript project to TypeScript?

Migrating a legacy JavaScript codebase to TypeScript should be incremental to minimize risk and disruption.

The recommended approach is:

1. Rename .js files to .ts.

2. Enable allowJs and checkJs in tsconfig.json.

3. Gradually add types, starting with core functions or modules.

4. Use any temporarily, then replace it with proper types as you refine the codebase.

Example tsconfig.json for gradual migration:

{
  "compilerOptions": {
    "allowJs": true,
    "checkJs": true,
    "strict": true
  }
}

Gradual migration ensures stability and allows teams to benefit from type checking early without major rewrites.

35. How do you use TypeScript with React?

Using TypeScript in React improves type safety for props and state, which helps prevent runtime errors.

Here is an example:

interface Props {
  title: string;
}

const Header: React.FC<Props> = ({ title }) => <h1>{title}</h1>;

Defining prop types helps TypeScript catch missing or incorrectly typed props at compile time, which improves reliability and developer productivity.

36. How do you use TypeScript with Node.js?

TypeScript enhances Node.js applications by adding type safety for API routes, configurations, and middleware.

Here is an example:

import express, { Request, Response } from "express";
const app = express();

app.get("/", (req: Request, res: Response) => res.send("Hello TypeScript"));

Typing Request and Response ensures correct parameter usage and prevents common runtime errors.

TypeScript makes Node.js APIs easier to maintain and refactor safely.

37. How do you handle third-party JavaScript libraries that lack TypeScript definitions?

Some libraries don’t include built-in types. In these cases, you have two main options:

Option 1: Install community-maintained types

npm install --save-dev @types/library-name

Option 2: Create a custom declaration file

// custom.d.ts
declare module "legacy-library" {
  export function init(): void;
}

Tips include:

• Always check @types before writing custom declarations.

• Gradually add types for complex libraries to ensure compatibility.

Proper typing of third-party libraries increases confidence and reduces runtime bugs.

TypeScript Configuration and Tooling Interview Questions

This section covers essential TypeScript configuration and tooling topics frequently discussed in technical interviews.

38. What is tsconfig.json, and why is it important?

The tsconfig.json file is the central configuration for any TypeScript project. 

It defines compiler behavior, includes files, and enables features.

Here is an example:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  },
  "include": ["src"],
  "exclude": ["node_modules", "dist"]
}

Key settings include:

• target: JavaScript version for output

• module: Module system (CommonJS, ESNext, etc.)

• strict: Enables all strict type-checking options

• outDir: Output folder for compiled code

• esModuleInterop: Allows CommonJS module imports

Make sure you enable strict mode to catch potential bugs early and improve maintainability.

39. How do you configure TypeScript with build tools like Webpack, Vite, or Babel?

TypeScript integrates seamlessly with modern build systems.

Common setups include:

• Webpack: ts-loader for on-the-fly compilation

• Vite: vite-plugin-ts for fast builds

• Babel: @babel/preset-typescript for JS-heavy environments

Example Vite configuration:

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import tsconfigPaths from "vite-tsconfig-paths";

export default defineConfig({
  plugins: [react(), tsconfigPaths()],
  build: {
    target: "es2020"
  }
});

Align compiler and bundler settings, enable incremental builds, and use source maps for easier debugging.

40. How do you configure ESLint with TypeScript for better code quality?

ESLint helps maintain consistent coding standards and catch errors early.

Install required packages:

npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-dev

Example ESLint configuration:

{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "rules": {
    "@typescript-eslint/no-explicit-any": "warn",
    "@typescript-eslint/explicit-function-return-type": "off"
  }
}

Tips include:

• Avoid disabling rules globally.
• Fine-tune rules per project to balance type safety and flexibility.
• Use ESLint with Prettier for a consistent and clean codebase.

Tips for Acing Your TypeScript Interview

Before your interview, you should focus on mastering both your technical skills and communication skills.

Here are some of the ways in which you can do so:

Study approach:

• Review official documentation on advanced types, generics, and utility types.
• Focus on real-world use cases rather than memorization.
• Practice reading and understanding type errors, especially since TypeScript compiler messages are often part of technical assessments.

Practice projects:

• Build small but complete apps to demonstrate practical skills:
• React To-Do List with typed props and state.
• Express REST API with typed request and response objects.
• Utility libraries using generics and mapped types.

Common pitfalls:

• Overusing any, which undermines TypeScript’s type safety.
• Neglecting strict mode, which leads to runtime bugs.
• Confusing null and undefined in type definitions.
• Forgetting to install or configure type definitions for third-party libraries.

Communication tips:

• During interviews, clearly explain your reasoning for type decisions.
• Describe trade-offs between approaches (for instance: interface vs type alias or abstract class vs interface).
• Show how TypeScript improves maintainability and scalability in projects.

Conclusion

TypeScript continues to dominate modern web development because it enforces clear, consistent data types that help prevent bugs and improve scalability for large projects.

To keep learning, explore our full catalog of courses to continue expanding your knowledge across different technologies.