AniUI Academy
Beginner to advanced

JavaScript Certification

One paper across the whole language: how the web works, everyday JavaScript, then scope, prototypes and promises, and finally the event loop, performance, workers and browser security. Sat in one two-and-a-half-hour sitting.

Sitting
2½ hours
Questions
65
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 65 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 0.1 + 0.2 !== 0.3, and what == does that === does not
  • Predict the order of a snippet mixing setTimeout, a resolved promise and plain console.log
  • Say what this is in four different call patterns, and repair a callback that lost it
  • Follow a property lookup up the prototype chain, and say what class gives you that a constructor function does not
  • Describe a bug a shallow copy caused you, and what you would reach for instead
  • Name the defence against XSS that still holds when an attacker controls the whole string
  • Say what layout thrashing is, and how you would find it in a profile

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 65 questions.

  • How the web works

    2 Q·3%

    Clients and servers, DNS, requests and responses, status codes, and where your code runs.

  • Values and types

    4 Q·6%

    let and const, the primitive types, null versus undefined, and type coercion.

  • Text and numbers

    3 Q·5%

    String methods, template literals, arithmetic, rounding, and converting between the two.

  • Control flow

    3 Q·5%

    Comparison, truthiness, if and else, ternaries, switch, loops, and error handling with try, catch, finally, and throw.

  • Functions

    4 Q·6%

    Declarations, arrow functions, parameters and defaults, return values, scope, and debugging with call stacks.

  • Arrays and objects

    4 Q·6%

    Creating and reading both, nesting, destructuring, spread, map/filter/reduce, Map, Set, and persisting data with localStorage.

  • The browser

    2 Q·3%

    The DOM as a tree, selecting and changing elements, events, forms, and fetching API data with fetch().

  • Scope and closures

    4 Q·6%

    The scope chain, block versus function scope, closures, and the temporal dead zone.

  • this and binding

    3 Q·5%

    Call patterns, call, apply and bind, arrow functions, and losing this in a callback.

  • Objects and prototypes

    4 Q·6%

    The prototype chain, classes, inheritance, private fields, and getters and setters.

  • Destructuring and spread

    3 Q·5%

    Nested destructuring, defaults, rest, shallow copying vs structuredClone, optional chaining (?.) and nullish coalescing (??).

  • Modules

    3 Q·5%

    Named and default exports, module scope, dynamic import, and ESM versus CommonJS.

  • Promises and async

    5 Q·8%

    States, chaining, error propagation, async and await, the combinators, and cancellation.

  • The event loop

    4 Q·6%

    Macrotasks and microtasks, ordering, starvation, animation frames, and Node's phases.

  • Iterators and generators

    3 Q·5%

    The iteration protocol, writing iterators, generators, laziness, and async iteration.

  • Functional patterns

    3 Q·5%

    Purity, composition, currying, memoisation and its cache costs, and recursion.

  • Performance

    4 Q·6%

    The pixel pipeline, layout thrashing, the frame budget, Core Web Vitals, and measuring.

  • Workers

    3 Q·5%

    Dedicated workers, structured clone, transferables, and what a worker cannot reach.

  • Security

    4 Q·6%

    Same-origin, CORS, XSS and its defences, CSP, CSRF, and where tokens belong.

Three questions from the bank

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

  1. Sample 1How the web works

    What does a DNS lookup return?

    • The HTML of the page you asked for
    • The IP address of the server hosting that domain
    • A list of every page on the site
    • The certificate proving the site is genuine

    Why: DNS turns a name into a number and does nothing else. The files come from a separate request to the address it gave back.

  2. Sample 2Values and types

    What does `const` prevent?

    • Changing any part of the value it holds
    • Reassigning the name to a different value
    • Using the name before it is declared
    • Declaring the same name in an inner block

    Why: const locks the binding, not the value. A const object can still have its properties changed — you simply cannot point the name at something else.

  3. Sample 3Text and numbers

    What does `" hello ".trim()` do to the original string?

    • Removes the spaces from it
    • Nothing — it returns a new string and leaves the original unchanged
    • Removes spaces only from the start
    • Throws an error because strings cannot be modified

    Why: Strings are immutable. Every string method returns a new string, which is why forgetting to use the return value is such a common beginner bug.

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 JavaScript Masterclass course covers the whole syllabus above across 37 lessons, with a playground in each one. Work through it first — the exam is the same material under a clock.

Open the JavaScript Masterclass 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.