TypeScript Interview Questions

What should you focus on for a TypeScript interview?

Which questions should you start with?

Start with type aliases versus interfaces, the most asked question in these interviews. It appeared in 10 of 45 interviews. Next came what TypeScript adds to JavaScript, followed by the problems generics solve.

Use these questions to check your answers:

• Can you explain what TypeScript adds to JavaScript and name errors it can catch?
• Can you show a generic function and explain the problem it solves?
• Can you compare var, let, and const, including scope and hoisting?

Look beyond individual questions, too. Unions and narrowing was the most common topic, appearing in 13 of 45 interviews. Can you explain how any, unknown, and never differ? Can you show how a type guard narrows a value?

What did reviewed answers leave out?

For type aliases versus interfaces, 3 of 6 reviewed answers missed a practical rule for choosing between them. The missing point was using interfaces for object contracts you need to extend, and type aliases for unions and other type expressions.

Check that your answer covers both the difference and the choice:

• Can you name an object contract you would define with an interface and explain how you would extend it?
• Can you show a union you would define with a type alias?
• Can you explain why you chose each approach?

What code should you be ready to write?

A coding task appeared in 9 of 45 interviews. Using a union type in a function was the most common task listed.

Try these checks before reading an answer:

• Can you write a function that uses a union type?
• Can you add an item to an array?
• Can you handle null in a TypeScript feature flag?
• Can you type React button props so link mode and button mode are mutually exclusive?

Which applied topics should you review?

For React, check whether you can type component props, state, reducers, and refs. For a polymorphic component, can you support an as prop with the correct props and refs?

For API work, can you validate external data and handle a nullable response? For backend work, can you limit concurrent work and define types for batch results?

For code quality, can you explain how you would replace any with appropriate types? Include how you would prevent any from returning across the project, not just how you would remove it.

Who gets asked TypeScript

The 20 most asked TypeScript questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. What is the difference between type aliases and interfaces in TypeScript, and when would you use each?

   Asked in 10 of 45 interviews · last asked Oct 8 · Concept · Mid-level

   Show answer

   Interfaces describe object shapes and support declaration merging. Type aliases can name any type, including objects, unions, and tuples. I prefer interfaces for extensible object contracts and type aliases for unions, such as component props with distinct variants.

   • Both can describe component props and function signatures.
   • Interfaces with the same name in the same scope merge; type aliases cannot be redeclared.
   • Interfaces extend compatible object types; type aliases can combine types using intersections.
   • Use a union type alias when different component variants require different props.

   What the interviewer checks: The interviewer is checking whether you understand the differences and can choose based on the contract you need.

   Common mistake (in 3 of 6 reviewed answers): Many answers forget that interfaces suit extensible object contracts, while type aliases suit unions and other type expressions.

   Other ways it was asked

   • “What is an interface in TypeScript?”
   • “In TypeScript, what's the difference between type and interface, and when would you prefer one over the other in a UI component code base?”
   • “In TypeScript, what's the difference between type and interface, and when do you prefer one over the other?”

2. What does TypeScript add to JavaScript, what benefits does it provide, and what errors can it catch?

   Asked in 7 of 45 interviews · last asked Aug 25 · Concept · Junior

   Show answer

   TypeScript adds static type checking to JavaScript, with features like type annotations, interfaces, and generics. It catches many mistakes before code runs, such as wrong argument types, missing properties, and unsafe null access when strict null checks are enabled. It improves editor suggestions, navigation, and refactoring. Types are removed when compiling to JavaScript, so they do not validate runtime data.

   • Type inference checks many values without explicit type annotations.
   • Static checks catch type mismatches, but not every logic error or runtime failure.
   • Strict settings catch more mistakes; any bypasses type checking.
   • External data still needs runtime validation.

   What the interviewer checks: The interviewer checks whether you understand static typing, tooling benefits, and the limits of compile-time checks.

   Other ways it was asked

   • “Why use TypeScript, and what benefits does it offer?”
   • “Can you explain why TypeScript is useful and what tooling it adds?”
   • “What does TypeScript add on top of JavaScript, and what tooling benefits does it provide?”

