SQLZoo, SQLBolt, Mode SQL Tutorial & DataCamp SQL Compared: Which Platform Wins?

sqlzoo searches sit at 2,900 a month, sql bolt at 1,300, mode sql tutorial at 1,600, and datacamp sql at 1,000 — four of the most-googled SQL practice platforms on the public web, and the four that show up on every "where should I learn SQL?" Reddit thread. The reality the search volume hides: none of these platforms is enough on its own. Each was designed for a different reader, a different dialect, and a different decade — and the right answer in 2026 is a stack of two or three of them, sequenced by goal, not a single platform end-to-end.

This guide is the honest, side-by-side comparison the SQL learning market never quite delivers. It grades SQLZoo, SQLBolt, Mode SQL Tutorial, and DataCamp SQL on five axes — free tier, interactivity, dialect coverage, depth, and audience level — maps which platform teaches which engine (MySQL, PostgreSQL, BigQuery, Snowflake, SQL Server, SQLite), and lays out the recommended zero-to-hero learning journey for a data analyst, an analytics engineer, and a data engineer. Each H2 ships with worked examples from real lesson pages, a Solution Tail with code, a step-by-step trace, an output table, and a concept-by-concept breakdown of why a given platform wins on its axis.

When you want interview-ready reps the moment any of those four free tutorials stops scaling, drill the SQL practice library →, rehearse on aggregation problems →, and stack windowing fluency with window-function drills →.

---

On this page

• The 4 most-googled SQL learning platforms — and why no single one wins
• Feature-by-feature matrix — 5 platforms, 5 axes
• Dialect coverage map — which platform teaches which engine
• The recommended learning journey — zero to hero
• Per-platform rating card — price, depth, audience fit
• Cheat sheet — platform recipes
• Frequently asked questions
• Practice on PipeCode

---

1. The 4 most-googled SQL learning platforms — and why no single one wins

Four platforms, four different readers — each was built to solve one slice of the SQL learning problem, not the whole thing

The mental model in one line: sqlzoo is the JOIN drill, sql bolt is the syntax warm-up, mode sql tutorial is the analytics-SQL bootcamp, and datacamp sql is the paid certificate track — they overlap less than 30%, which is why "which one wins?" is the wrong question. The right question is "which stack of two or three covers the goal I have today?" — and that depends on whether the learner is a complete beginner, an analyst onboarding into a new BI team, or a data engineer prepping for FAANG interviews.

The four candidates in one paragraph each.

• SQLZoo — launched in 2003 by Andrew Cumming at Edinburgh Napier University. The original "in-browser SQL practice site" — runs MySQL on the server, ships classic datasets (World, Nobel, Movies, Guardian) and progressively harder lesson pages, each with a runnable code box. Free, ad-light, and ten years older than every competitor. Best for muscle-memory JOIN and aggregation drills; weakest on modern dialects and interactivity polish.
• SQLBolt — eighteen short interactive lessons designed for "the first two hours with SQL." Each lesson is one concept, a runnable example, and a small set of exercises. Generic ANSI-flavoured syntax that runs against a SQLite-style backend; no auth, no progress tracking, no advanced topics. Best for absolute beginners who need to feel SELECT, WHERE, JOIN, and GROUP BY for the first time.
• Mode SQL Tutorial — the analytics SQL bootcamp shipped by Mode Analytics (now Sigma) as a marketing asset. Three layered sections — Basic, Intermediate, Advanced — with worked product-analytics datasets (warehouse orders, web events, US-state SAT scores). Runs against Mode's Postgres-flavoured engine and is the only one of the four that teaches window functions, performance, and BI thinking properly. Best for analyst and analytics-engineer onboarding.
• DataCamp SQL — a paid, structured course track. Twenty-plus tracks covering SQL, T-SQL, BigQuery, dbt, and PostgreSQL with video lectures, browser IDE, quizzes, and downloadable certificates of completion. Subscription is $25–$35/month after a short free intro. Best for career switchers who need a structured curriculum and a LinkedIn-grade credential; weakest on cost and on interview-style problem density.

The fifth platform that quietly belongs in the comparison.

• PipeCode — the data-engineering-focused practice platform. Generous free tier, multi-dialect IDE (Postgres / BigQuery / Snowflake / MySQL), 450+ problems tagged by company (Meta, Google, Stripe, Airbnb, Snowflake, ByteDance) and by topic (window functions, NULL handling, CTEs, joins). Built for the interview audience and the modern stack — which is where the four older platforms run out of steam. Free for the entire practice library; paid only for the senior-DE courses.

The five axes this post grades on.

• Free tier — how much real content does the free user get before the paywall? SQLZoo, SQLBolt, Mode, and PipeCode are all free-first; DataCamp is paid after a small intro.
• Interactive runner — can the learner run SQL right in the lesson page, against real data, with millisecond feedback? All five say yes — but the quality of the runner (latency, dialect fidelity, error messages, dataset realism) varies massively.
• Dialect coverage — which engines does the lesson page actually run? MySQL? Postgres? BigQuery? Snowflake? SQL Server? Modern interviews increasingly require Postgres / BigQuery / Snowflake fluency; legacy tutorials default to MySQL.
• Depth — how far does the platform go past SELECT * FROM? Window functions, CTEs, recursive queries, query plans, performance, partitioning. Some platforms stop at GROUP BY.
• Audience level — who is the lesson written for? Absolute beginner? Analyst? Senior DE preparing for FAANG? Mismatches here are the #1 reason people abandon a tutorial mid-lesson.

Where PipeCode fits. The other four platforms all teach SQL the language. PipeCode teaches SQL as an interview signal and a job skill. Problems are tagged by the company that historically asked them, by the dialect the employer runs, and by topic — so a candidate prepping for a Meta DE loop drills Meta-tagged problems on Postgres-flavoured syntax, not generic MySQL JOINs. It is intentionally the last step in the journey, not a substitute for the early platforms.

The spoiler. The right answer for almost every learner is a stack — SQLBolt → SQLZoo → Mode → PipeCode for free-only learners, SQLBolt → Mode → DataCamp track → PipeCode for career switchers who want a credential, and Mode windowing → PipeCode 50 problems for the "I have 30 days to land a DE interview" use case. The exact sequence is unpacked in the journey section below.

Worked example — the same SELECT lesson on all four platforms

Detailed explanation. A complete beginner opens each of the four platforms on day one and tries to filter rows from a customers table where the country is 'France'. The platforms each teach the same SQL, but the lesson page, dataset, and runner experience differ wildly. Walking through the same example surfaces what the platform actually optimises for.

Question. Compare how SQLZoo, SQLBolt, Mode SQL Tutorial, and DataCamp SQL each present the lesson "select every customer in France" to a beginner. What does each lesson page look like, what dialect does the runner use, and what is the cognitive load on the learner?

Input. A common customers table with id, name, and country columns; thousands of rows; France is one of dozens of countries.

id	name	country
1	Alice	France
2	Bob	Germany
3	Cara	France
4	Dan	USA

Code.

-- SQLZoo "Helpdesk" / "Nobel" page — generic ANSI, runs on MySQL
SELECT name FROM customers WHERE country = 'France';

-- SQLBolt "Lesson 2: Queries with constraints" — runs on SQLite
SELECT name FROM customers WHERE country = "France";

-- Mode "Intro to SQL" — runs on Mode's Postgres-flavoured engine
SELECT name FROM customers WHERE country = 'France';

-- DataCamp "Introduction to SQL" — runs on the in-browser DataCamp IDE
SELECT name FROM customers WHERE country = 'France';

Step-by-step explanation.

1. SQLZoo presents the lesson as a static HTML page with embedded prose, a runnable code editor below the prose, and the dataset schema documented inline. The dataset is one of SQLZoo's curated classics (world, nobel, movies). The runner submits the query to a server-side MySQL instance and renders the result table below the editor. No login, no progress bar.
2. SQLBolt presents the lesson as a one-screen card: a short prose explanation, a worked code example, and three or four "exercises" with their own runners. The dataset is small (a movies table or similar). No login, no progress saved between sessions; refreshing the page resets state.
3. Mode SQL Tutorial presents the lesson as a full-width article on its marketing site with an in-page Mode editor that runs against the actual Mode product engine — same Postgres-flavoured syntax the user would write at a real analytics job. Datasets are realistic (warehouse_orders, web_events). The lesson links progressively into more advanced sections.
4. DataCamp presents the lesson as a video lecture + in-browser IDE + a quiz, gated behind a login. Each lesson is two-to-three minutes of video, then a graded exercise. Progress is tracked, and completion produces a certificate.

Output.

Platform	Login required?	Dataset	Dialect	Lesson format
SQLZoo	No	World / Nobel / Movies	MySQL	Static page + inline runner
SQLBolt	No	Movies / generic	SQLite (generic ANSI)	Single card per lesson
Mode	No	warehouse_orders / web_events	Mode (Postgres-like)	Long-form article + runner
DataCamp	Yes	DataCamp datasets	Postgres / T-SQL / BigQuery (per track)	Video + IDE + quiz

Rule of thumb. The platform that "wins" for a given learner is the one whose dataset realism, dialect, and lesson format match the goal. A beginner needs SQLBolt's short cards; an analyst needs Mode's real product datasets; an interview prepper needs PipeCode's company-tagged graded problems. Picking the wrong platform is the #1 reason learners stall.

Worked example — the same JOIN lesson, four very different teaching styles

