Beginner SQL is not "I know SELECT and WHERE." It is being able to read a short query against a small table and say, correctly, which rows come back — including the single most common way that goes wrong for beginners: NULL, which behaves nothing like zero, an empty string, or "no value" the way most people assume on first contact with it.
What "Beginner" Actually Covers
SELECT with column lists and aliases, WHERE with the standard comparison and logical operators, ORDER BY (including multiple columns and ASC/DESC), basic INNER JOIN across two tables on a matching key, and the core aggregate functions — COUNT, SUM, AVG, MIN, MAX — used with GROUP BY.
You can also write a basic INSERT, UPDATE with a WHERE clause, and DELETE with a WHERE clause, and — critically — you understand why leaving the WHERE off an UPDATE or DELETE is dangerous rather than just unusual.
That is a real, employable floor for report-writing and basic data-pulling work. It looks, from a CV line alone, identical to having only read about SQL — which is why naming the specific pieces reads as far more credible than the word "SQL" on its own.
Where It Breaks
- A `WHERE column != value` or `WHERE column = value` silently dropping every row where that column is NULL, because any comparison against NULL evaluates to UNKNOWN, not TRUE or FALSE
- Trying to filter on an aggregate inside WHERE instead of HAVING, since the aggregate does not exist yet when WHERE runs
- A JOIN that matches more than one row on one side, quietly inflating a SUM or COUNT computed afterward — the query is syntactically correct and numerically wrong
- Forgetting GROUP BY needs every non-aggregated selected column listed in it (or the engine rejects the query, or in more permissive engines silently picks an arbitrary row)
- An UPDATE or DELETE with no WHERE clause, which runs successfully against every row in the table — no error, no warning, no undo
None of these require advanced knowledge. They require knowing that a query can be free of syntax errors and still return the wrong answer — which is exactly the gap beginner-level scenario testing is built to surface.
What to Put on a CV at This Level
"Basic SQL: SELECT/WHERE/ORDER BY, INNER JOIN, GROUP BY with aggregates, basic INSERT/UPDATE/DELETE" is accurate and it is enough for a real share of reporting and data-pulling roles that never touch a window function or a subquery.
What would overstate it: "SQL" with nothing after it, or naming things you have only read about — window functions, CTEs, transactions — without having written one. Those get tested directly by the first real query someone asks you to debug, not the interview.
The Next Rung
Two things separate beginner from intermediate: a working understanding of LEFT/RIGHT JOIN and how a WHERE clause can silently turn a LEFT JOIN back into an INNER JOIN, and subqueries — including the specific trap of `NOT IN` combined with a subquery that can return NULL.
The SQL Test covers 30 scenario questions in about six minutes across query fundamentals, joins, aggregation and correctness traps, which is a faster way to find the actual gap than guessing from a tutorial.
Why NULL Is Worth Taking Seriously From Day One
It is worth saying plainly why NULL gets more attention here than almost anything else at this level: it is the single most common reason a beginner's query looks completely correct, runs without error, and still returns the wrong row count. Nothing else in beginner SQL produces a silent, un-flagged wrong answer this often.
Someone who has genuinely internalised that NULL is "unknown," not "empty" or "zero," and that comparisons against it evaluate to UNKNOWN rather than false, has removed the single largest source of beginner SQL bugs. Everything the next tier adds — joins, subqueries, aggregation edge cases — builds on that foundation being solid.