Beginner JavaScript is not "I know var, let and functions exist." It is being able to read a short piece of code and say, correctly, what it does when it runs — including the language's single most famous beginner trap: == comparing a string and a number by converting one to match the other, using rules that are consistent but not what most people guess on first contact.
What "Beginner" Actually Covers
Variable declaration with var/let/const, the core primitive types (string, number, boolean, undefined, null) and basic type conversion, if/else and switch branching, for/while loops, arrays with basic methods (push, pop, indexOf, includes), and writing a basic function including a function with a return value.
You can use template literals for string building, basic object literals with dot and bracket property access, and you understand that JavaScript is dynamically typed — a variable can hold any type and that type is not fixed the way it is in a statically typed language.
That is a genuine, employable floor. It also looks, from a CV line alone, identical to having only skimmed a tutorial — which is why naming the specific things you can do reads as far more credible than the bare word "JavaScript".
Where It Breaks
- == converting types before comparing, so `"5" == 5` is true and `0 == false` is true, in ways that look inconsistent until you know the specific conversion rules being applied
- `NaN == NaN` returning false, and `typeof NaN` returning "number" — both spec-defined, both surprising on first encounter
- var's function-scoping meaning a variable declared inside an if block is still accessible outside it, unlike most other languages' block-scoped variables
- Array holes and sparse arrays behaving unexpectedly with some array methods, and `typeof array` returning "object" rather than something array-specific
- Implicit type coercion in string concatenation — `1 + "1"` is `"11"` (string concatenation) while `1 + 1` is `2` (addition) and `"5" - 1` is `4` (the minus operator only has a numeric meaning, so it coerces the string to a number) — three different rules for what looks like similar code
None of these require advanced knowledge to avoid. They require knowing that JavaScript has a small, specific list of places where the code doing something is not the same as the code doing what you expected — which is exactly what beginner-level testing checks for.
What to Put on a CV at This Level
"Basic JavaScript: variables, control flow, functions, arrays/objects basics, template literals, ===/type coercion awareness" is accurate and it is enough for a real share of front-end maintenance and simple scripting roles that never touch a Promise or a class hierarchy.
What would overstate it: "JavaScript" with nothing after it, or naming things you have only read about — async/await, closures, the event loop — without having written one. Those get tested directly in the first working week, not the interview.
The Next Rung
Two things separate beginner from intermediate: a real understanding of scope (why var and let behave differently inside a loop) and closures — functions that remember variables from the scope they were created in, which is central to a huge amount of real JavaScript, not a niche feature.
The JavaScript Test covers 30 code-reading scenario questions in about six minutes across core language, scope/functions, and async/DOM-adjacent fundamentals, which is a faster way to find the actual gap than guessing from a tutorial.
Why == Is Worth Taking Seriously From Day One
It is worth saying plainly why type coercion gets more attention here than almost anything else at this level: it is the single most common reason a beginner's JavaScript comparison looks completely correct and quietly is not, and it is also the most-cited "gotcha" in the language for exactly that reason.
Someone who has genuinely internalised the difference between == and ===, and who defaults to === specifically to avoid the ambiguity, has removed the single largest source of beginner JavaScript comparison bugs. Everything the next tier adds — scope, closures, this — builds on that foundation being solid.