Detailed explanation. Once the learner has SELECT and WHERE, the next universal lesson is "join two tables." Every one of the four platforms has a JOIN lesson — and the way each one introduces JOINs reveals the platform's underlying audience model.

Question. Show how SQLZoo, SQLBolt, Mode, and DataCamp each introduce INNER JOIN. Which one is best for a beginner who has never used relational data?

Input — customers.

id	name
1	Alice
2	Bob

Input — orders.

order_id	customer_id	amount
100	1	50
101	1	30
102	2	20

Code.

-- SQLZoo: thrown straight into the JOIN syntax on the Movies dataset
SELECT title, name
FROM movie JOIN casting ON id = movieid
           JOIN actor ON actorid = actor.id
WHERE name = 'Harrison Ford';

-- SQLBolt: simplest possible 2-table JOIN, then exercises
SELECT c.name, o.amount
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

-- Mode: framed as "combining web events with user profiles"
SELECT u.email, COUNT(*) AS event_count
FROM users u
INNER JOIN web_events e ON e.user_id = u.id
GROUP BY u.email;

-- DataCamp: video explanation + drag-and-drop syntax + quiz
SELECT c.name, o.amount
FROM customers AS c
INNER JOIN orders AS o
  ON c.id = o.customer_id;

Step-by-step explanation.

1. SQLZoo drops the learner into a three-table JOIN on the Movies dataset by lesson 6. The progression is steep — by the time you reach lesson 7 ("More JOIN") you are writing self-joins and outer joins. The site assumes the reader has already internalised set theory mentally. This is great for someone with prior data exposure who needs to drill, bad for an absolute beginner.
2. SQLBolt keeps the JOIN lesson tiny: two tables, one JOIN, three exercises. No window functions, no CTEs, no real-world datasets. The "lessons 6 through 8" sequence covers INNER, OUTER, and self-joins in roughly an hour of reading. Perfect for the first two hours with SQL.
3. Mode frames every JOIN as part of an analytics question: "how many web events did each user produce?" The dataset is realistic (a real web events table) and the lesson explicitly motivates why you would JOIN — to combine events with user metadata. This builds analyst intuition faster than syntax-only tutorials.
4. DataCamp gates the JOIN lesson behind a video (2–3 min) and an IDE exercise. The pacing is deliberately slow; the same JOIN that SQLBolt covers in one card takes DataCamp a full chapter. Good for video learners and for the cert audience.

Output.

Platform	Lesson pacing	Audience signal
SQLZoo	Aggressive — 3-table JOIN by lesson 6	Prior data experience
SQLBolt	Gentle — 2-table JOIN, one card	Absolute beginner
Mode	Question-first — "why JOIN?" before "how JOIN?"	Analyst / BI thinker
DataCamp	Slow — video + IDE + quiz	Video learner / cert seeker

Rule of thumb. Match the JOIN lesson style to your learning preference. Visual learners → DataCamp. Reading-and-doing learners → SQLBolt then SQLZoo. Question-first analyst types → Mode. Interview crammers → skip the tutorials, go straight to PipeCode's JOIN drills with NULL traps and outer joins.

Worked example — what each platform leaves out

Detailed explanation. The gaps are as revealing as the strengths. Every one of the four platforms has a topic it deliberately or accidentally skips — and the gaps almost always show up exactly when the learner needs the topic for a real job.

Question. What does each platform not teach, and which platform fills the gap?

Input. The full surface area of "what a 2026 data role uses SQL for": SELECT, JOIN, GROUP BY, window functions, CTEs, NULL handling, performance, partitioning, JSON, semi-structured data, analytics queries, interview problems.

Code. Not applicable — this is a gap audit.

Step-by-step explanation.