3. What problems do TypeScript generics solve, and can you show an example of a generic function?

   Asked in 6 of 45 interviews · last asked Oct 7 · Concept · Junior

   Show answer

   TypeScript generics let you reuse code with different types while keeping type checks. A type parameter, such as T, connects types across inputs and outputs. This avoids writing separate functions for each type or using any, which loses type safety.

   • Generics preserve type information instead of replacing it with any.
   • TypeScript can often infer type arguments from the values you pass.
   • Use extends to limit which types a generic accepts.

   CodeCopy

   function identity<T>(value: T): T {
     return value;
   }
   
   const count = identity(42); // inferred as literal type 42
   const label = identity<string>("hello"); // explicit string type

   What the interviewer checks: The interviewer checks whether you can write reusable code that preserves relationships between types.

   Other ways it was asked

   • “What are generic types in TypeScript, and what is your understanding of them?”
   • “How do you use generics in TypeScript?”
   • “What are generics in TypeScript, why are they useful, and can you give an example?”

4. How do any, unknown, and never differ in TypeScript?

   Asked in 4 of 45 interviews · last asked Oct 7 · Concept · Mid-level

   Show answer

   any turns off type checking for a value. unknown accepts any value, but you must narrow its type or use a type assertion before type-specific operations. never represents values that cannot exist, such as the return value of a function that always throws.

   • Prefer unknown for untrusted input; check its type before using it.
   • any lets unsafe operations pass type checking and can hide bugs.
   • never supports exhaustive checks and describes functions that cannot return normally.
   • Unlike never, void means a function returns no useful value.

   What the interviewer checks: The interviewer checks whether you understand type safety, narrowing, and impossible values.

   Other ways it was asked

   • “What is the difference between the any and unknown types in TypeScript?”
   • “What is the difference between any and unknown in TypeScript?”
   • “What is the difference between `any`, `unknown`, and `never` in TypeScript?”

5. How do var, let, and const differ in TypeScript, including their scope and hoisting?

   Asked in 3 of 45 interviews · last asked Oct 8 · Concept · Junior

   Show answer

   `var` has function scope, or module/global scope at the top level. `let` and `const` have block scope; only `let` allows reassignment. `var` is hoisted and initialized to `undefined`. `let` and `const` are hoisted but stay uninitialized until their declaration runs; earlier access throws a `ReferenceError` because of the temporal dead zone.

   • `var` allows redeclaration; `let` and `const` cannot be redeclared in the same scope.
   • `const` prevents reassignment, but object properties and array contents can still change.
   • A normal `const` declaration requires an initializer.
   • TypeScript follows JavaScript’s scope and hoisting rules for these keywords.

   What the interviewer checks: The interviewer checks whether you understand scope, reassignment, and what happens when variables are accessed before declaration.

   Other ways it was asked

   • “What variable declaration types are available in JavaScript?”
   • “What variable declaration keywords are available in JavaScript and TypeScript, and how do they differ?”
   • “How does `var` work in TypeScript?”

6. What is type narrowing in TypeScript, and how do type guards help?

   Asked in 3 of 45 interviews · last asked Oct 6 · Concept · Mid-level

   Show answer

   Type narrowing means TypeScript uses checks and control flow to work out a more specific type. Type guards are checks, such as `typeof` or `instanceof`, that help it narrow a type. They let you safely use properties or methods that only some possible types support.

   • Common guards use typeof, instanceof, in, or checks against a specific value.
   • Custom guard functions can return a type predicate, such as value is string.
   • A custom guard must actually check what its type predicate claims.
   • Narrowing changes the compiler’s view of a value, not the value itself.

   CodeCopy

   function isString(value: unknown): value is string {
     return typeof value === "string";
   }
   
   function format(value: string | number): string {
     if (isString(value)) return value.toUpperCase();
     return value.toFixed(2);
   }

   What the interviewer checks: The interviewer is checking whether you can safely handle union or unknown types using checks rather than type assertions.

   Other ways it was asked

   • “What are type guards in TypeScript, and when would you use them?”
   • “How would you write a type guard in TypeScript?”
   • “What are type guards?”

