Types, generics, utility types, narrowing, strict tsconfig, advanced generics, zod.
Before starting, we run a 1-minute tech check — microphone, ambient noise, connection. If your setup isn't good enough, the test is fully refunded.
Stop saying you "know TypeScript" — prove you can reason through generics, narrowing, Zod, and strict mode under pressure with a 15-minute AI oral exam that gives you a score, a level, and a badge you can share.
The Plume TypeScript badge certifies your actual command of the TypeScript type system — not just your ability to annotate function parameters. The AI examiner digs into the areas that separate a TypeScript power user from someone who writes glorified JavaScript: conditional types, mapped types, discriminated unions with exhaustiveness checking via `never`, type predicates, advanced generic constraints with `infer`, and the full `strict` tsconfig surface area. You're questioned the way a principal engineer would interview you, with follow-up questions that expose gaps you can't paper over.
What makes this badge credible is the format itself. You can't prep by memorizing a cheat sheet — the AI adapts to your answers, asks you to walk through a custom utility type you've actually written, justify why you reached for Zod at an API boundary, or explain how you'd handle an exhaustiveness check on a union that keeps growing. The full transcript is then scored by Claude Opus, which produces a 0-100 score, a level (Novice / Proficient / Advanced / Expert), and a detailed written report breaking down your strengths and blind spots.
This badge is built for frontend, fullstack, and backend engineers who ship TypeScript in production and want credible proof of it. It's especially valuable if you're applying for roles where TypeScript is central to the stack (React, Next.js, NestJS, tRPC, Prisma), if you're a freelancer competing on technically demanding contracts, or if you're a senior developer positioning yourself for a tech lead role and want to validate your depth before the interview.
Here are the concrete dimensions the AI examines during the 15-minute oral.
Writing custom utility types (DeepPartial, PathsOf<T>, Flatten), mastering `extends` constraints, inference with `infer`, and const type parameters introduced in TypeScript 5.x.
Discriminated unions, type predicates (`x is Foo`), assertion functions, and exhaustiveness checking with `never` to guarantee a switch statement covers every case in a union — with no runtime surprises.
Using `extends ? :` for conditional types, `keyof`, `in`, and `as` remapping in mapped types, and combining them to build complex type transformations that stay maintainable.
Enabling and justifying each strict option (`strictNullChecks`, `noImplicitAny`, `exactOptionalPropertyTypes`), and configuring `@typescript-eslint` for a codebase with no type compromises.
Integrating Zod or Valibot at API and external data boundaries, inferring the TypeScript type from the schema with `z.infer<>`, and handling validation errors in a fully type-safe way.
Automating type generation from OpenAPI (openapi-typescript), GraphQL (GraphQL Code Generator), or Prisma, keeping types in sync with the source of truth instead of maintaining them by hand.
Progressive migration with `allowJs`, manual `.d.ts` files, and `@ts-check`, managing technical debt and untyped packages, and making deliberate trade-offs between temporary `any` and over-engineered type gymnastics.
Awareness of `satisfies` (4.9), const type parameters (5.0), inferred type predicates (5.5), and isolatedDeclarations — plus an informed view on TypeScript vs. Flow or the native JS type annotations proposal.
Final scoring is performed by Claude (Anthropic), which reads back the full transcript and applies this weighted criteria grid.
How deeply you understand generics, conditional types, mapped types, and narrowing. Can you describe complex types you've actually written, not just recite examples from the TypeScript handbook?
How relevant and concrete your examples are: actual migrations, Zod integration at a real API boundary, handling a package with no types available, or designing a generic hook that works across multiple data shapes.
Can you justify technical choices — when to use `unknown` over `any`, when a custom utility type becomes more expensive than it's worth, or why enabling `exactOptionalPropertyTypes` might break an existing codebase you shouldn't touch?
Mastery of tsconfig options (project references, paths, composite mode), integration with ESLint, bundlers (Vite, esbuild, tsx), and type generators from external schemas or APIs.
Knowledge of recent TypeScript releases and features, and a reasoned opinion on where TypeScript is heading versus alternatives like Flow or the TC39 type annotations proposal.
A Plume session takes about 20 minutes, from tech check to badge delivery.
The AI confirms your mic is working and the audio is clean. No IDE, no screen share — the exam is entirely verbal, like a real technical phone screen. All you need is a working microphone and a quiet room.
You briefly introduce yourself and describe your most recent or most complex TypeScript project — the stack, the scale, and one moment where the type system either saved you or got in your way. The AI calibrates the depth of what follows based on what you share.
The AI works through the core TypeScript dimensions: advanced generics, narrowing, conditional and mapped types, Zod at runtime boundaries, strict tsconfig configuration, and JS-to-TS migration strategies. It follows up on your answers, asks for concrete examples, and pushes on the gray areas — the trade-offs you made and why.
You get the floor: what's your take on `satisfies`, on native JS type annotations, or on a TypeScript limitation you regularly work around? This is your chance to show technical maturity and genuine engagement with the ecosystem.
Claude Opus reads the full transcript and produces a 0-100 score, a level (Novice to Expert), and a detailed written report. Your TypeScript badge is ready in your Plume profile with a shareable URL within minutes.
Your score out of 100 translates into a level a recruiter can grasp at a glance.
You use TypeScript as annotated JavaScript: primitive types, basic interfaces, the occasional generic copy-pasted from Stack Overflow. Strict mode intimidates you and you lean on `any` to keep moving. You don't yet have a TypeScript project in production that you own end-to-end.
You work with TypeScript daily on a production project. You're comfortable with the standard utility types (`Partial`, `Pick`, `Omit`, `Record`), you understand basic narrowing with type guards, and you can configure a reasonable tsconfig. Simple generics are no issue, but conditional types and mapped types are still fuzzy territory.
You write custom utility types, you're fluent with conditional types (`infer`, `extends`), discriminated unions with exhaustiveness checking, and you know how to wire up Zod or Valibot at API boundaries. You've been through at least one non-trivial JS-to-TS migration and you have strong opinions on `@typescript-eslint` configuration.
You design type-level abstractions that your teammates use without seeing the complexity underneath. You understand the nuances of variance, the limits of structural typing, where TypeScript loses type information at runtime, and you have a grounded take on `satisfies`, isolatedDeclarations, and what native type stripping would mean in practice. You're the TypeScript reference point in any team you join.
No degree or years of experience required to take the badge. Here are the profiles it makes the most sense for.
You use TypeScript every day with React and want to prove you go beyond typed props — that you can reason through generic hooks, `useReducer` return types, and Zod-validated route params in a Next.js app.
An Advanced or Expert TypeScript badge on your Plume profile is a concrete signal for clients building on NestJS, tRPC, or Prisma. It compensates for the lack of verifiable public references when your work is under NDA.
You want to land a senior or lead position, and interviewers want proof of TypeScript depth. The Plume oral simulates exactly the kind of questions you'll face in a technical interview at a Series B or later-stage company.
You're making the JS-to-TS shift and want to validate that your level is genuinely Proficient or Advanced before applying. The detailed report tells you exactly which gaps to close — conditional types, strict config, Zod — before your next interview.
You want an objective picture of your team's TypeScript depth before a migration or refactoring sprint. Plume badges give you a shared reference framework without running time-consuming internal interviews.
Where and how your TypeScript badge will help you day to day.
A recruiter sees "TypeScript" on your resume alongside 80% of other candidates. With a Plume Expert badge, you stand out: they can read the report, see that you can explain `infer` and discriminated unions in context, and verify the score in 30 seconds.
A client is choosing between two freelancers. Your Advanced TypeScript badge shows you know how to set up a tRPC project with end-to-end Zod validation and a strict tsconfig. The other candidate only has their own word for it.
You take the Plume oral two weeks before a real interview at a scale-up. The report flags that your answers on assertion functions and `never` for exhaustiveness were vague. You spend a focused week on those topics and walk into the interview with real confidence.
You're positioning yourself to lead a monorepo JavaScript migration to TypeScript. The badge validates your technical credibility with the CTO and the rest of the team — even before you have the tech lead title on your business card.
You add your Plume badge URL to the README of your TypeScript utility library on GitHub. Contributors and potential employers can verify your level in seconds — no résumé, no trust required.
A CTO wants to know if the team is ready to adopt advanced generics and Zod before a major refactoring initiative. Plume badges give a consistent, objective snapshot of each developer's TypeScript level without politicizing the assessment.
A few minutes to check you have everything you need.
At the end of your session you don't just get a score — here's everything that awaits you.
You get a precise score out of 100 and a level — Novice, Proficient, Advanced, or Expert — that reflects your actual TypeScript mastery. Not a self-assessment, but an AI verdict based on how you performed under real questioning.
Claude Opus produces a written breakdown of your strengths (e.g., strong discriminated union reasoning) and the areas to develop (e.g., `infer` usage needs more depth) — specific, actionable, and directly useful for your next interview prep.
Your full oral is recorded and stored securely. You can replay it to analyze your answers, spot hesitations on specific TypeScript topics, and sharpen your explanations before the next real technical interview.
A unique, verifiable URL to drop on your resume, LinkedIn, GitHub profile, or portfolio. Recruiters and clients can check your TypeScript score and level without a Plume account — instant, friction-free credibility.
Discover related skills you can validate with Plume.
A 15-min oral exam with an AI, a shareable badge for your recruiters.
Choose this badge · €19.99