1. SQLZoo gaps — no window functions teaching, no CTE deep dive, no JSON / semi-structured types, no modern dialects beyond MySQL, no performance / query plan content. The UI is also visibly 2003-era.
2. SQLBolt gaps — only 18 lessons; everything past GROUP BY is missing. No window functions, no CTEs, no aggregation patterns beyond basic SUM / AVG, no real-world dataset feel.
3. Mode gaps — only one dialect (Mode's Postgres-flavoured engine). Some analytics-only content; no cert. No company-tagged interview problems. Window functions are taught but performance is shallow.
4. DataCamp gaps — costs money after the intro. The depth per track is structured but not interview-density; you can finish the "Intermediate SQL" track and still not solve a Meta-style window-function question cleanly.
5. PipeCode gaps — focused on DE / analytics engineer interview surface. Does not teach SQL from absolute zero in the way SQLBolt does — assumes the learner already has SELECT / WHERE / JOIN. Pairs naturally with one of the beginner platforms at the start.

Output.

Platform	What it skips	Best filler
SQLZoo	Window functions, CTEs, modern dialect, performance	Mode + PipeCode
SQLBolt	Everything past GROUP BY	SQLZoo + Mode
Mode	Multi-dialect, company-tagged problems, cert	PipeCode (problems) or DataCamp (cert)
DataCamp	Free access, interview-density problems	PipeCode + Mode
PipeCode	Absolute-zero syntax warm-up	SQLBolt for first 2 hours

Rule of thumb. Audit the gap before you commit to a platform. If your goal includes window functions, your platform must teach them — that rules SQLZoo and SQLBolt out as solo choices for an analyst or DE. If your goal includes a credential, only DataCamp issues one. If your goal is interview prep, no tutorial-style platform is enough — you need a problem-density platform.

SQL interview question on choosing the right platform

A common framing from a hiring manager or senior interviewer: "You have a junior analyst joining your team next week. They have never written SQL. You have one week to onboard them before they need to start writing real queries against the warehouse. Walk me through which platforms you would have them use and in what order."

Solution Using a 5-day onboarding stack

-- Day 1: SQLBolt lessons 1–8 (SELECT → JOIN → GROUP BY)
-- Day 2: SQLZoo Nobel + World JOIN drills (1–2 hours)
-- Day 3: Mode "Intermediate SQL" — GROUP BY, HAVING, subqueries
-- Day 4: Mode "Advanced SQL" — window functions, performance
-- Day 5: PipeCode 5 graded problems on the team's real dialect

-- Verification query: have they internalised the basics?
SELECT
    LessonLabel              AS milestone,
    EstHours                 AS expected_hours,
    Goal                     AS skill_goal
FROM onboarding_plan
WHERE WeekNumber = 1
ORDER BY DayNumber;

Step-by-step trace.

Day	Platform	Lessons	Skill check
1	SQLBolt	Lessons 1–8	Can write SELECT, WHERE, JOIN, GROUP BY against a small table
2	SQLZoo	Nobel + World JOIN drills	Can write 2- and 3-table JOIN by hand without copy-paste
3	Mode	Intermediate SQL chapter	Can use HAVING and subqueries; can write a self-join
4	Mode	Advanced SQL chapter	Can write ROW_NUMBER / RANK and explain when each wins
5	PipeCode	5 graded problems on Postgres	Can solve a real interview-style problem unaided in under 30 min

The plan covers absolute-zero syntax (SQLBolt day 1) through analyst-level windowing (Mode day 4) to graded real-problem repetition (PipeCode day 5) — exactly the ramp a junior analyst needs to be useful by week two.

Output:

metric	value
Days to "writing real queries"	5
Free platforms used	4 (SQLBolt, SQLZoo, Mode, PipeCode free tier)
Paid platforms used	0
Lessons covered	~30
Graded problems solved	5

Why this works — concept by concept:

• Sequenced by depth, not by brand — each day pushes the learner one step further. SQLBolt warms syntax muscles; SQLZoo drills JOINs until they are automatic; Mode adds analyst thinking; PipeCode tests under interview conditions.
• Free-first stack — all five days use free content. The team can scale the program to a whole cohort without a budget conversation.
• Dialect-correct on day 5 — PipeCode lets the learner pick the dialect the team actually runs (Postgres / BigQuery / Snowflake), so day-5 fluency is directly applicable to day-6 production tickets.
• Verification by graded output — a junior who can pass 5 PipeCode problems in one sitting is measurably warehouse-ready in a way "I finished a DataCamp track" never proves.
• Cost — zero dollars, ~25 hours of learner time, ~2 hours of mentor time over the week. The cheapest junior-onboarding plan that produces a productive analyst at the end.

SQL
Topic — sql
SQL practice library (warehouse-grade)

Practice →

---

2. Feature-by-feature matrix — 5 platforms, 5 axes

Receipts on the table — the 5x5 matrix grades all five platforms on the things learners actually care about

The mental model in one line: sql practice platforms are not interchangeable — each one wins on one or two axes and loses on the others, so the matrix is the only honest way to compare them. Once you internalise the five axes (free tier, interactivity, dialect coverage, depth, audience level), you can pick the right stack in two minutes instead of two months of trial-and-error.

The matrix at a glance.

Axis	SQLZoo	SQLBolt	Mode	DataCamp	PipeCode
Free tier	Full free	Full free	Full free	Paid after intro	Generous free
Interactive runner	In-browser	Inline runner	Mode editor	Browser IDE	Multi-dialect IDE
Dialect	MySQL + partial Postgres	Generic ANSI / SQLite	Mode (Postgres-like)	MySQL / Postgres / T-SQL / BigQuery (separate tracks)	Postgres / BigQuery / Snowflake / MySQL
Depth	Beginner → Intermediate	Shallow (18 lessons)	Intermediate (window functions)	Intermediate (cert-flavoured)	Beginner → Senior (interview)
Audience	Beginners + JOIN drillers	Absolute beginners	Analysts / BI	Career switchers / cert seekers	DEs / analytics engineers / interview candidates

Axis 1 — Free tier.

• SQLZoo, SQLBolt, Mode — all genuinely free. No login required for SQLZoo and SQLBolt; Mode requires a free Mode account but the tutorial pages are publicly accessible.
• DataCamp — only the first chapter of "Introduction to SQL" is free; all other tracks (Intermediate SQL, Joining Data, T-SQL, BigQuery, dbt) are behind the $25–$35/month subscription.
• PipeCode — generous free tier covering the bulk of the practice library; the paid tier unlocks senior-DE courses, premium mocks, and detailed performance analytics.

Axis 2 — Interactive runner.

• All five have an interactive code editor that runs against a real database — but the quality varies. SQLBolt's runner is the snappiest for the first two hours. Mode's runner is the closest to a real warehouse experience. DataCamp's runner is structured and graded. PipeCode's runner offers a dialect dropdown so the same problem can be solved on Postgres, BigQuery, or Snowflake. SQLZoo's runner is functional but feels 2003.

Axis 3 — Dialect coverage.

• SQLZoo — primarily MySQL with some partial Postgres pages.
• SQLBolt — generic ANSI with SQLite-style semantics under the hood.
• Mode — Mode's Postgres-flavoured engine; one dialect end-to-end.
• DataCamp — broad: MySQL, Postgres, T-SQL, BigQuery are each their own paid course track.
• PipeCode — Postgres / BigQuery / Snowflake / MySQL switchable per problem; the only platform built around the 2026 modern stack of cloud dialects.

Axis 4 — Depth.

• SQLZoo — JOIN drills are deep; window functions are absent.
• SQLBolt — deliberately shallow; 18 lessons total.
• Mode — the Advanced section covers window functions and BI patterns well; performance and partitioning are light.
• DataCamp — intermediate-flavoured, structured. Each track has a clear narrative but stops short of senior-interview density.
• PipeCode — beginner-to-senior; the topic taxonomy includes window functions, recursive CTEs, NULL handling, JSON, performance.

Axis 5 — Audience level.

• SQLZoo — beginner with prior data exposure; JOIN drillers.
• SQLBolt — absolute beginner; first two hours.
• Mode — analyst / BI / analytics-engineer onboarding.
• DataCamp — career switchers and certificate seekers.
• PipeCode — interview candidates, modern-stack DEs, mid-to-senior analytics engineers.

Quick verdict per platform.

• SQLZoo wins when the learner needs raw JOIN and aggregation reps and does not care about modernity.
• SQLBolt wins the first two hours, then it runs out of content.
• Mode wins for analyst onboarding; teach me window functions on real datasets.
• DataCamp wins when a learner needs a structured curriculum, video lectures, and a downloadable certificate for LinkedIn.
• PipeCode wins the interview prep axis end-to-end.

Where each platform breaks.

• SQLZoo breaks when the team migrates off MySQL onto BigQuery or Snowflake — the lessons no longer match the engine.
• SQLBolt breaks at the end of lesson 18; there is nowhere to go.
• Mode breaks when the learner needs multi-dialect fluency; everything is in Mode-flavoured Postgres.
• DataCamp breaks when the budget runs out or when interview density is needed (videos do not substitute for graded problems).
• PipeCode pairs rather than competes with the early platforms — it is the natural endpoint, not a substitute for SQLBolt's first two hours.

Worked example — grading the same "rank top 3 products per category" problem across the five platforms

Detailed explanation. A classic intermediate interview problem: rank products by revenue within each category, return the top 3 per category. Every platform with a window-function lesson covers this — but only some teach it well enough that a learner can solve it cold.

Question. Which platforms teach the "top N per group" pattern well enough that a learner can write the query unaided after finishing the lesson?

Input — sales.

product	category	revenue
A	Electronics	1200
B	Electronics	900
C	Electronics	700
D	Electronics	500
E	Books	200
F	Books	150

Code.

-- The canonical window-function answer (Postgres / Snowflake / BigQuery)
SELECT product, category, revenue
FROM (
    SELECT
        product,
        category,
        revenue,
        ROW_NUMBER() OVER (PARTITION BY category ORDER BY revenue DESC) AS rn
    FROM sales
) ranked
WHERE rn <= 3;

Step-by-step explanation.

1. SQLZoo does not teach window functions explicitly; the closest pattern is a self-join + aggregate which is correct but clumsy. A SQLZoo-only learner cannot solve this problem cleanly.
2. SQLBolt does not cover window functions at all. Lesson 18 ends well before this topic.
3. Mode "Advanced SQL" section teaches window functions, including ROW_NUMBER and PARTITION BY, and includes an "exercise: find top product per category." A Mode-trained learner can solve this confidently.
4. DataCamp's "PostgreSQL Summary Stats and Window Functions" track covers ROW_NUMBER, RANK, DENSE_RANK with worked examples and graded quizzes. A DataCamp-trained learner can solve this.
5. PipeCode has dozens of "top N per group" problems tagged under window functions and ranking, each with the canonical solution and the common wrong-answer trap (using RANK and getting ties).

Output.

Platform	Can solve unaided?	Notes
SQLZoo	No	No windowing lesson
SQLBolt	No	Stops at GROUP BY
Mode	Yes	Advanced section covers it
DataCamp	Yes	Dedicated window-function track
PipeCode	Yes — and faster	Tagged problems with traces

Rule of thumb. If the goal includes window functions (and for any 2026 data role it should), Mode or DataCamp or PipeCode are required. SQLZoo and SQLBolt alone are not enough.

Worked example — same "find duplicate rows" problem, four platform takes

Detailed explanation. A foundational data-quality problem: find rows where a key column has duplicates. Each platform's coverage of this pattern reveals how much they care about real-world data hygiene as opposed to syntax-only exercises.

Question. Show the canonical "find duplicates" query and rank how well each platform's lesson library prepares a learner to write it cold.

Input — customers.

customer_id	email
1	[e-mail]
2	[e-mail]
3	[e-mail]
4	[e-mail]
5	[e-mail]

Code.

-- Canonical "find duplicate emails"
SELECT email, COUNT(*) AS dup_count
FROM customers
GROUP BY email
HAVING COUNT(*) > 1;

-- Variant: list the customer_ids that share an email
SELECT email, ARRAY_AGG(customer_id) AS ids
FROM customers
GROUP BY email
HAVING COUNT(*) > 1;

Step-by-step explanation.

1. SQLZoo covers GROUP BY + HAVING in its core lesson set; a SQLZoo learner can write the COUNT-based version cleanly.
2. SQLBolt introduces HAVING in lesson 9 — but the example uses HAVING SUM > 100, not "find duplicates." A SQLBolt-only learner may write it after a hint.
3. Mode explicitly frames this pattern as "find user emails with multiple sign-ups," tying it to a real product analytics use case. A Mode learner internalises the pattern and the use case.
4. DataCamp covers HAVING in its "Intermediate SQL" track with quizzes; the lesson is solid but the example is generic.
5. PipeCode has dozens of duplicate-detection problems with company tags (data-quality interviews at Stripe, Airbnb, ByteDance). A PipeCode user solves "find duplicates" in their sleep.

Output.

Platform	Lesson clarity for "find duplicates"
SQLZoo	High — GROUP BY + HAVING pattern covered
SQLBolt	Medium — HAVING introduced, example weak
Mode	High — framed in a real product use case
DataCamp	High — structured with quiz
PipeCode	Highest — graded problems with traces

Rule of thumb. "Find duplicates" is the litmus-test query for whether a learner has internalised GROUP BY + HAVING. If they cannot write it in 60 seconds, they are not yet warehouse-ready — regardless of which platform they used.

SQL interview question on choosing platforms by goal

The probe a senior interviewer uses to test whether a candidate can think about learning resources: "Pretend you are mentoring three people — a complete beginner, an analyst onboarding into Snowflake, and a candidate prepping for a Meta DE loop. Recommend the right platform stack for each, and justify the choice in one sentence each."

Solution Using goal-driven platform selection

-- The matching algorithm, expressed as SQL
WITH goals (learner, primary_goal, time_budget, dialect_target) AS (
    VALUES
        ('Complete beginner', 'first 2 hours with SQL', '5 days',  'any'),
        ('Analyst onboarding', 'analyst chops + Snowflake', '2 weeks', 'Snowflake'),
        ('Meta DE candidate', 'interview prep', '6 weeks', 'Postgres')
)
SELECT
    learner,
    primary_goal,
    CASE
        WHEN primary_goal = 'first 2 hours with SQL'
             THEN 'SQLBolt (1-2d) -> SQLZoo (3d) -> Mode basics (3d)'
        WHEN primary_goal = 'analyst chops + Snowflake'
             THEN 'Mode SQL Tutorial -> PipeCode Snowflake-tagged drills'
        WHEN primary_goal = 'interview prep'
             THEN 'Mode windowing -> PipeCode 50 problems on Postgres + Meta-tagged set'
    END AS recommended_stack
FROM goals;

Step-by-step trace.

Learner	Primary goal	Time budget	Recommended stack
Complete beginner	First 2 hours with SQL	5 days	SQLBolt → SQLZoo → Mode basics
Analyst onboarding	Analyst chops + Snowflake	2 weeks	Mode SQL Tutorial → PipeCode Snowflake drills
Meta DE candidate	Interview prep	6 weeks	Mode windowing → PipeCode 50 problems + Meta-tagged set

Each recommendation maps the learner's goal to two platforms — never one. The beginner needs syntax + JOIN drills + first analytics intuition. The analyst needs Mode for windowing + PipeCode for dialect-correct reps on Snowflake. The interview candidate skips beginner platforms entirely and goes from Mode straight to PipeCode for graded reps.

Output:

metric	value
Recommendations	3
Free platforms in every stack	yes
Paid optional layer	DataCamp track (not required for any of the three)
Average platforms per learner	2

Why this works — concept by concept:

• Stack over single platform — every recommendation is a sequence of two platforms, not a single brand. This matches the empirical reality that no platform covers the whole DE / analyst surface.
• Goal-driven, not brand-driven — the platform is picked because of what the learner needs to learn next, not because of platform name recognition.
• Dialect-correct on the last step — the final step in each stack uses the dialect the learner's target job actually runs (Snowflake for the analyst, Postgres for the DE candidate).
• Free-first — none of the recommendations require DataCamp's paid track unless the learner specifically wants a credential.
• Cost — pure planning cost; learner-side time budget is 5 days / 2 weeks / 6 weeks respectively. Zero dollars at the minimum tier.

SQL
Topic — aggregation
Aggregation drills (SQL)

Practice →

---

3. Dialect coverage map — which platform teaches which engine

Six dialects, five platforms, one transferable core — match the platform to the engine your target job actually runs

The mental model in one line: dialect is the single most under-discussed axis of SQL learning — the SELECT / WHERE / JOIN core is portable, but window-function syntax, date arithmetic, JSON handling, and type semantics diverge sharply between MySQL, Postgres, BigQuery, Snowflake, SQL Server, and SQLite. Picking a platform that teaches the wrong dialect is how learners end up "fluent on paper" and frozen on the keyboard at a real job.

The dialect map at a glance.

Platform	MySQL	PostgreSQL	BigQuery	Snowflake	SQL Server	SQLite
SQLZoo	Good	Partial	None	None	None	None
SQLBolt	Generic	Generic	None	None	None	Good
Mode	None	Postgres-like	Partial	None	None	None
DataCamp	Track	Track	Separate track	Snippets	Track	None
PipeCode	Yes	Primary	Yes	Yes	Planned	None

Which platform teaches which engine in detail.

• MySQL — SQLZoo (good), SQLBolt (generic ANSI), DataCamp (yes via its MySQL track). Most legacy SQL learners learn MySQL because of historical defaults. Modern hires increasingly need Postgres or BigQuery instead.
• PostgreSQL — Partial on SQLZoo, the de-facto engine on Mode (Mode's runner is Postgres-flavoured), full track on DataCamp, primary on PipeCode. The 2026 default for new analytics teams and most cloud warehouses' SQL surface.
• BigQuery — Partial on Mode (Mode supports BigQuery connectors), separate paid course on DataCamp, yes on PipeCode. The Google Cloud default; every modern data role at a GCP-heavy company tests BigQuery SQL.
• Snowflake — None on SQLZoo / SQLBolt; brief snippets on DataCamp; yes on PipeCode. The dominant cloud warehouse SQL surface for many fintech / analytics teams; surprisingly thin coverage outside dedicated paid courses.
• SQL Server (T-SQL) — Full track on DataCamp, planned on PipeCode, none on the rest. Microsoft shops still run T-SQL; everyone else can usually skip it.
• SQLite — Good on SQLBolt (its lesson runner is essentially SQLite-flavoured). Useful for laptop-first beginners; rarely a job dialect.

Why dialect matters in 2026.

• Window function syntax — Postgres / BigQuery / Snowflake all support ROWS BETWEEN ... PRECEDING AND CURRENT ROW, but the exact framing keywords and the way RANGE interacts with NULLs differ. MySQL only added windowing in 8.0 (2018) and lags in feature coverage.
• Date arithmetic — every engine spells "30 days ago" differently. DATE_ADD(CURRENT_DATE, INTERVAL -30 DAY) (MySQL), CURRENT_DATE - INTERVAL '30 day' (Postgres), DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY) (BigQuery), DATEADD(day, -30, CURRENT_DATE()) (Snowflake), DATEADD(day, -30, GETDATE()) (SQL Server). Five engines, five spellings.
• JSON handling — Postgres uses -> and ->> operators; BigQuery uses JSON_VALUE and JSON_EXTRACT; Snowflake uses the : syntax (payload:user.id); MySQL uses JSON_EXTRACT(payload, '$.user.id'); SQL Server uses JSON_VALUE similarly to BigQuery.
• String functions — || (Postgres / Snowflake / Oracle) vs CONCAT(a, b) (MySQL / SQL Server / BigQuery) vs + (SQL Server only). Same operation, three syntaxes.
• Modern stack hires test BigQuery / Snowflake — not MySQL. A learner who only knows MySQL is at a measurable disadvantage in 2026 cloud-DE loops.

The transferable core.

• SELECT, WHERE, GROUP BY, HAVING, basic JOIN (INNER / LEFT / RIGHT / FULL), basic CTE — these are portable everywhere. Most of SQLBolt and the first half of SQLZoo teach this core.
• Window functions are portable in syntax but vary in available functions (e.g., PERCENTILE_CONT is Postgres / Snowflake only).
• Type casting (CAST, ::) is portable in spirit but the exact target type names differ (INTEGER vs INT64 vs NUMBER).

Worked example — same window query, four different dialects

Detailed explanation. "Rank customers by lifetime value within each region, return the top customer per region." A textbook window-function problem. The query concept is portable; the syntax is not — and the differences are exactly what trip up a learner whose tutorial taught the wrong dialect.

Question. Write the canonical "top customer per region by LTV" query in four dialects and highlight the syntactic differences.

Input — customers.

customer_id	region	ltv
1	EU	1200
2	EU	800
3	US	1500
4	US	1100
5	APAC	600

Code.

-- PostgreSQL / Snowflake — IS standard; supports DISTINCT inside the window
SELECT customer_id, region, ltv
FROM (
    SELECT
        customer_id, region, ltv,
        ROW_NUMBER() OVER (PARTITION BY region ORDER BY ltv DESC) AS rn
    FROM customers
) ranked
WHERE rn = 1;

-- BigQuery — same syntax but date / type functions diverge
SELECT customer_id, region, ltv
FROM (
    SELECT
        customer_id, region, ltv,
        ROW_NUMBER() OVER (PARTITION BY region ORDER BY ltv DESC) AS rn
    FROM customers
) AS ranked
WHERE rn = 1;

-- MySQL 8.0+ — windowing supported, but older shops may need a subquery hack
SELECT customer_id, region, ltv
FROM (
    SELECT
        customer_id, region, ltv,
        ROW_NUMBER() OVER (PARTITION BY region ORDER BY ltv DESC) AS rn
    FROM customers
) ranked
WHERE rn = 1;

-- SQL Server (T-SQL) — same window syntax + must alias subquery
SELECT customer_id, region, ltv
FROM (
    SELECT
        customer_id, region, ltv,
        ROW_NUMBER() OVER (PARTITION BY region ORDER BY ltv DESC) AS rn
    FROM customers
) AS ranked
WHERE rn = 1;

Step-by-step explanation.

1. The four queries are syntactically nearly identical at the window-function level — but the dialect quirks matter at scale.
2. Postgres / Snowflake — additionally supports WHERE rn = 1 directly in some warehouse SQL extensions (the Postgres LATERAL join makes per-group selection elegant).
3. BigQuery — requires AS keyword on subquery aliases more strictly than Postgres; otherwise identical at this level. Date and JSON functions diverge sharply elsewhere.
4. MySQL — was added in 8.0 (2018). Older MySQL 5.x deployments require the user-variable trick: SET @rn := IF(@region = region, @rn + 1, 1) — a sign of an old codebase.
5. SQL Server (T-SQL) — strictly requires subquery aliases; otherwise window function syntax is identical to the ANSI standard.

Output.

customer_id	region	ltv
1	EU	1200
3	US	1500
5	APAC	600

Rule of thumb. Window function syntax is portable. Date arithmetic, JSON, and string concatenation are not. When you switch dialect, learn the new versions of those four families first — everything else transfers.

Worked example — same date filter, five different dialects

Detailed explanation. "Find every order in the last 30 days." Five engines, five distinct syntaxes — and migrating a query between them is one of the most common reasons SQL learners feel "I knew this but it does not work here."

Question. Write WHERE order_date >= today - 30 days in MySQL, Postgres, BigQuery, Snowflake, and SQL Server.

Input. Any orders table with order_date as DATE.

Code.

-- MySQL
WHERE order_date >= DATE_ADD(CURRENT_DATE, INTERVAL -30 DAY);

-- PostgreSQL
WHERE order_date >= CURRENT_DATE - INTERVAL '30 days';

-- BigQuery
WHERE order_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY);