7. What is a union type in TypeScript, and how would you use one in a function?

   Asked in 3 of 45 interviews · last asked Oct 7 · Write code · Junior

   Show answer

   A union type lets a value be one of several types, written with `|`. A function can use a union parameter to accept different input types. Inside the function, use checks such as `typeof` to narrow the type before calling type-specific methods.

   • Use `|` to combine types, such as `string | number`.
   • Before narrowing, only operations valid for every member of the union are allowed.
   • Type checks let TypeScript identify which type is safe to use.

   CodeCopy

   function format(value: string | number): string {
     if (typeof value === "number") {
       return value.toFixed(2);
     }
     return value.trim();
   }
   
   format(12.5);       // "12.50"
   format(" hello "); // "hello"

   What the interviewer checks: The interviewer is checking whether you can accept multiple types and handle them safely using type narrowing.

   Other ways it was asked

   • “What is the name of a TypeScript type that allows a variable to have more than one type?”
   • “Can you give an example of using union types in TypeScript in a function?”
   • “What is a union type?”

8. How would you type a polymorphic React component with an as prop and correct props and refs?

   Asked in 2 of 45 interviews · last asked Jul 19 · Concept · Senior

   Show answer

   I use a generic element type, then combine its props with the component’s own props. ComponentPropsWithRef includes the matching ref type. In React 19, I pass ref through as a prop. In React 18, I use forwardRef and give the exported component a generic call signature to preserve inference.

   • Use React.ElementType for the generic constraint, with a default matching the default rendered element.
   • Omit overlapping keys from inherited props so the component’s own props take priority.
   • React.ComponentRef or React.ElementRef can infer the ref instance type.
   • Custom components must accept and pass refs correctly; types alone cannot guarantee this.

   CodeCopy

   // React 19, TypeScript with JSX
   import * as React from "react";
   type Props<C extends React.ElementType = "button"> =
     { as?: C } & Omit<React.ComponentPropsWithRef<C>, "as">;
   function Box<C extends React.ElementType = "button">({ as, ...props }: Props<C>) {
     const Tag: React.ElementType = as ?? "button";
     return React.createElement(Tag, props);
   }
   const linkRef = React.createRef<HTMLAnchorElement>();
   const link = <Box as="a" href="/" ref={linkRef} />;

   What the interviewer checks: The interviewer checks whether the chosen element controls allowed props and ref types without losing generic inference.

   Other ways it was asked

   • “How would you type a reusable React component with an as prop so that when as is an anchor you get anchor props, and when as is a button you get button props, including correct ref types?”
   • “How would you model a polymorphic React component in TypeScript?”
   • “In a polymorphic React component typed with TypeScript, how do you ensure the ref type matches each rendered element, and which type utilities can infer the instance type?”

9. What are decorators in Angular?

   Asked in 2 of 45 interviews · last asked Oct 15 · Concept · Junior

   Show answer

   Decorators in Angular are functions that add metadata to classes, properties, methods, or parameters. Angular uses this metadata to understand how to handle them. For example, @Component defines a component and its settings, while @Injectable marks a class for dependency injection.

   • @Component provides settings such as a component’s selector and template.
   • @Input and @Output define how a component receives data and sends events.
   • @Directive defines a directive; @Pipe defines a template value transformation.
   • @NgModule defines an Angular module; standalone components do not need an NgModule declaration.

   What the interviewer checks: The interviewer checks whether you understand decorator metadata and can name common Angular decorators and their purposes.

   Other ways it was asked

   • “What is a decorator in Angular?”
   • “What are some examples of decorators in Angular?”
   • “What are some other examples of decorators in Angular?”

