AI InterviewSearch…Search problems, topics, or pages…Ctrl KGet started
All skill tests

JavaScript · Intermediate skill test

JavaScript (Intermediate)

JavaScript the way production code uses it: the object model, the libraries, the edge cases and the traps — then two problems to solve in JavaScript.

Pass at 60%Distinction at 85%Proctored · full screenNo negative markingCode in JavaScriptValid 2 years

Quick answer

What does the JavaScript (Intermediate) skill test cover?

It examines JavaScript as production code uses it: how the this keyword is bound by call, apply, bind and classes, prototype chains and class syntax, closures, promise combinators and async/await, the event loop's task and microtask order, iterators, generators and Map, and edge cases in coercion, arrays and numbers. Multiple-choice questions come first, then coding problems up to medium difficulty, solved in JavaScript.

The sitting

60% pass85%0100

60%

to pass

1h 20m

total time

27

questions

7 days

to retake

Start the test

The clock starts as soon as you click. Every sitting draws a fresh paper.

Proctored sitting

  • Laptop or desktop only, with a webcam. Phones and tablets can't start a test.
  • The test runs full screen, with the site's navigation hidden.
  • Your webcam stays on and is checked on your computer — nothing is recorded or uploaded.
  • Leaving full screen, switching tab or window or minimising blurs the paper — and so does the camera seeing no one, someone else, a phone, or you looking away. The clock keeps running.
  • Each is a warning; the third ends the sitting, graded as not passed.
  • Pasting, copying, right-click and printing are off.

The paper

2 sections, sat in order, each on its own clock — 1h 20m in all.

1

Concepts

25 Q · 25 marks

30 min

One mark a question, no negative marking. Many questions show a program and ask what it prints. A few ask you to select every correct option, and only the exact set scores.

2

Coding

2 problems · 25 marks

50 min

Write each solution in JavaScript. Run checks the visible cases; Submit runs every hidden case and your best submission per problem is what counts, with partial credit for each case passed.

What it covers

Every paper takes its share from each of these 10 topics, so no two sittings lean the same way.

  1. 01

  2. 02

  3. 03

  4. 04

  5. 05

  6. 06

  7. 07

    Promises & async/await

    Practise: JavaScript study plan
  8. 08

  9. 09

  10. 10

The JavaScript (Intermediate) test is about what the language does once code stops being one script read from top to bottom: functions handed from one place to another, objects that inherit from other objects, and work that finishes later than the line that started it. Its questions examine how this is bound, how the prototype chain is searched, how errors travel through promises and exactly when asynchronous code runs.

The questions are short programs, rarely more than a dozen lines, and most ask what they print. Answering them means running the program in your head with the language's actual rules rather than an approximation of them. A few ask you to choose every correct option, scored only when the set is exact. The coding section that follows must be answered in JavaScript and is judged on hidden test cases.

Is this your level?

Sit Intermediate if JavaScript is a language you use every week: building front ends, writing Node.js services, or preparing for interviews where JavaScript is the language you will code in. It assumes what the JavaScript (Basic) test covers — scope and hoisting, coercion, the array and string methods, and the basic order of timers and promises — because the harder questions stand on that ground.

If you have used JavaScript for years but mostly through a framework, expect the event-loop and prototype questions to be the unfamiliar part. Framework code rarely makes you think about either, and both are examined here directly.

Where the questions dig deeper

Every area is a topic on your result. The JavaScript study plan covers them all; its modules on functions, scope and closures, prototypes and classes, collections and iteration, and asynchronous JavaScript matter most at this level.

  • this and binding. call, apply and bind; arrow functions; methods passed as callbacks or to timers; and this inside class methods, class fields and static methods.
  • Objects and prototypes. The prototype chain and how property reads and writes use it, own versus inherited properties, property attributes and freezing, and what class and extends actually build.
  • Functions and closures. Closures as a design tool: private state, functions that build other functions, wrappers that change how a function is called, and closures created inside loops.
  • Promises and async/await. What each step of a promise chain passes on, how errors travel through a chain and out of an async function, when asynchronous work starts compared with when it is awaited, and the four combinators Promise.all, allSettled, race and any.
  • The event loop. The order in which synchronous code, microtasks and timer callbacks run, in browsers and in Node.js, including where queueMicrotask, await and process.nextTick fit.
  • Modern syntax and built-ins. Optional chaining and nullish coalescing, iterators and generators, Map and WeakMap, object spread, accessors and tagged templates.
  • Types and coercion. The equality algorithms — loose, strict and Object.is — special values such as NaN and -0, and comparisons involving null and undefined.
  • Arrays. Sorting with and without a comparator, reduce with and without a starting value, sparse arrays, and building arrays with fill and Array.from.
  • Errors. Custom error classes, finally, errors thrown from code that runs later, and what Node.js does with a promise rejection that has no handler.
  • Strings and numbers. Floating-point comparison, the limit of safe integers and BigInt, and parsing numbers out of text.

Tracing asynchronous code by hand