-- Snowflake
WHERE order_date >= DATEADD(day, -30, CURRENT_DATE());

-- SQL Server
WHERE order_date >= DATEADD(day, -30, CAST(GETDATE() AS DATE));

Step-by-step explanation.

1. Every engine has a "today minus N days" idiom — and every engine spells it differently.
2. MySQL uses DATE_ADD(date, INTERVAL n unit) with a negative N for subtraction.
3. PostgreSQL uses operator arithmetic: CURRENT_DATE - INTERVAL '30 days' (note the quoted string and plural unit).
4. BigQuery uses the explicit DATE_SUB function and requires CURRENT_DATE() with parentheses.
5. Snowflake uses DATEADD(part, value, date) like SQL Server, with a positional unit argument first.
6. SQL Server uses DATEADD(part, value, date) but reads "today" as GETDATE() which returns a DATETIME — usually cast to DATE for date-only filtering.

Output. Each query returns the same logical row set when run on its own engine; cross-engine paste will fail on every dialect except the one it was written for.

Dialect	Today function	Subtract syntax
MySQL	CURRENT_DATE	DATE_ADD(..., INTERVAL -30 DAY)
Postgres	CURRENT_DATE	... - INTERVAL '30 days'
BigQuery	CURRENT_DATE()	DATE_SUB(..., INTERVAL 30 DAY)
Snowflake	CURRENT_DATE()	DATEADD(day, -30, ...)
SQL Server	GETDATE() (DATETIME)	DATEADD(day, -30, ...)

