TypeScript is on more developer resumes than ever. It's also one of the most commonly misrepresented skills — developers who've only used basic type annotations calling themselves "proficient," when the concepts that matter in real codebases (generics, conditional types, mapped types, declaration merging) are largely untouched.
The ten questions below are modelled on what senior TypeScript engineers and interviewers actually test. They're not trick questions — they're the concepts that determine whether you can maintain and evolve a large TypeScript codebase.
Why TypeScript knowledge varies so dramatically
Most developers learn TypeScript by adding it to an existing JavaScript project: install the package, rename files to .ts, add ': string' and ': number' where VSCode complains, and call it done. That gets you to about 20% of what TypeScript can do.
The remaining 80% — the generic constraints, conditional return types, template literal types, utility types like Extract and Exclude, declaration merging, const assertions, satisfies operator — is what separates TypeScript users from TypeScript engineers.
Interviewers know this. When a senior role asks "tell me about your TypeScript experience," they're waiting to hear whether you mention inference, generics, or the type system — not whether you know what a type annotation is.
The concepts that matter in real TypeScript codebases
Generic constraints are used in almost every utility library. Understanding extends in a generic context — not as class inheritance but as a type constraint — is fundamental. If you can write a function that accepts any object with a specific shape and infers the return type correctly, you understand generics.
Conditional types (T extends U ? X : Y) power most of TypeScript's built-in utility types. Exclude, Extract, NonNullable, ReturnType, and Parameters are all conditional types. If you can't read a conditional type, you can't understand what the types you import from libraries actually do.
Mapped types transform existing types into new ones. Record, Partial, Required, and Readonly are all mapped types. Understanding how to write your own — { [K in keyof T]: ... } — is essential for any role building shared type systems or design systems.
The infer keyword inside conditional types lets you extract type information that you couldn't otherwise access. It's used to extract the resolved type of a Promise, the element type of an array, or the props of a React component. If you've never written infer, you're missing a significant part of the type system.
How to verify your TypeScript level before your interview
The honest way to measure your TypeScript skill is to get tested on it — not to self-assess.
Skeelzy's TypeScript quiz covers the concepts that matter: type inference, generics, conditional types, utility types, and common runtime-vs-compile-time distinctions. It's 10 questions. Your score is recorded and can appear as a verified badge on your developer resume — so when you say "TypeScript: proficient" in an application, there's a number behind it.
Take the quiz before you apply for your next TypeScript role. If your score is below 70%, spend a week on the TypeScript Handbook's advanced section before interviewing. If it's above 85%, you can walk into most TypeScript interviews with genuine confidence.