Questions about execution order reward a method more than intuition. Read the script once from top to bottom and keep three lists as you go: code that runs now, the microtask queue and the timer queue. Write each callback into the list it joins at the moment it is scheduled — which is not always the line where it is written — and only then work out the order in which the lists are emptied. Writing the lists down turns a guess into a trace, and it shows you exactly which rule you are unsure of.

The rules themselves — how the queues are drained, and where await, queueMicrotask and process.nextTick place their work — are taught in the Asynchronous JavaScript module of the study plan. Practise them by writing a few lines, predicting the output and running them in Node.js. Keep each experiment small enough that you can account for every line it prints; when one surprises you, cut it down until only the surprising part is left.

The same discipline helps with this and prototype questions. For this, ask how the function is called on that exact line, unless it is an arrow function, which takes this from the code around it. For a property, ask whether the object has it as its own property or reaches it through the chain, and whether the line reads it or writes it.

Medium problems, solved in JavaScript

The coding section draws from the problem catalogue and reaches medium difficulty, where choosing the right algorithm matters as much as writing correct code. Submit runs every hidden case, so an approach that is fast enough for the visible examples can still lose marks. Review costs with the Big-O notation lesson, then practise the patterns medium problems lean on — hashing, two pointers, sliding window and binary search — with problems from Hash table, Two pointers and Sliding window.

In the sitting, the editor gives you a function to complete: return the answer rather than printing it, since the judge compares what the function returns. Reach for a Map or Set when you need constant-time lookups. Pasting is switched off, so practise writing solutions from an empty function. Your best submission for each problem is the one that counts, with partial credit for every hidden case it passes.

JavaScript Certification Test (Intermediate)

A free 80-minute JavaScript skill test at intermediate level. Pass with 60% to earn a verifiable CodeKairo credential and a profile frame.

  • Skill: JavaScript
  • Level: Intermediate
  • Duration: 80 minutes
  • Questions: 27
  • Pass mark: 60% (distinction at 85%)
  • Credential: Verifiable, valid for 2 years

JavaScript the way production code uses it: the object model, the libraries, the edge cases and the traps — then two problems to solve in JavaScript.

What does the JavaScript (Intermediate) skill test cover?

It examines JavaScript as production code uses it: how the this keyword is bound by call, apply, bind and classes, prototype chains and class syntax, closures, promise combinators and async/await, the event loop's task and microtask order, iterators, generators and Map, and edge cases in coercion, arrays and numbers. Multiple-choice questions come first, then coding problems up to medium difficulty, solved in JavaScript.

Sections

SectionQuestionsTimeKindMarks each
Concepts2530 minMultiple choice1
Coding250 minCoding12.5

What it covers

The JavaScript (Intermediate) test is about what the language does once code stops being one script read from top to bottom: functions handed from one place to another, objects that inherit from other objects, and work that finishes later than the line that started it. Its questions examine how this is bound, how the prototype chain is searched, how errors travel through promises and exactly when asynchronous code runs.

The questions are short programs, rarely more than a dozen lines, and most ask what they print. Answering them means running the program in your head with the language's actual rules rather than an approximation of them. A few ask you to choose every correct option, scored only when the set is exact. The coding section that follows must be answered in JavaScript and is judged on hidden test cases.

Is this your level?

Sit Intermediate if JavaScript is a language you use every week: building front ends, writing Node.js services, or preparing for interviews where JavaScript is the language you will code in. It assumes what the JavaScript (Basic) test covers — scope and hoisting, coercion, the array and string methods, and the basic order of timers and promises — because the harder questions stand on that ground.

If you have used JavaScript for years but mostly through a framework, expect the event-loop and prototype questions to be the unfamiliar part. Framework code rarely makes you think about either, and both are examined here directly.

Where the questions dig deeper

Every area is a topic on your result. The JavaScript study plan covers them all; its modules on functions, scope and closures, prototypes and classes, collections and iteration, and asynchronous JavaScript matter most at this level.

  • this and binding. call, apply and bind; arrow functions; methods passed as callbacks or to timers; and this inside class methods, class fields and static methods.
  • Objects and prototypes. The prototype chain and how property reads and writes use it, own versus inherited properties, property attributes and freezing, and what class and extends actually build.
  • Functions and closures. Closures as a design tool: private state, functions that build other functions, wrappers that change how a function is called, and closures created inside loops.
  • Promises and async/await. What each step of a promise chain passes on, how errors travel through a chain and out of an async function, when asynchronous work starts compared with when it is awaited, and the four combinators Promise.all, allSettled, race and any.
  • The event loop. The order in which synchronous code, microtasks and timer callbacks run, in browsers and in Node.js, including where queueMicrotask, await and process.nextTick fit.
  • Modern syntax and built-ins. Optional chaining and nullish coalescing, iterators and generators, Map and WeakMap, object spread, accessors and tagged templates.
  • Types and coercion. The equality algorithms — loose, strict and Object.is — special values such as NaN and -0, and comparisons involving null and undefined.
  • Arrays. Sorting with and without a comparator, reduce with and without a starting value, sparse arrays, and building arrays with fill and Array.from.
  • Errors. Custom error classes, finally, errors thrown from code that runs later, and what Node.js does with a promise rejection that has no handler.
  • Strings and numbers. Floating-point comparison, the limit of safe integers and BigInt, and parsing numbers out of text.