10. How would you replace any with appropriate types and prevent its reintroduction across a TypeScript project?

    Asked in 2 of 45 interviews · last asked Oct 14 · Scenario · Senior

    Show answer

    I would review each `any` and replace it with a specific type, a union, or a generic that preserves type relationships. For untrusted data, I would use `unknown` and validate it before use. I would enable strict TypeScript checks and ESLint rules, then run both in CI to catch new problems.

    • Enable `strict`; its `noImplicitAny` check catches implicit `any` errors but does not ban explicit `any`.
    • Use `@typescript-eslint/no-explicit-any` to ban explicit `any`, and type-aware `no-unsafe-*` rules to catch unsafe uses.
    • Narrow `unknown` with type guards or runtime validation; do not hide problems with type assertions.
    • Fix types at their source, including dependency declarations; document and limit unavoidable exceptions.

    What the interviewer checks: The interviewer is checking whether you can improve type safety and enforce it across the project.

    Other ways it was asked

    • “If you wanted to eliminate `any` throughout a project, how would you approach it and add rules so your team avoids using `any` in the codebase?”
    • “How would you replace any types with appropriate TypeScript types?”

11. Do you have a favorite feature in TypeScript that you miss when you switch to another language?

    Asked once · last asked Apr 23 · Concept · Mid-level

    Show answer

    My favorite feature is discriminated unions. TypeScript uses a shared field, such as `kind`, to narrow a union and check which properties I can access. I miss this when another language needs more manual checks, though some languages have similar features.

    • Each union member has a different literal value for the shared field.
    • Checking that field narrows the type without a type assertion.
    • A `never` check can catch missing cases when new union members are added.

    What the interviewer checks: The interviewer wants to see whether you can explain a feature you value and its practical benefits.

12. If you have an array of items and want to add one more item, how would you do it in JavaScript or TypeScript?

    Asked once · last asked Aug 25 · Write code · Junior

    Show answer

    Use `items.push(newItem)` to add an item to the end of the existing array. To create a new array without changing the original, use `[...items, newItem]`. In TypeScript, `push` requires an item allowed by the array’s element type.

    • `push` changes the original array and returns its new length.
    • Spread creates a new array and leaves the original unchanged.
    • TypeScript checks that the pushed item has an allowed type.

    JavaScriptCopy

    const items = [1, 2];
    items.push(3); // items is now [1, 2, 3]
    const newItems = [...items, 4]; // [1, 2, 3, 4]
    // items is still [1, 2, 3]

    What the interviewer checks: The interviewer is checking whether you can add an item and distinguish changing an array from creating a new one.

13. What are the two TypeScript types that are not represented in JavaScript?

    Asked once · last asked Aug 25 · Concept · Mid-level

    Show answer

    The usual answer is tuples and enums. A tuple describes an array with known types at specific positions. An enum defines named constants. Tuple types are removed during compilation, while regular enums generate JavaScript code.

    • JavaScript has arrays, but no built-in tuple type syntax.
    • Regular enums create runtime values; const enums are usually inlined.
    • TypeScript has other type features too, so “two” is not a strict total.

    What the interviewer checks: The interviewer is checking whether you understand tuples, enums, and how they become JavaScript.

14. What happens when you try to access a property on null in TypeScript?

    Asked once · last asked Sep 1 · Concept · Junior

    Show answer

    Accessing a property on null throws a TypeError at runtime. With strictNullChecks enabled, TypeScript reports a compile-time error if the value may be null. Check for null first, or use optional chaining, which returns undefined when the value is null.

    • TypeScript types do not add runtime null checks.
    • strictNullChecks helps catch unsafe property access before running the code.
    • Optional chaining safely handles both null and undefined.
    • A non-null assertion (!) removes a type warning but does not prevent a runtime error.

    What the interviewer checks: The interviewer is checking whether you distinguish compile-time null checks from runtime behavior.

15. What data types are available in JavaScript and TypeScript?

    Asked once · last asked Oct 8 · Concept · Junior

    Show answer

    JavaScript has seven primitive types: string, number, bigint, boolean, symbol, undefined, and null. It also has objects, including arrays and functions. TypeScript supports these and adds static types such as any, unknown, never, void, tuples, unions, and intersections. TypeScript type annotations are removed during compilation.

    • Despite typeof null returning "object", null is a primitive value.
    • Interfaces and type aliases let you describe custom types.
    • any disables type checking; unknown requires narrowing or a type assertion before most operations.
    • void usually describes an ignored function return value; never means a value cannot occur.

    What the interviewer checks: The interviewer checks whether you distinguish JavaScript runtime values from TypeScript’s static type system.

