AniUI Academy
Beginner to advanced

TypeScript Certification

One paper across the whole type system: basic types and inference, functions and object shapes, unions and narrowing, generics and the utility types built from them, classes, the advanced type-level features behind library code, and the modules, tsconfig strictness and real-world habits that make a typed codebase trustworthy. Sat in one two-hour sitting.

Sitting
2 hours
Questions
50
Pass mark
70%
Price
₹199$9.99

Sit this when you can do these without looking them up

This is not a certificate of attendance. It is 50 questions in 2 hours at 70% with no partial credit and one attempt, and roughly a third of the paper is foundations — the certificate is for the whole language, not the parts you enjoyed.

  • Explain why let x: any = 5; x.toUpperCase() compiles but crashes at runtime, and what any turns off that unknown does not
  • Narrow a union using typeof, instanceof, in, and a discriminant property, and know which applies to a given shape
  • Write a generic function with a constraint (<T extends { length: number }>) instead of reaching for any
  • Explain the practical difference between interface and type, and what declaration merging does that a type alias cannot
  • Read a mapped type or a conditional type using infer and say what it produces for a concrete input
  • Add types for an untyped third-party module with a .d.ts file, and say what @types/* packages are for
  • Explain what satisfies checks that a plain type annotation does not, and when reaching for as const actually matters

If you'd rather find out than guess, the free 5-question readiness check reports a predicted band in two minutes. If several readiness points are unfamiliar, the free course covers everything on the syllabus.

Take the free 5-question checkOr try the longer 10-question practice paper

Syllabus

Every paper is drawn to this mix, so the weights are a promise rather than a guide. The bars show each area's share of the 50 questions.

  • Why TypeScript and project setup

    2 Q·4%

    What TypeScript compiles to, structural typing, tsc and tsconfig basics, and where type errors actually surface day to day.

  • Basic types and inference

    4 Q·8%

    The primitive types, how let and const infer differently, arrays vs tuples, and null/undefined under strictNullChecks.

  • Functions and object types

    4 Q·8%

    Parameter and return types, optional and default parameters, contextual typing, interfaces, readonly, and index signatures.

  • Interfaces vs type aliases

    3 Q·6%

    What each can express that the other can't, intersection vs extends, and declaration merging.

  • Unions, intersections and narrowing

    5 Q·10%

    Union and intersection types, literal types, typeof/instanceof/in narrowing, discriminated unions, and exhaustiveness checking.

  • Arrays, tuples and enums

    3 Q·6%

    readonly arrays, fixed-length tuples, numeric and string enums, and the literal-union alternative.

  • unknown, any, and type guards

    3 Q·6%

    Why any disables checking and unknown doesn't, and writing custom type guards with the is keyword.

  • Generics

    5 Q·10%

    Type parameters on functions, interfaces and classes, constraints with extends, and default type parameters.

  • Utility types

    5 Q·10%

    Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, ReturnType, Parameters, and Awaited.

  • Classes and OOP

    4 Q·8%

    Access modifiers, parameter properties, implements vs extends, abstract classes, and polymorphism.

  • Advanced type-level features

    5 Q·10%

    Conditional types and infer, distributive conditional types, mapped types and key remapping, and template literal types.

  • Modules and declaration files

    2 Q·4%

    import type, .d.ts files, and hand-declaring the shape of an untyped module.

  • Third-party types and tsconfig strictness

    3 Q·6%

    DefinitelyTyped and @types packages, module augmentation, and what the strict family of compiler flags actually checks.

  • satisfies, as const, and real-world integration

    2 Q·4%

    as const and satisfies, typing async code and caught errors, and migrating an existing JavaScript codebase incrementally.

Three questions from the bank

Representative of the mix and difficulty — answer visible, shown here to calibrate expectations rather than test you.

  1. Sample 1Why TypeScript and project setup

    What actually executes when a browser or Node.js runs TypeScript code?

    • The .ts file directly — modern runtimes understand TypeScript natively
    • Plain JavaScript, produced by a compiler that has erased every type annotation
    • A bytecode format specific to TypeScript
    • The .ts file, but only inside Node.js, never in a browser

    Why: No browser and no version of Node.js has ever executed a .ts file directly. A compiler (tsc, or a transpiler like esbuild/SWC) strips every annotation and produces ordinary JavaScript, which is what actually runs.

  2. Sample 2Basic types and inference

    Given `let count = 5;` with no type annotation, what type does TypeScript infer for count?

    • `any`
    • `number`
    • the literal type `5`
    • `unknown`

    Why: Inference from a let binding widens a literal to its general type, since a let is expected to be reassignable to any value of that general type — so 5 becomes number, not the literal 5.

  3. Sample 3Functions and object types

    In `function greet(name: string, greeting = "Hello") {}`, what type is inferred for greeting?

    • `string`, inferred from the default value, the same way a const's initializer is used for inference
    • It must be explicitly annotated or this is a compile error
    • The literal type `"Hello"`, and nothing else is ever allowed
    • `any`

    Why: A default value gives the compiler something to infer from, the same as an initializer would for a variable — greeting is inferred as string, and callers may pass any string or omit the argument entirely.

What this does NOT replace

An honest comparison, because overclaiming cert value helps nobody and gets caught by anyone who hires.

  • This is not an AWS / Google / Microsoft vendor certification — those cover a proprietary platform, carry employer discounts, and some recruiters filter resumes against them. If a role explicitly names those, this doesn't substitute.
  • This is not a replacement for a degree, a bootcamp with job placement, or shipping real work. Those produce different evidence. A certificate is a focused signal, not a career.
  • This is a focused, honest signal that you can hold the full syllabus in your head under a clock. Pair it with a résumé that shows what you've built — that's the combination that lands interviews.

Everything on this syllabus is taught free

The TypeScript course covers the whole syllabus above across 28 lessons, with a playground in each one. Work through it first — the exam is the same material under a clock.

Open the TypeScript course

What sitting it is like

The exam opens full screen with a countdown, a question at a time, and a grid showing what you have answered and what you have flagged to come back to. Nothing is submitted until you say so, or the clock reaches zero.

Every answer saves to the server as you give it. If your laptop dies at question forty, sign back in and you will find question forty exactly as you left it — with however much time was left still ticking, because the clock does not pause.

Leaving full screen or switching tabs is noted but does not end your exam. It is a record, not a trap: nobody is auto-failed for a notification stealing focus.

When it ends you get your mark, a topic-by-topic breakdown, and every question with the right answer and an explanation — whether you passed or not. Passing also produces a certificate with a link anyone can verify.