Most people who put "JavaScript expert" on a CV are describing advanced skills — async/await, clean Promise chains, correct event-loop ordering. Genuine expert level is a different question: how the prototype chain actually resolves a property lookup underneath class syntax, what Proxy and Reflect actually let you intercept, and how a closure can quietly keep a large object reachable — and therefore alive — long after you meant to be done with it. Here is where the real line sits.
What "Expert" Actually Covers
A working, correct mental model of the prototype chain: how property lookup actually walks from an object to its prototype and beyond, and how class syntax is implemented on top of that same mechanism rather than being a separate system. Proxy and Reflect for intercepting fundamental object operations — get, set, has, deleteProperty, apply — and knowing what kind of problem (reactivity, validation, access logging) actually calls for them versus a simpler pattern.
Reasoning about memory: what makes an object reachable, how closures can unintentionally extend an object's lifetime, and enough familiarity with browser or Node profiling tools (heap snapshots, allocation timelines) to actually diagnose a leak rather than guess at one. Enough runtime awareness to know where browser-engine and Node/V8 behaviour genuinely differs, rather than assuming one runtime's specifics apply everywhere.
What Genuinely Still Trips Up Experts
- Assuming a Proxy trap is a free, no-cost interception point, when in fact every intercepted operation has real performance overhead that matters in a hot path
- A long-lived event listener or subscription that captures an unintentionally large closure, keeping data structures reachable — and therefore un-collectable — for the lifetime of the listener rather than the lifetime the developer actually intended
- Modifying a built-in prototype (extending Array.prototype, for instance) and being surprised when that change leaks into unrelated code — including third-party library code — that also iterates the same built-in type
- Assuming garbage collection timing is predictable or synchronous enough to reason about precisely, when it is deliberately left to the engine to schedule, which makes some memory-leak symptoms intermittent and hard to reproduce on demand
The pattern here is different from the earlier tiers: these are not wrong-output bugs caught by reading the code. They are correctness and performance problems that often only appear under real, sustained usage — long-running pages, large data sets, many event subscriptions over time — exactly why they sit at the expert tier.
What to Put on a CV at This Level
Name the specific components: "prototype chain and object model internals, Proxy/Reflect, memory-leak diagnosis (heap snapshots), runtime-specific behaviour (V8/browser)" is specific and checkable — it also tells an interviewer exactly what to probe, which is the honest version of an expert claim.
If the real experience stops at "I understand async/await and closures" without having reasoned about the prototype chain or diagnosed a real memory leak, that is advanced, not expert — and the distinction matters, because the interview question at this tier is usually a scenario about a growing heap over time, not a definition of what a class is.
Where This Actually Stops
Past this point the work usually moves into JavaScript-engine or runtime-internals territory proper — contributing to V8 or a similar engine, or deep Node.js internals work — a genuinely different job from application-level JavaScript, even expert application-level JavaScript.
The JavaScript Test is scenario-based across core language, scope/functions and async/runtime fundamentals in 30 questions, which places its ceiling around the advanced tier rather than testing Proxy/Reflect or memory diagnostics directly — a genuinely useful fundamentals check even for someone operating at expert level day to day. If the target role compares runtime and concurrency models across languages, the Python Test is a useful companion, since Python's GIL-constrained threading model is a genuinely different but comparably subtle tradeoff worth being able to contrast against JavaScript's single-threaded event loop.
A Note on Calling Yourself an Expert
Because "JavaScript expert" is such a common overstatement — often meaning "very comfortable with async/await and modern syntax" rather than "understands the object model and runtime" — some interviewers treat the bare claim as close to a neutral signal and reach straight for a scenario question instead: why is this heap growing over time, what does this Proxy trap actually intercept.
The upside runs the other way too. A candidate who says "solid with async/await and closures, still building depth on the prototype chain and memory profiling" reads as more credible than one who claims "JavaScript expert" and cannot explain how property lookup actually walks the prototype chain when asked directly — and in a technical conversation, that kind of precision is usually what decides whether the interviewer trusts everything else the candidate said.