Rule of thumb. Every time you migrate a query across engines, audit date arithmetic first. It is the single most common cause of cross-dialect breakage and the one that costs the most engineer-hours per bug.

Worked example — same JSON access pattern, four very different syntaxes

Detailed explanation. Pulling a field out of a JSON column is a 2026 default for analytics queries — and is the dialect axis where divergence is the most painful. Mode and SQLZoo do not teach JSON at all; PipeCode and DataCamp do.

Question. Given a payload column containing JSON {"user": {"id": 42, "country": "FR"}}, extract the country field in four dialects.

Input. events(event_id INT, payload JSON).

Code.

-- PostgreSQL — arrow operators
SELECT payload -> 'user' ->> 'country' AS country FROM events;

-- BigQuery — JSON_VALUE
SELECT JSON_VALUE(payload, '$.user.country') AS country FROM events;

-- Snowflake — colon path
SELECT payload:user.country::STRING AS country FROM events;

-- MySQL — JSON_EXTRACT + unquote
SELECT JSON_UNQUOTE(JSON_EXTRACT(payload, '$.user.country')) AS country FROM events;

Step-by-step explanation.

1. Postgres uses -> (returns JSON) and ->> (returns TEXT). Chaining them lets you walk the structure and end with a text value.
2. BigQuery uses the path-expression JSON_VALUE(col, '$.path.to.field') — the cleanest of the four for analytics.
3. Snowflake uses the colon-path notation with an explicit type cast (::STRING). Idiomatic Snowflake JSON access is the shortest of the four.
4. MySQL requires the JSON_UNQUOTE(JSON_EXTRACT(...)) combination — extract returns a quoted JSON string; unquote strips the surrounding quotes to give the plain text value.

Output.

Dialect	Syntax style	One-liner length
Postgres	Arrow operators	Medium
BigQuery	Path expression	Medium
Snowflake	Colon path + cast	Shortest
MySQL	Function nesting	Longest

Rule of thumb. JSON access is the canary in the dialect coalmine. If a tutorial never teaches JSON, it is implicitly assuming you only handle relational columns — which rules it out for any modern analytics-engineer or DE role.

SQL interview question on dialect transfer

A common framing from a hiring manager: "Your team is migrating an existing BI workload from MySQL to Snowflake. The legacy queries use MySQL idioms heavily — DATE_ADD, IFNULL, backticks, no window functions. How would you approach the rewrite?"

Solution Using a dialect-translation checklist

-- The translation table the team uses
WITH translation_rules (mysql_idiom, snowflake_equivalent, action) AS (
    VALUES
        ('DATE_ADD(d, INTERVAL n DAY)', 'DATEADD(day, n, d)', 'replace'),
        ('IFNULL(a, b)',                'COALESCE(a, b)',     'replace'),
        ('`identifier`',                '"identifier"',       'replace'),
        ('GROUP_CONCAT(x)',             'LISTAGG(x, '','')',  'replace'),
        ('User-variable window hack',   'ROW_NUMBER() OVER',  'rewrite'),
        ('JSON_EXTRACT + JSON_UNQUOTE', 'payload:path::STRING', 'rewrite')
)
SELECT mysql_idiom, snowflake_equivalent, action
FROM translation_rules;

Step-by-step trace.

Step	MySQL idiom	Snowflake equivalent
1	DATE_ADD(d, INTERVAL n DAY)	DATEADD(day, n, d)
2	IFNULL(a, b)	COALESCE(a, b)
3	backticks \x``	double quotes "x"
4	GROUP_CONCAT(x)	LISTAGG(x, ',')
5	User-variable rank hack	ROW_NUMBER() OVER (...)
6	JSON_EXTRACT + JSON_UNQUOTE	payload:user.id::STRING

The migration moves through each idiom systematically. The biggest wins are step 5 (the user-variable hack is replaced with native windowing) and step 6 (JSON access becomes one line instead of two function calls).

Output:

metric	value
Idioms translated	6
Native Snowflake features unlocked	window functions, LISTAGG, colon-path JSON
Estimated query-runtime improvement	30–80% on windowed queries
Lines-of-code reduction	~15% on JSON-heavy queries

Why this works — concept by concept:

• Idiom-by-idiom translation table — eliminates "translate as I go" guesswork. Every legacy idiom maps to a single modern equivalent.
• Native windowing replaces hacks — moving from user-variable rank to ROW_NUMBER() is both correct and faster; the optimiser can plan windows but not arbitrary user-variable assignments.
• JSON access becomes idiomatic — colon-path is concise and is the form interview question setters use in Snowflake-flavoured probes.
• NULL handling unified on COALESCE — replacing IFNULL with COALESCE aligns the codebase with the ANSI standard and unblocks future moves to BigQuery / Postgres.
• Cost — one rewrite pass per query, automatable to ~70% with regex on the easy idioms. The remaining 30% (windowing, JSON paths) requires hand review but unlocks substantial perf and clarity wins.

SQL
Topic — window functions
Window function drills (SQL)

Practice →

---

4. The recommended learning journey — zero to hero

Five steps, two of them optional — sequence the platforms by depth, not by brand recognition

The mental model in one line: the right path is SQLBolt → SQLZoo → Mode → (DataCamp optional) → PipeCode, each step adding one new layer of skill and dialect fluency — and you almost never need to finish one platform before starting the next. The biggest mistake is "I must complete every SQLBolt lesson before moving on" — that is how learners stall for months on syntax they already know.

The five-step ladder.

• Step 1 — SQLBolt (1–2 days). Eighteen short lessons. The goal: muscle memory for SELECT, WHERE, JOIN, GROUP BY. Skip if you already know syntax.
• Step 2 — SQLZoo (1–2 weeks). Drill JOINs and aggregations on the World, Nobel, and Movies datasets. The goal: write 3-table joins without copy-paste. Stop when you can solve the SELF JOIN page without hints.
• Step 3 — Mode SQL Tutorial (1 week). Work through Basic → Intermediate → Advanced. The goal: window functions, analytics-SQL framing, and the BI mindset. This is where you learn to think in queries.
• Step 4 — DataCamp Data Engineer track (optional, paid, 1–2 months). Structured curriculum + certificate. The goal: a credential for HR/LinkedIn signal and a video-format reinforcement of everything you already know. Skip if you do not need the credential.
• Step 5 — PipeCode (ongoing). Company-tagged interview problems on modern dialects + mock interviews. The goal: real interview density and dialect-correct fluency on the engine your target job runs.

Step 1 in detail — SQLBolt (1–2 days).

• Lessons 1–4 — SELECT, WHERE, constraints. One sitting.
• Lessons 5–8 — JOIN, OUTER JOIN, NULL, expressions. Second sitting.
• Lessons 9–13 — INSERT, UPDATE, DELETE, CREATE, ALTER, DROP. Read once; you will not write DDL much as an analyst.
• Lessons 14–18 — Subqueries, UNION, and a final practice section. Third sitting.
• What you skip — none of it; SQLBolt is the smallest of the four free platforms.
• What you do not get — window functions, CTEs, performance, modern dialects.

Step 2 in detail — SQLZoo (1–2 weeks).

• Tutorials 0–5 — SELECT BASICS, FROM WORLD, FROM NOBEL, SELECT FROM WORLD, SELECT IN SELECT, SUM and COUNT. The "warm" half — should take 2–3 hours total.
• Tutorial 6 — JOIN. The most-googled SQLZoo page on the entire internet. World Cup dataset; the lesson teaches 2-, 3-, and 4-table joins. Plan 2–3 hours.
• Tutorial 7 — More JOIN. Movies dataset; harder. Plan another 2–3 hours.
• Tutorial 8 — Using NULL. The most realistic NULL exercises on the public web. Plan 1 hour.
• Tutorial 9 — Window functions — only added recently; light coverage. Skim and move on.
• Tutorial 10+ — Self-JOIN, NSS Tutorial, etc. Optional reps.
• What you skip — anything past tutorial 9 if you are short on time; come back to it later.

Step 3 in detail — Mode SQL Tutorial (1 week).

• Basic SQL — SELECT, LIMIT, ORDER BY, WHERE, comparison operators. Skip if SQLBolt + SQLZoo are done.
• Intermediate SQL — GROUP BY, HAVING, CASE, DISTINCT, JOIN, UNION. The "consolidation" layer.
• Advanced SQL — window functions, performance tuning, pivoting with CASE, full-text search. The chapter that earns the platform its reputation.
• Analytics training — the optional "becoming an analyst" track. Worth skimming for the mindset, not for the syntax.
• What you skip — the Mode-product-specific sections if you do not use Mode at your job.
• What you get — analyst-grade SQL on a Postgres-flavoured engine with real product datasets.