16. What does the TypeScript notation `string[]` mean?

    Asked once · last asked Oct 8 · Concept · Junior

    Show answer

    `string[]` means an array of strings in TypeScript. Each element must be a string when checked by TypeScript. It is the same type as `Array<string>`.

    • The array can be empty or contain multiple strings.
    • TypeScript rejects adding values of other types during type checking.
    • The type does not check values at runtime.

    What the interviewer checks: The interviewer is checking whether you understand array types and their element type restrictions.

17. Can you give an example of how to use type assertions in TypeScript?

    Asked once · last asked Jul 20 · Concept · Junior

    Show answer

    Use `as` to tell TypeScript to treat a value as a specific type. For example, if a DOM element is known to be an input, assert `HTMLInputElement` to access its `value` property. Assertions do not check or convert values at runtime.

    • Use assertions when you know more about a value’s type than TypeScript does.
    • A wrong assertion can cause runtime errors.
    • Handle null separately when an element might not exist.

    CodeCopy

    // The page contains <input id="email">.
    const input = document.getElementById("email") as HTMLInputElement | null;
    if (input !== null) {
      input.value = "user@example.com";
    }

    What the interviewer checks: The interviewer checks whether you can use assertion syntax and explain its runtime limits.

18. How does structural typing work in TypeScript, and how does it differ from nominal typing?

    Asked once · last asked Oct 7 · Concept · Senior

    Show answer

    TypeScript uses structural typing: types are compatible when their members match, even if their names differ. A value can fit a target type if it has all required members with compatible types. Nominal typing instead uses declared type identity and explicit relationships, such as inheritance.

    • Extra members usually do not prevent assignment.
    • Fresh object literals get extra checks for unknown properties.
    • Private and protected class members must come from the same declaration for compatibility.

    CodeCopy

    interface Person {
      name: string;
    }
    const employee = { name: "Ana", role: "Developer" };
    const person: Person = employee; // Allowed: required members match.

    What the interviewer checks: The interviewer is checking whether you understand that matching structure usually matters more than type names in TypeScript.

19. What does it mean for a function to return void or to be private or public?

    Asked once · last asked Jun 4 · Concept · Junior

    Show answer

    In TypeScript, `void` means a function provides no usable return value to its caller. A `private` method is accessible only within the class that declares it. A `public` method is accessible from anywhere. Return types and access modifiers describe separate things.

    • Class methods are public by default.
    • Private methods cannot be accessed directly by subclasses.
    • A function returning a value can satisfy a void-returning callback type; its return value is ignored.
    • TypeScript’s private modifier is checked at compile time; JavaScript’s #private members enforce privacy at runtime.

    What the interviewer checks: The interviewer is checking whether you distinguish return types from access control and understand TypeScript’s privacy rules.

20. What does `extends` mean in TypeScript and JavaScript?

    Asked once · last asked Oct 8 · Concept · Junior

    Show answer

    In JavaScript, `extends` makes one class inherit from another. TypeScript supports this too, and also uses `extends` for interface inheritance, generic constraints, and conditional types. Class inheritance affects runtime behavior; TypeScript’s type-only uses do not.

    • A class can extend one parent class, inheriting instance methods and static members.
    • A TypeScript interface can extend multiple interfaces.
    • A generic constraint such as `T extends User` requires T to be assignable to User.
    • A conditional type such as `T extends string ? A : B` selects a type based on assignability.

    What the interviewer checks: The interviewer checks whether you distinguish runtime class inheritance from TypeScript’s type-only uses of `extends`.

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• QA Engineer interview questions
• AI Engineer interview questions
• Cybersecurity interview questions
• Python interview questions
• Java interview questions
• JavaScript interview questions
• C# and .NET interview questions
• C++ interview questions
• PHP and Laravel interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every TypeScript interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

45 interviews, 37 candidates, Oct 2025 to Oct 2026. Updated every month with new interviews.