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 several of those are unfamiliar, the course below is free and covers all of it. If you would rather find out than guess, there is a practice paper at the same level — ten questions, marked as you go, no account, nothing recorded.

Take the free practice paper

Syllabus

Every paper is drawn to this mix, so the weights are a promise rather than a guide. The numbers are how many of the 50 questions come from each area.

  • 2

    Why TypeScript and project setup

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

  • 4

    Basic types and inference

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

  • 4

    Functions and object types

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

  • 3

    Interfaces vs type aliases

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

  • 5

    Unions, intersections and narrowing

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

  • 3

    Arrays, tuples and enums

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

  • 3

    unknown, any, and type guards

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

  • 5

    Generics

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

  • 5

    Utility types

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

  • 4

    Classes and OOP

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

  • 5

    Advanced type-level features

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

  • 2

    Modules and declaration files

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

  • 3

    Third-party types and tsconfig strictness

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

  • 2

    satisfies, as const, and real-world integration

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

Everything on this syllabus is taught free

The TypeScript course covers the whole syllabus above across 25 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.