JavaScript is deceptively easy to start with and genuinely hard to master. The syntax is permissive, the documentation is vast, and you can build working applications without understanding half of what's actually happening at runtime. That's precisely what makes it such fertile ground for interview questions.
Every web developer has written JavaScript. Very few have spent time really understanding how it executes — the event loop, the call stack, closure mechanics, prototype delegation, the quirks of coercion. Those are the things that separate developers who can write JavaScript from developers who truly understand it.
This is what senior JavaScript interviews test. Not whether you know the syntax — everyone does. Whether you understand the runtime.
What senior JavaScript knowledge looks like
Closures are the most fundamental concept that separates JavaScript from languages with simpler scoping rules. A closure is what happens when a function keeps a live reference to the variables in its enclosing scope — even after that scope has returned. Every callback, every event listener, every timer in JavaScript is relying on closure. Understanding how closures create and maintain references is the prerequisite for understanding memory leaks, the classic loop-variable bug, and module patterns.
The event loop is the architecture of JavaScript's concurrency model. JavaScript is single-threaded — only one piece of code executes at a time. But browsers and Node.js are not single-threaded environments. The event loop is the mechanism that lets JavaScript handle asynchronous operations — I/O, timers, fetch requests — without blocking the main thread. Understanding the call stack, the task queue, the microtask queue, and how they interact is fundamental to reasoning about async code.
The prototype chain is how JavaScript implements inheritance. Every object in JavaScript has a prototype — another object it delegates property lookups to. This continues up the chain until it reaches Object.prototype. This isn't class-based inheritance — it's delegation. The class syntax in ES6 is syntactic sugar over prototype delegation. If you don't understand prototypes, you don't understand what JavaScript classes actually do.
Coercion is the set of rules JavaScript uses when it converts between types implicitly. "5" + 3 is "53". "5" - 3 is 2. [] == false is true. null == undefined is true, but null === undefined is false. These aren't bugs — they're specified behaviour. Senior developers know the coercion rules well enough to avoid gotchas and explain them to juniors.
Async patterns have evolved: callbacks → Promises → async/await. Understanding all three — including how async/await is syntactic sugar over Promises, and how Promises use the microtask queue — is what lets you reason about async execution order correctly.
10 questions that test real JavaScript knowledge
Work through these honestly before checking what you know and don't know. Each gap you identify is a concept worth reinforcing before your next interview.
1. What is a closure? Write a function that uses closure to create a private counter that can only be incremented or read, never set directly.
2. What is hoisting? What is the difference in hoisting behaviour between var, let, and function declarations?
3. Describe the JavaScript event loop. If you have a setTimeout(fn, 0) and a resolved Promise, which callback runs first?
4. What does 'this' refer to inside an arrow function? How is it different from a regular function, and when does that difference matter?
5. Explain the prototype chain. What happens when you access a property on an object that doesn't have that property defined on itself?
6. What is the difference between a Promise and a callback? What problem was Promise designed to solve?
7. You have an async function that calls fetch. Where should you put your try/catch to handle both network errors and API error responses (4xx, 5xx)?
8. What is the difference between WeakMap and Map? In what scenario would you reach for WeakMap?
9. What is a generator function? Write one that yields the Fibonacci sequence one number at a time.
10. What is the module scope in ES modules? How does it differ from CommonJS modules, and what is the significance of top-level await?
Why these questions come up in interviews
These questions appear in senior JavaScript interviews because they test the mental model, not the API. Any developer can look up how to write a for...of loop. The questions above test whether you understand what JavaScript is actually doing when your code runs — the execution context, the memory model, the async scheduling.
Interviewers use these questions to distinguish developers who've used JavaScript from developers who understand it. The developers who struggle with closures usually have never traced through what actually happens to the variable reference when the enclosing function returns. The developers who struggle with the event loop have used setTimeout and async/await without building a model of how they interact with the runtime.
The goal of the quiz isn't to trick you. It's to find the boundaries of your understanding so you know where to go deeper. A 60% score on this quiz tells you something specific: which concepts to spend the next week on. An 85% score tells you that your JavaScript fundamentals are solid enough that interviewers won't trip you up on the basics.
What your JavaScript score means
The Skeelzy JavaScript quiz is adaptive — questions increase in difficulty as your accuracy improves. A score above 85% indicates strong conceptual understanding across closures, the event loop, prototypes, and async patterns. That's the benchmark for senior JavaScript developers and most mid-level frontend/Node.js roles.
A score between 60-80% typically indicates solid practical JavaScript knowledge with gaps in the deeper runtime concepts. Those gaps are identifiable and fixable — usually a few days of focused study on the event loop model or prototype chain fills them in.
Below 60% usually indicates JavaScript is still primarily surface-level for you — you can write it, but you haven't yet built a model of how it executes. That's not a permanent state; it's a stage in learning the language.
Your score appears as a verified badge on your Skeelzy resume — "JavaScript: 82% accuracy" is a specific, externally validated signal that tells recruiters more than "JavaScript: proficient (self-assessed)." Take the quiz, see where you stand, and use the result as a calibration.