Tracing asynchronous code by hand

Questions about execution order reward a method more than intuition. Read the script once from top to bottom and keep three lists as you go: code that runs now, the microtask queue and the timer queue. Write each callback into the list it joins at the moment it is scheduled — which is not always the line where it is written — and only then work out the order in which the lists are emptied. Writing the lists down turns a guess into a trace, and it shows you exactly which rule you are unsure of.

The rules themselves — how the queues are drained, and where await, queueMicrotask and process.nextTick place their work — are taught in the Asynchronous JavaScript module of the study plan. Practise them by writing a few lines, predicting the output and running them in Node.js. Keep each experiment small enough that you can account for every line it prints; when one surprises you, cut it down until only the surprising part is left.

The same discipline helps with this and prototype questions. For this, ask how the function is called on that exact line, unless it is an arrow function, which takes this from the code around it. For a property, ask whether the object has it as its own property or reaches it through the chain, and whether the line reads it or writes it.

Medium problems, solved in JavaScript

The coding section draws from the problem catalogue and reaches medium difficulty, where choosing the right algorithm matters as much as writing correct code. Submit runs every hidden case, so an approach that is fast enough for the visible examples can still lose marks. Review costs with the Big-O notation lesson, then practise the patterns medium problems lean on — hashing, two pointers, sliding window and binary search — with problems from Hash table, Two pointers and Sliding window.

In the sitting, the editor gives you a function to complete: return the answer rather than printing it, since the judge compares what the function returns. Reach for a Map or Set when you need constant-time lookups. Pasting is switched off, so practise writing solutions from an empty function. Your best submission for each problem is the one that counts, with partial credit for every hidden case it passes.

Sample question

Topic: Errors

What does this program print?

const inputs = ['{"id":7}', "{id:7}", "null"];
const out = inputs.map((text) => {
  try {
    return JSON.parse(text).id;
  } catch (e) {
    return e.name;
  }
});
console.log(out.join(" "));
  1. 7 7 undefined
  2. 7 SyntaxError undefined
  3. 7 SyntaxError TypeError
  4. 7 SyntaxError SyntaxError
Show the answer

C. 7 SyntaxError TypeError

JSON is stricter than JavaScript's object literals: keys must be double-quoted strings, so {id:7} is not valid JSON and JSON.parse throws a SyntaxError. "null", on the other hand, is valid JSON — it parses to the value null — and the error comes one step later, when .id is read from null, which throws a TypeError. Both happen inside the try block, so both are caught, and the callback returns each error's name.

Common questions

Does the JavaScript Intermediate test assume Node.js or the browser?

The language rules are the same in both, and most questions depend on nothing else. Where the runtime matters, as with process.nextTick, the question says it is about Node.js and names the version if the behaviour changed between releases. Nothing on the test uses the DOM or other browser APIs.

Does the JavaScript Intermediate test cover regular expressions, modules or the DOM?

No. The questions stay with the core language and its standard built-ins: functions, objects, classes, promises, collections and iteration. Regular expressions, import and export, browser APIs and frameworks are not examined, though the JavaScript study plan teaches all of them.

How well do I need to know classes for the JavaScript Intermediate test?

Well enough to say what class syntax builds underneath: where methods, fields and static members live, what extends connects, and how this behaves inside class code. Private #name fields and decorators are not examined.

Is TypeScript part of the JavaScript Intermediate test?

No. Every question and the coding section use plain JavaScript, and type annotations would be a syntax error in a coding answer. The runtime rules examined here apply unchanged to TypeScript code; the type system itself has its own credential, TypeScript (Intermediate).

Do I have to pass JavaScript Basic before sitting Intermediate?

No, either test can be sat first. Take Basic first if scope, coercion or the array methods still need thought, because Intermediate questions build on them: a gap there costs marks on harder questions too, and the Basic result shows exactly where the gap is.

Rules

This is a certification test. Pass with 60% and you earn a verifiable CodeKairo credential — 85% earns it with distinction. It is valid for 2 years.

  • The sections are timed separately and taken in order. A section you leave cannot be reopened.
  • The server keeps the clock. Closing the tab or reloading does not pause it.
  • Your answers save as you go and survive a refresh.
  • The coding section must be answered in JavaScript. Run checks the visible cases; Submit runs every hidden case.
  • You may sit this test again 7 days after a sitting ends. Your best result stands.

Integrity. Work alone and from what you know, on a laptop or desktop with a webcam — phones and tablets cannot sit a skill test. The test runs full screen and must stay in front the whole time, and the webcam must see you, alone: leaving full screen, switching to another tab or window, minimising, or the camera seeing no one, someone else, a phone or you looking away blurs the paper and counts against you — the first 2 are warnings, and the third ends the sitting, graded as not passed. The camera check runs in your browser; nothing is recorded or uploaded. Pasting into the editor is switched off. A sitting that looks assisted can be reviewed, and a credential earned that way is revoked.

The answers are never shown — not during the test and not after it. Your result breaks the score down by topic and points you to what to practise.