Step 4 in detail — DataCamp Data Engineer track (optional).

• When to use it — if you need a LinkedIn-grade credential, or if you are a video learner who needs structured pacing.
• When to skip — if you already have Mode + PipeCode and are short on cash. DataCamp does not teach much that Mode + PipeCode do not cover; the value is in the format, not the content.
• What the track includes — "Intro to SQL", "Joining Data", "Intermediate SQL", "PostgreSQL Summary Stats and Window Functions", "Exploratory Data Analysis in SQL". Plus the optional T-SQL or BigQuery track if your target job runs those.
• Time budget — 1–2 months at 5 hours/week. Plus the monthly subscription ($25–$35) for the duration.

Step 5 in detail — PipeCode (ongoing).

• Where to start — Postgres tagged problems if your target job is cloud-warehouse-flavoured (most modern roles); BigQuery for GCP shops; Snowflake for fintech / mid-market analytics.
• First 10 problems — focus on aggregation, joins, and CASE WHEN. These reinforce the Mode foundations on a dialect-correct runner.
• Next 20 problems — window functions and ranking. The interview backbone.
• Final 20 problems before a loop — company-tagged set for your target employer (Meta, Stripe, Airbnb, Snowflake, ByteDance).
• What you get — graded reps, time-pressure simulation, dialect-correct syntax, company-tagged authenticity.

The honest skip list.

• Skip SQLBolt if you already know SELECT / WHERE / JOIN / GROUP BY.
• Skip SQLZoo if you have 6+ months of warehouse SQL experience.
• Skip Mode basic and intermediate if SQLZoo is already done; jump straight to the Advanced chapter for window functions.
• Skip DataCamp unless you specifically want the credential.
• Skip PipeCode only if you are not interviewing in the next 6 months. Otherwise it is the single highest-ROI step in the journey.

The "30 days to land a DE interview" fast track.

• Day 1–3 — SQLBolt (assume rusty syntax).
• Day 4–10 — Mode "Intermediate" + "Advanced SQL" chapters; window functions become automatic.
• Day 11–30 — PipeCode 50 problems on the target dialect, including company-tagged sets for the employers you have loops scheduled with.
• Total time — ~50 hours of focused practice.
• Cost — $0 (free tiers only) or ~$25/month if DataCamp is added.

Worked example — a 5-day onboarding plan for a junior analyst

Detailed explanation. A new junior analyst joins on Monday with zero SQL. They need to be writing real warehouse queries by Friday. The platform stack below covers exactly this case, using only free tools.

Question. Lay out a 5-day plan that takes a complete beginner to "writing real warehouse queries unaided."

Input. Calendar: Mon → Fri. Learner: complete SQL beginner. Goal: useful by week 2.

Code. Not applicable — this is a curriculum.

Step-by-step explanation.

1. Monday — SQLBolt lessons 1–8. SELECT, WHERE, JOIN. 3–4 hours of focused work.
2. Tuesday — SQLBolt lessons 9–18 + SQLZoo tutorials 0–5. Finish SQLBolt; start SQLZoo basics. 4–5 hours.
3. Wednesday — SQLZoo tutorials 6–7 (JOIN + MORE JOIN). 3–4 hours. By end of day, can write 3-table JOIN unaided.
4. Thursday — Mode "Intermediate SQL" chapter. GROUP BY, HAVING, CASE, subqueries on real datasets. 4–5 hours.
5. Friday — PipeCode: 5 graded problems on the team's dialect (Postgres / BigQuery / Snowflake). 2–3 hours. End of day: can write a real warehouse query against a real table cold.

Output.

Day	Platform	Outcome
Monday	SQLBolt	SELECT / WHERE / JOIN syntax
Tuesday	SQLBolt + SQLZoo	Full SQLBolt; SQLZoo basics
Wednesday	SQLZoo	3-table JOIN automatic
Thursday	Mode	GROUP BY + HAVING + CASE on real data
Friday	PipeCode	5 graded warehouse-style problems solved

Rule of thumb. A junior who follows this 5-day plan is measurably faster to productive than one who tries to "complete a DataCamp track over 3 months." Density of practice beats breadth of curriculum at the beginner stage.

Worked example — 6-week DE interview prep plan

Detailed explanation. A candidate has a Meta DE loop in 6 weeks. They are an experienced analyst but have never solved interview-style window-function problems under time pressure. The plan: skip the early platforms, focus on Mode windowing for 1 week, then 5 weeks of PipeCode reps.

Question. Plan 6 weeks of focused interview prep for a candidate with prior SQL experience.

Input. 6 calendar weeks. ~10 hours/week of focused practice time. Target: Meta DE loop.

Code. Not applicable — this is a curriculum.

Step-by-step explanation.

1. Week 1 — Mode "Advanced SQL" chapter. Window functions, performance, pivoting. ~10 hours. Goal: write ROW_NUMBER, RANK, LAG / LEAD cold.
2. Week 2 — PipeCode window function tagged set (20 problems). Build muscle memory on Postgres-flavoured syntax with graded feedback. ~10 hours.
3. Week 3 — PipeCode joins + CTE tagged set (15 problems). Cover the JOIN-heavy probes. ~10 hours.
4. Week 4 — PipeCode aggregation + NULL handling tagged set (15 problems). Plug the silent-bug gaps. ~10 hours.
5. Week 5 — PipeCode Meta-company-tagged set (15+ problems). Mimic the exact distribution Meta DE loops are known to pull from. ~10 hours.
6. Week 6 — Mock interviews + 1 final pass through every problem you got wrong. ~10 hours.

Output.

Week	Focus	Problems solved
1	Mode Advanced (windowing)	~5 worked exercises
2	PipeCode windowing	20
3	PipeCode JOIN + CTE	15
4	PipeCode aggregation + NULL	15
5	PipeCode Meta-tagged	15+
6	Mocks + review	0 new — review only

Rule of thumb. Interview prep is about density of representative problems under time pressure, not about completing more curriculum. After week 1's Mode-driven knowledge load, every remaining week is graded reps on the dialect and company distribution the loop uses.

Worked example — onboarding an analytics engineer

Detailed explanation. An analytics engineer joins the team. They know SQL well but need dbt + warehouse-specific dialects + dimensional modelling. The platform stack below covers the SQL side; pair it with dbt's own docs for the orchestration layer.

Question. Recommend a SQL platform stack for an analytics-engineer onboarding into a Snowflake + dbt shop.

Input. Senior IC, prior MySQL experience, no Snowflake exposure.

Code. Not applicable — this is a curriculum.

Step-by-step explanation.

1. Mode Advanced SQL chapter — refresh window functions on Postgres-flavoured syntax. Free, 1 week.
2. DataCamp "Intermediate SQL Server" or the Snowflake-relevant track — only if dialect-specific structured material is needed; usually optional. Paid, 2 weeks.
3. PipeCode Snowflake-tagged problems (20–30 problems) — dialect-correct fluency on colon-path JSON, LISTAGG, DATEADD, and warehouse-flavoured CTE patterns. Free tier + optional paid course. 3–4 weeks.
4. Dimensional modelling reading + practice — pair with data modelling for DE interviews → for the modelling layer.

Output.

Step	Platform	Time	Outcome
1	Mode Advanced	1 week	Windowing on Postgres
2	DataCamp (optional)	2 weeks	Structured curriculum
3	PipeCode	3–4 weeks	Snowflake dialect fluency
4	PipeCode + courses	parallel	Dimensional modelling

Rule of thumb. Analytics engineers need dialect plus modelling. The SQL platforms cover the dialect axis; pair them with a modelling course for the schema-craft side.

SQL interview question on platform-driven prep

A common hiring-manager framing: "Walk me through how you would prepare for a 6-week SQL-heavy interview loop, starting from intermediate skill level. What platforms would you use, in what sequence, and how would you know you were ready?"

Solution Using the 6-week density-driven plan

`sql
-- The check query a candidate runs on themselves each week
WITH weekly_check AS (
SELECT
week_num,
platform,
problems_solved,
solved_first_try,
target_solved_first_try
FROM prep_log
WHERE week_num <= 6
)
SELECT
week_num,
platform,
problems_solved,
solved_first_try,
CASE
WHEN solved_first_try >= target_solved_first_try THEN 'on track'
ELSE 'needs more reps'
END AS readiness
FROM weekly_check
ORDER BY week_num;
`

Step-by-step trace.

Week	Platform	Solved	Target first-try	Readiness
1	Mode Advanced	5 exercises	4	on track
2	PipeCode windowing	20	16	on track
3	PipeCode JOIN + CTE	15	12	on track
4	PipeCode aggregation + NULL	15	12	on track
5	PipeCode Meta-tagged	15	12	on track
6	Mocks + review	0 new	n/a	calibrating

The plan ladders from foundational knowledge load (Mode) into graded reps (PipeCode), with a measurable readiness check at the end of each week.

Output:

metric	value
Total weeks	6
Total focused hours	~60
Total problems solved	~70
Cost (free tier)	$0
Cost (with DataCamp)	~$50

Why this works — concept by concept:

• Density beats breadth — 70 graded problems in 5 weeks of reps produce more interview-readiness than 300 hours of unranked tutorial completion.
• Dialect-correct from week 2 — every rep after week 1 is on the dialect the target job runs. No "wait until the loop to see the engine" surprise.
• Company-tagged set in week 5 — the final weekly focus mirrors the actual distribution of probes a Meta loop pulls from. This is the highest-signal practice density on the public web.
• Mocks in week 6 — measurable readiness check that surfaces the last weak spots while there is still time to fix them.
• Cost — $0 for the canonical path; ~$50 if a DataCamp track is layered in. The price-to-readiness ratio is the best in the market.

SQL
Topic — ranking
Ranking & top-N problems (SQL)

Practice →

---

5. Per-platform rating card — price, depth, audience fit

Five vertical rating cards — price, depth bar, modern-stack relevance, and a one-line "best for" tagline

The mental model in one line: a rating card collapses each platform to four data points — price, depth, modern-stack relevance, audience — and a one-line tagline; that is enough to pick correctly in under two minutes. Once you can recite each card, you are no longer "shopping for a SQL course" — you are prescribing the right one for the goal in front of you.

The five rating cards.

Platform	Price	Depth	Modern-stack relevance	Audience
SQLZoo	Free	60%	30%	Beginner → Intermediate
SQLBolt	Free	30%	25%	Absolute beginner
Mode	Free	75%	65%	Intermediate analyst
DataCamp	$25–$35/month	65%	70%	Career switcher / cert seeker
PipeCode	Free + paid	95%	95%	Intermediate → Senior DE / analytics engineer

SQLZoo — Free · classic · Best for JOIN drills.

• Strengths. Free, no-login, deep JOIN coverage on canonical datasets. The Nobel page is the single best JOIN drill on the public web.
• Weaknesses. Stale UI (2003-era). MySQL-flavoured. Light on window functions and modern features.
• Pick it when you want raw repetition on JOIN patterns and do not care about dialect modernity.

SQLBolt — Free · 18 lessons · Best for first 2 hours with SQL.

• Strengths. Smallest, fastest onboarding ramp. One-screen lessons. No login.
• Weaknesses. Stops at GROUP BY. No window functions, CTEs, performance, or modern dialects.
• Pick it when you are absolutely brand new and need a 2-hour syntax warm-up.

Mode SQL Tutorial — Free · analytics-flavoured · Best for analyst onboarding.

• Strengths. Real product datasets, Postgres-flavoured runner, the best free window-function lesson on the public web. Long-form, BI-mindset framing.
• Weaknesses. Single dialect. No certificate. No company-tagged problems.
• Pick it when you are training to be an analyst or analytics engineer and need windowing + analytics-SQL mindset together.

DataCamp SQL — $25–$35/month · structured · Best for cert seekers.

• Strengths. Structured curriculum, video lectures, downloadable certificates, multi-dialect tracks (MySQL, Postgres, T-SQL, BigQuery).
• Weaknesses. Paid after the intro chapter. Video pacing is slow for experienced learners. Interview density is light.
• Pick it when you are a career switcher who needs a credential and you prefer video lectures over reading.

PipeCode — Free + paid · interview-focused · Best for DE & analytics engineer interview prep.

• Strengths. 450+ problems tagged by company and topic. Multi-dialect IDE (Postgres / BigQuery / Snowflake / MySQL). Real-time scoring. Modern stack.
• Weaknesses. Assumes prior SQL exposure (not a beginner-zero platform). Pair with SQLBolt for the first two hours.
• Pick it when you are within 6 months of an interview loop and need company-tagged, dialect-correct, graded reps.

"If you only had time for one" — the honest answer.

• Analyst goal → Mode SQL Tutorial. It is the only one that teaches analytics SQL on real datasets.
• Interview goal → PipeCode. It is the only one with company-tagged graded problems on modern dialects.
• Absolute beginner → SQLBolt. Two hours, no login, you walk away with SELECT muscle memory.
• Career switcher who needs a credential → DataCamp Data Engineer track.
• JOIN drill addict → SQLZoo.

Team-onboarding picks.

• Data analyst hire → Mode SQL Tutorial (1 week) + 3 internal datasets + PipeCode 10 problems.
• Data engineer hire → Mode windowing (3 days) + PipeCode Postgres-tagged set (2 weeks) + dbt docs.
• Analytics engineer hire → Mode + DataCamp dbt track (optional) + PipeCode Snowflake-tagged problems.
• Junior PM with a "needs SQL" gap → SQLBolt (1 day) + Mode Intermediate (3 days).

Free-only stack.

• SQLBolt → SQLZoo → Mode → PipeCode free tier — skip DataCamp paywall entirely. Covers the journey from absolute zero to interview-ready at $0.

Worked example — comparing rating cards for a specific learner

Detailed explanation. A senior analyst wants to transition into a data engineering role. They have 4 hours/week. The rating cards above let you pick a platform in under a minute by matching depth, modern-stack relevance, and audience to the goal.

Question. Given a senior analyst transitioning to DE, with 4 hours/week and a target loop in 8 weeks on a Postgres / BigQuery shop, which platforms should they use and which can they skip?

Input. Learner profile: senior analyst, 4 hours/week, 8 weeks, Postgres/BigQuery target.

Code. Not applicable — this is a rating-card lookup.

Step-by-step explanation.

1. Skip SQLBolt — the learner is not absolute-beginner. Audience mismatch.
2. Skip SQLZoo — JOIN drills are below the learner's skill ceiling. Depth too low.
3. Use Mode Advanced SQL chapter for week 1 — windowing refresher on Postgres-flavoured runner. Depth 75%, modern-stack relevance 65%, free.
4. Skip DataCamp — no credential needed for a senior IC role.
5. Use PipeCode for weeks 2–8 — 95% depth, 95% modern-stack relevance, dialect dropdown for Postgres + BigQuery, company-tagged probes.

Output.

Step	Platform	Reasoning
Skip	SQLBolt	Audience mismatch (too basic)
Skip	SQLZoo	Depth too low for senior analyst
Use	Mode Advanced	Windowing refresh, free
Skip	DataCamp	No credential needed
Use	PipeCode	Highest depth + modern-stack relevance + dialect dropdown

Rule of thumb. Rating cards turn platform selection into a 2-minute decision. Read the four data points (price / depth / modern-stack / audience), match to the learner's goal, pick the top-1 or top-2 — done.

Worked example — choosing a platform for a 1-week analyst onboarding

Detailed explanation. A new junior analyst joins on Monday. They have a CS undergrad and have written some Python but no SQL. They need to be writing real warehouse queries by Friday. The rating-card lookup gives the answer in under a minute.

Question. Pick the platform stack for a CS-undergrad junior analyst who needs to be warehouse-productive in 5 days.

Input. Learner profile: CS undergrad, no SQL, 5 days, target = real warehouse queries.

Code. Not applicable — this is a rating-card lookup.

Step-by-step explanation.

1. Use SQLBolt on Monday — absolute-beginner audience, 18 lessons, 1 day. Audience fit: perfect.
2. Use SQLZoo on Tuesday + Wednesday — beginner-to-intermediate, JOIN drills. Audience fit: good.
3. Use Mode Intermediate on Thursday — intermediate analyst, real datasets. Audience fit: stretches the learner upward.
4. Use PipeCode on Friday — 5 graded problems on the team's dialect. Audience fit: tests warehouse-readiness directly.
5. Skip DataCamp — no time for a paid track, no credential needed.

Output.

Day	Platform	Goal
Mon	SQLBolt	Syntax warm-up
Tue–Wed	SQLZoo	JOIN drills
Thu	Mode Intermediate	Real datasets
Fri	PipeCode	5 graded reps

Rule of thumb. A 5-day onboarding plan uses 4 platforms in sequence, all free. Total cost: $0. Total mentor time: ~2 hours of check-ins.

Worked example — picking a platform for a Snowflake shop

Detailed explanation. A team runs Snowflake exclusively. They need to onboard a new data engineer with prior MySQL experience but no Snowflake exposure. The rating-card lookup quickly narrows the options.

Question. Recommend a platform stack for onboarding a MySQL-experienced DE into a Snowflake shop in 3 weeks.

Input. Learner profile: prior MySQL DE, 3 weeks, target = Snowflake productive DE.

Code. Not applicable — this is a rating-card lookup.

Step-by-step explanation.

1. Skip SQLBolt and SQLZoo — learner has prior SQL. Audience mismatch (both too basic).
2. Use Mode Advanced for week 1 — refresh windowing on Postgres-flavoured runner. Free.
3. Use PipeCode Snowflake-tagged set for weeks 2 + 3 — dialect-correct on Snowflake: colon-path JSON, LISTAGG, DATEADD, MERGE INTO. 95% modern-stack relevance.
4. Skip DataCamp unless the company wants a credential signal on the personnel file.

Output.

Week	Platform	Focus
1	Mode Advanced	Windowing refresh
2	PipeCode Snowflake	Colon-path JSON, LISTAGG
3	PipeCode Snowflake	MERGE, CTE, performance

Rule of thumb. Snowflake shops should bias toward PipeCode for the dialect-correct fluency. Mode's window-function content is the best free preparation; the rest is dialect-specific reps.

SQL interview question on rating-card-driven selection

A common hiring-manager framing: "If I gave you 30 days and $0 budget to take someone from intermediate SQL to DE-interview-ready, which two platforms would you pick and why?"

Solution Using the rating cards to compose a free 30-day plan

`sql
-- The composer query the mentor uses
WITH constraints (budget_usd, days_available, learner_level, target) AS (
VALUES (0, 30, 'intermediate', 'DE interview')
)
SELECT
'Mode SQL Tutorial Advanced' AS week_1,
'PipeCode windowing + JOIN' AS week_2,
'PipeCode aggregation + NULL' AS week_3,
'PipeCode company-tagged set' AS week_4
FROM constraints
WHERE budget_usd = 0
AND days_available >= 28
AND learner_level = 'intermediate'
AND target = 'DE interview';
`

Step-by-step trace.

Week	Platform	Tagged set	Goal
1	Mode Advanced	n/a	Windowing fluency
2	PipeCode	windowing + JOIN	Interview pattern reps
3	PipeCode	aggregation + NULL	Silent-bug coverage
4	PipeCode	company-tagged	Loop-correct distribution

The plan uses two platforms, both free, in a four-week sequence that ladders from knowledge load (Mode) to graded reps (PipeCode) to loop-correct authenticity (company tags).

Output:

metric	value
Platforms used	2 (Mode + PipeCode)
Budget	$0
Total problems solved	~50
Final-week focus	Company-tagged set

Why this works — concept by concept:

• Two platforms is the right cardinality — fewer leaves gaps; more dilutes density. Mode for knowledge, PipeCode for reps.
• Free-first — the entire plan fits within free tiers. Budget conversation skipped.
• Density of reps in weeks 2–4 — ~15 problems per week, graded, dialect-correct. This is the highest signal-to-noise practice you can buy at $0.
• Loop-correct distribution in week 4 — finishing on the company-tagged set mimics the actual probe distribution, building loop-day confidence.
• Cost — $0, 30 days, two platforms. The single highest-ROI "intermediate-to-interview-ready" plan in the public market.

SQL
Topic — joins
JOIN problems (SQL)

Practice →

---

Cheat sheet — platform recipes

• Absolute beginner, day 1. SQLBolt lessons 1–8. Two hours. Free.
• Drill JOINs until automatic. SQLZoo Nobel + World tutorials. 1–2 weeks of evening sessions. Free.
• Add window functions + analytics-SQL mindset. Mode SQL Tutorial Advanced section. 1 week. Free.
• Need a certificate for HR / LinkedIn? DataCamp Data Engineer track or "SQL Fundamentals" track. 1–2 months at $25–$35/month.
• DE / analytics engineer interview prep. PipeCode company-tagged set on the target dialect + Mode windowing as a refresh. Ongoing.
• Onboard a new analyst hire in 1 week. Mode SQL Tutorial + 3 internal datasets + PipeCode 10 problems on the team's dialect. Free.
• Onboard a new DE hire in 2 weeks. Mode Advanced + PipeCode 25 problems + dbt docs. Free for the SQL side.
• Free-only stack, complete journey. SQLBolt → SQLZoo → Mode → PipeCode free tier. Skip DataCamp paywall.
• 30-day fast track to a DE interview. SQLBolt warm-up (1–3 days) → Mode windowing (4–10 days) → PipeCode 50 problems (11–30 days).
• 6-week senior loop prep. Mode Advanced (1 week) → PipeCode windowing (1 week) → PipeCode JOIN/CTE (1 week) → PipeCode aggregation/NULL (1 week) → PipeCode company-tagged (1 week) → mocks (1 week).
• Senior analyst pivoting to DE. Skip SQLBolt + SQLZoo; use Mode Advanced + PipeCode Postgres / BigQuery / Snowflake-tagged sets.
• Career switcher who wants the credential. SQLBolt (warm-up) + DataCamp Data Engineer track + PipeCode 25 problems on the target dialect. $25–$35/month for ~2 months.
• Snowflake-shop onboarding. Mode Advanced + PipeCode Snowflake-tagged problems (colon-path JSON, LISTAGG, DATEADD).
• BigQuery-shop onboarding. Mode Advanced + PipeCode BigQuery-tagged problems + GCP's official BigQuery docs.
• MySQL-only legacy stack. SQLZoo + SQLBolt cover this surface; upgrade to PipeCode the moment the team migrates off MySQL.
• "I read the tutorials but freeze in interviews." Diagnosis: low density of representative graded problems. Fix: 50 PipeCode reps on the target dialect.

Frequently asked questions

SQLZoo vs SQLBolt — which should I start with?

If you have never written SQL before, start with SQLBolt — its 18 lessons cover the absolute basics (SELECT, WHERE, JOIN, GROUP BY) in roughly two hours, with one-screen lesson cards that minimise cognitive load. Once SQLBolt is done, move to SQLZoo for JOIN repetition on the Nobel and World datasets — SQLZoo assumes you already know syntax and throws you into multi-table joins by tutorial 6. The honest order is SQLBolt first, SQLZoo second, with a total time budget of ~3–5 days from "I have never written SQL" to "I can write 3-table JOINs unaided."

Is DataCamp SQL worth paying for in 2026?

DataCamp SQL is worth the $25–$35/month subscription if and only if you need the credential for HR / LinkedIn or you prefer video lectures over reading-and-doing. The content itself is solid but does not teach much that the free combination of Mode SQL Tutorial + PipeCode does not already cover — and the free combination has higher interview density. For pure interview prep, skip the DataCamp paywall and use Mode for knowledge load + PipeCode for graded reps. For a career switcher who wants a downloadable certificate to put on a CV, the DataCamp Data Engineer track is a reasonable structured curriculum.

What is Mode SQL Tutorial best at?

Mode SQL Tutorial is best at analytics-SQL framing — every lesson is anchored in a real product analytics question (web events, warehouse orders, user funnels), and the Advanced SQL chapter is the single best free window-function teaching resource on the public web. The runner is Postgres-flavoured, the datasets are realistic, and the lesson pacing matches how an analyst actually thinks about queries. Use Mode for the Intermediate + Advanced chapters; skip the Basic chapter if SQLBolt + SQLZoo are already done. Pair Mode with PipeCode for graded interview reps on top of the analyst foundations.

Which platform teaches BigQuery / Snowflake SQL?

For BigQuery, the options are partial Mode coverage (Mode supports BigQuery connectors), a dedicated paid DataCamp track ("Introduction to SQL Server" and the "BigQuery basics" track), and PipeCode's dialect dropdown which lets you solve the same problem on BigQuery, Postgres, or Snowflake. For Snowflake, the options narrow: DataCamp has light snippets, and PipeCode is the most thorough free-and-paid Snowflake teaching surface (colon-path JSON, LISTAGG, MERGE INTO, DATEADD, semi-structured data). SQLZoo and SQLBolt do not teach either dialect. The 2026 default for modern-stack hires is to use Mode for analyst chops + PipeCode for dialect-correct reps on BigQuery or Snowflake.

How long does it take to finish all four platforms?

Honestly, you do not need to "finish" any of them — and trying to is the most common reason learners stall. A realistic budget per platform: SQLBolt in 1–2 days (it has only 18 lessons), SQLZoo's tutorials 0–8 in 1–2 weeks of evening sessions, Mode SQL Tutorial Basic + Intermediate + Advanced in 1 week of focused study, and DataCamp Data Engineer track in 1–2 months at 5 hours/week if you commit to it. Total elapsed time to "warehouse-productive analyst" using only the free platforms (SQLBolt + SQLZoo + Mode) is roughly 3 weeks of focused effort. Add PipeCode reps on an ongoing basis after that — there is no "finish line" for the practice-platform layer; you keep drilling until you are interview-ready.

Are these enough to land a data engineer interview?

SQLBolt + SQLZoo + Mode are enough to prepare for a DE interview but not enough to pass one — they teach the language and the analyst mindset, but they do not give you the high-density graded problem reps that interview loops actually test. Every DE candidate we see who relies only on tutorials freezes on the first window-function probe under time pressure. The honest answer is add PipeCode as the final layer: 50+ problems on the dialect your target job runs, including the company-tagged set for the employer you are loop-scheduled with. The full stack is SQLBolt (syntax warm-up) → Mode (windowing + analyst mindset) → PipeCode (graded interview reps) — three platforms, ~50 hours, free or near-free. That is the price of admission for a 2026 DE loop.

Practice on PipeCode

• Drill the SQL practice library → for warehouse-grade reps across every SQL surface a modern DE role tests.
• Rehearse on aggregation problems → when you finish Mode's Intermediate chapter and need graded GROUP BY + HAVING reps.
• Sharpen window function drills → — the single highest-leverage interview topic.
• Stack ranking and top-N problems → for ROW_NUMBER, RANK, DENSE_RANK fluency.
• Layer CTE drills → for the recursive and chained-CTE patterns that appear in senior loops.
• Build NULL handling reps → for the silent-bug surface no tutorial covers properly.
• For the broader surface, read top data engineering interview questions →.
• Pair with the only 5 skills you need to become a data engineer → for the role-fit perspective.
• Sharpen the dialect axis with the SQL for data engineering interviews course →.
• For long-form schema craft, work through data modelling for DE interviews →.

Pipecode.ai is Leetcode for Data Engineering — every platform recipe above ends with PipeCode for a reason. While SQLBolt warms your syntax muscles and Mode teaches you to think like an analyst, PipeCode is the only platform that puts you in front of company-tagged, dialect-correct, graded interview problems on the modern stack (Postgres / BigQuery / Snowflake). 450+ DE-focused problems, a real-time scoring engine, and the tagged sets for Meta, Google, Stripe, Airbnb, Snowflake, ByteDance, and more — so your last 30 days of prep mirror the loop you are actually walking into.

Practice SQL now →
Window function drills →