SQLBolt Alternatives 2026: Better Ways to Learn SQL Interactively

What Is SQLBolt?

SQLBolt is a free interactive SQL tutorial website that has taught thousands of developers the basics of SQL since 2014. It is structured as a series of short lessons, each followed by in-browser exercises using a small sample dataset of movies, actors, and theaters. You write a query, click Submit, and the site tells you if your answer is correct before unlocking the next lesson.

The appeal of SQLBolt is its simplicity. There is no signup, no installation, no environment setup. You open a tab and start writing SELECT queries within 30 seconds. For absolute beginners who have never seen SQL before, it is one of the smoothest on-ramps available.

SQLBolt covers 18 main lessons plus review exercises, structured roughly like this:

• Lessons 1-5: SELECT, WHERE, filtering with text, sorting and pagination, review
• Lessons 6-9: Multi-table queries with JOINs, OUTER JOINs, NULL handling, expressions
• Lessons 10-12: Aggregate functions, GROUP BY, HAVING, order of execution
• Lessons 13-15: INSERT, UPDATE, DELETE statements
• Lessons 16-18: CREATE TABLE, ALTER TABLE, DROP TABLE

Most learners complete the full series in 4 to 8 hours across a few sessions. At the end, you have a working knowledge of the SQL statements that make up 90% of real-world query writing.

Where SQLBolt Falls Short in 2026

SQLBolt is genuinely good at what it set out to do in 2014. The problem is that SQL — and the way SQL is used in real jobs — has moved on, and the site has not. Here is what is missing eight years later:

• Last meaningful update was 2018. SQL itself has evolved noticeably since then — window functions are now table stakes for any analytics role, CTEs (WITH clauses) are everywhere in production code, and JSON operators are mainstream in PostgreSQL and MySQL. None of this shows up in SQLBolt.
• No support for advanced features. Window functions (ROW_NUMBER, RANK, LAG, LEAD, OVER (PARTITION BY)), recursive CTEs for hierarchies, JSON operators (->>, JSONB_PATH_QUERY), and MERGE / UPSERT are all absent — yet they appear in almost every real-world dataset you will touch.
• Single dialect, loosely SQLite-flavored. The queries you write on SQLBolt run on a generic SQL engine, but they will not prepare you for PostgreSQL's ::DATE casts and JSONB, MySQL's ON DUPLICATE KEY UPDATE, or SQL Server's TOP and DATEADD. Real jobs use real dialects.
• Static curriculum with a tiny synthetic dataset. The movies/actors/theaters tables are great for syntax practice but they cannot teach you how to handle the messy reality of production data: NULLs in unexpected places, time zones, denormalized columns, or 50-million-row tables. There is also no AI explainer when you get stuck — just right-or-wrong feedback.
• No interview prep angle. SQLBolt's exercises are designed to teach syntax, not to mirror the questions actually asked at companies. If you are studying for an analytics or data-engineering interview, you will need LeetCode SQL, DataLemur, or StrataScratch on top of SQLBolt.
• No way to bring your own schema. The exercises are locked to the built-in dataset. You cannot paste your company's tables and practice writing queries against them — which is the actual job most people are learning SQL for.

Why Look for a SQLBolt Alternative?

SQLBolt is well-designed, but it has clear limits in 2026. If you are evaluating it or have already finished it, you will likely hit one of these walls:

1. It has not been significantly updated in years. SQL itself is mature and most of SQLBolt's content is still correct, but the site does not cover modern patterns like CTEs (WITH clauses), window functions beyond the most basic aggregates, PostgreSQL's LATERAL JOIN, or JSON handling in MySQL and Postgres.

2. It teaches standard SQL, not a specific dialect. You will not learn ON DUPLICATE KEY UPDATE in MySQL, UPSERT in Postgres, MERGE in Oracle and SQL Server, or STRING_SPLIT syntax. Real jobs use real dialects.

3. The sample data is small and synthetic. The movies and actors dataset is fine for practicing syntax, but you will not see the messy reality of production data: NULLs where you do not expect them, timestamps in weird time zones, denormalized columns with comma-separated values, or 50-million-row tables that demand indexes.

4. There is no feedback beyond right-or-wrong. When your query is wrong, SQLBolt tells you so but does not explain why. You are left to re-read the lesson and guess. A tutor who can say "you used WHERE when you needed HAVING because your filter is on an aggregate" would accelerate learning by 5x.

5. You cannot use your own data. The exercises are locked to the built-in dataset. You cannot paste your company's schema and practice writing queries against it, which is the actual job most people need SQL for.

These limits are why many learners finish SQLBolt and then search for an alternative. The most common alternatives fall into three categories.

SQLBolt vs Alternatives in 2026

Here is an honest side-by-side of SQLBolt against the six tools most people consider as replacements or supplements. "Free?" means there is at least a usable free tier; some tools have paid upgrades. "Bring Your Own Data" means you can connect or paste your real schema, not just use the built-in dataset.

Tool	Free?	Interactive?	Window Functions	CTEs	Multi-Dialect	AI Assist	Bring Your Own Data	Best For
SQLBolt	Yes	Yes	No	No	No (single, SQLite-flavored)	No	No	Absolute beginners, first SQL exposure
AI2SQL	Yes (free tier)	Yes (workspace + generator)	Yes (generates them)	Yes (generates them)	Yes (Postgres, MySQL, SQL Server, Snowflake, BigQuery, more)	Yes (English → SQL)	Yes (paste schema or connect DB)	Writing production SQL fast against real data
Mode SQL Tutorial	Yes	Yes	Yes (dedicated lessons)	Yes	No (PostgreSQL/Redshift-flavored)	No	No	Analytics-focused tutorial path
Khan Academy Intro to SQL	Yes	Yes (video + exercises)	No	No	No (SQLite)	No	No	Guided beginner course with video
LeetCode (SQL track)	Partial (free + paid)	Yes	Yes	Yes	Partial (MySQL primary)	No	No	Interview prep (FAANG-style problems)
DataLemur	Partial (free + paid)	Yes	Yes	Yes	Partial	Hints (paid tier)	No	Interview prep with company-specific questions
SQLZoo	Yes	Yes	Limited (introductory)	Limited	Partial (multiple engines selectable)	No	No	More-challenging exercises after SQLBolt

A note on AI2SQL: it is not a structured tutorial. It is a generator and workspace. You will not get a 1-to-18 lesson plan — you will get a tool that writes correct SQL from English prompts and lets you practice on your real schema. Treat it as the "applied practice" half of your learning, not the "first SQL primer" half.

Want to skip memorization and write SQL by describing what you need? Try AI2SQL free — bring your schema or use the demo database.

Which Alternative Should You Pick?

The honest answer depends on where you are in the journey and what you are trying to do next. Here is a short decision guide:

If you are brand new and want a guided tutorial → Khan Academy or Mode SQL Tutorial. Khan Academy adds short video alongside exercises, which helps if you have never seen a database before. Mode is pitched at analytics use cases and has stronger coverage of GROUP BY, window functions, and joins than SQLBolt. Both are free.

If you want interview prep → LeetCode SQL or DataLemur. Both have free tiers with progressively harder problems modeled on real interviews. LeetCode is the classic and has the largest community of write-ups. DataLemur is newer and leans toward analytics interviews specifically (Meta, Amazon, Airbnb-style questions). Skip these if you have never written a JOIN — you will bounce off the difficulty.

If you want to write production SQL fast against real data → AI2SQL. This is the gap SQLBolt explicitly does not fill. You paste your schema, describe the query you need in plain English, and get correct SQL for the dialect you target. It is most useful after you have done a beginner tutorial — you will recognize the SELECT/JOIN/GROUP BY structure and learn the harder patterns (window functions, CTEs, dialect-specific date math) by reading generated queries.

If you want a structured cheatable reference → keep SQLBolt as a quick read, but supplement. SQLBolt's lesson summaries are still a fine refresher for pure SELECT/JOIN/aggregation syntax. It is just not enough on its own for 2026 work. Pair it with one of the above tools instead of treating it as the whole curriculum.

Most learners end up using two or three of these: a tutorial for the structured path, a sandbox for practice on real data, and an interview-prep site if they are job hunting. There is no single replacement and you do not need one.

Walking Through SQLBolt's Topics with Runnable Examples

The rest of this guide walks through every SQLBolt topic with examples you can paste into any SQL environment — including the AI2SQL free playground — and shows how an AI-powered tool can accelerate the "apply on real data" phase that SQLBolt deliberately leaves out.

SQL Fundamentals: SELECT and WHERE

SQLBolt's first lessons teach the SELECT statement and filtering with WHERE. Here is the same material with examples you can run in any SQL environment, including the AI2SQL free playground.

Create a small sample dataset for the rest of this guide:

-- Sample data: a movies database like SQLBolt's
CREATE TABLE movies (
    id        INTEGER PRIMARY KEY,
    title     VARCHAR(100),
    director  VARCHAR(100),
    year      INTEGER,
    length_min INTEGER
);

INSERT INTO movies VALUES
    (1, 'Toy Story',     'John Lasseter',   1995, 81),
    (2, 'A Bugs Life',   'John Lasseter',   1998, 95),
    (3, 'Toy Story 2',   'John Lasseter',   1999, 93),
    (4, 'Monsters Inc.', 'Pete Docter',     2001, 92),
    (5, 'Finding Nemo',  'Andrew Stanton',  2003, 107),
    (6, 'The Incredibles','Brad Bird',      2004, 116),
    (7, 'Cars',          'John Lasseter',   2006, 117),
    (8, 'Ratatouille',   'Brad Bird',       2007, 115),
    (9, 'WALL-E',        'Andrew Stanton',  2008, 104),
    (10,'Up',            'Pete Docter',     2009, 101);

The basic SELECT picks columns from a table:

-- All columns, all rows
SELECT * FROM movies;

-- Specific columns only
SELECT title, year FROM movies;

-- With a computed column
SELECT title, length_min / 60.0 AS length_hours FROM movies;

WHERE filters rows based on a condition. Operators include =, !=, <, >, BETWEEN, IN, and LIKE:

-- Exact match
SELECT * FROM movies WHERE director = 'Brad Bird';

-- Range
SELECT title, year FROM movies WHERE year BETWEEN 2000 AND 2005;

-- Set membership
SELECT title FROM movies WHERE director IN ('John Lasseter', 'Pete Docter');

-- Pattern matching (% is any string, _ is one character)
SELECT title FROM movies WHERE title LIKE 'Toy%';

-- Combined conditions
SELECT title, year FROM movies
WHERE year >= 2000 AND length_min > 100
ORDER BY year;

This is exactly what SQLBolt Lessons 1-4 cover. The difference is that here you can paste the CREATE TABLE into any database — SQLite, PostgreSQL, MySQL, SQL Server — and run the queries yourself. You can also modify the data and see how results change, which SQLBolt's locked exercises do not allow.

Sorting and Pagination

SQLBolt Lesson 5 covers ORDER BY and the LIMIT / OFFSET pattern for pagination.

-- Sort by one column
SELECT title, year FROM movies ORDER BY year DESC;

-- Sort by two columns
SELECT title, director, year FROM movies
ORDER BY director ASC, year DESC;

-- Pagination: first page of 3 results
SELECT title FROM movies ORDER BY year LIMIT 3;

-- Pagination: second page of 3 results
SELECT title FROM movies ORDER BY year LIMIT 3 OFFSET 3;

-- SQL Server syntax (uses TOP instead of LIMIT)
SELECT TOP 3 title FROM movies ORDER BY year;

Note the database dialect difference: MySQL, PostgreSQL, and SQLite use LIMIT. SQL Server uses TOP. Oracle 12c+ uses FETCH FIRST N ROWS ONLY. SQLBolt does not teach these differences because it sticks to one dialect. For real jobs, you need to know which one applies.

JOINs and Multi-Table Queries

SQLBolt Lessons 6 through 8 introduce JOINs, which let you combine rows from multiple tables. Add a related box_office table:

CREATE TABLE box_office (
    movie_id          INTEGER PRIMARY KEY,
    rating            DECIMAL(3,1),
    domestic_sales    BIGINT,
    international_sales BIGINT
);

INSERT INTO box_office VALUES
    (1,  8.3,  191796233, 170162503),
    (2,  7.2,  162798565, 200600000),
    (3,  7.9,  245852179, 239163000),
    (4,  8.1,  289916256, 272900000),
    (5,  8.2,  380843261, 555900000),
    (6,  8.0,  261441092, 370001000),
    (7,  7.1,  244082982, 217900167),
    (8,  8.0,  206445654, 417277164),
    (9,  8.4,  223808164, 297503696);
-- Note: 'Up' has no box office record

An INNER JOIN returns only rows that match in both tables:

SELECT m.title, b.rating, b.domestic_sales
FROM movies m
INNER JOIN box_office b ON m.id = b.movie_id
ORDER BY b.domestic_sales DESC;

A LEFT JOIN keeps all rows from the left table, even if there is no match on the right:

-- Up has no box_office row, so rating/sales will be NULL
SELECT m.title, b.rating, b.domestic_sales
FROM movies m
LEFT JOIN box_office b ON m.id = b.movie_id
ORDER BY m.year;

NULL handling is the most common beginner trap with JOINs:

-- Wrong: this excludes Up because NULL != 'value'
SELECT m.title FROM movies m
LEFT JOIN box_office b ON m.id = b.movie_id
WHERE b.rating != 8.0;

-- Right: check for NULL explicitly
SELECT m.title FROM movies m
LEFT JOIN box_office b ON m.id = b.movie_id
WHERE b.rating != 8.0 OR b.rating IS NULL;

SQLBolt teaches INNER, LEFT, and RIGHT JOINs. For a complete treatment including FULL OUTER, CROSS, and SELF JOINs, see our SQL Joins Explained guide. For the advanced APPLY / LATERAL pattern that SQLBolt skips entirely, see the CROSS APPLY guide.

Aggregates and GROUP BY

SQLBolt Lessons 10 and 11 cover aggregate functions — COUNT, SUM, AVG, MIN, MAX — and GROUP BY.

-- Simple aggregates over all rows
SELECT COUNT(*) AS total_movies,
       AVG(length_min) AS avg_length,
       MIN(year) AS earliest,
       MAX(year) AS latest
FROM movies;

-- Aggregate per group
SELECT director,
       COUNT(*) AS movie_count,
       AVG(length_min) AS avg_length
FROM movies
GROUP BY director
ORDER BY movie_count DESC;

-- HAVING filters groups (unlike WHERE which filters rows)
SELECT director, COUNT(*) AS movie_count
FROM movies
GROUP BY director
HAVING COUNT(*) >= 2
ORDER BY movie_count DESC;

The distinction between WHERE and HAVING trips up most learners. WHERE filters individual rows before grouping. HAVING filters groups after aggregation. You cannot use an aggregate function in WHERE because the groups do not exist yet.

-- Wrong: aggregate not allowed in WHERE
SELECT director, COUNT(*) FROM movies
WHERE COUNT(*) > 2
GROUP BY director;

-- Right: use HAVING for aggregate filters
SELECT director, COUNT(*) FROM movies
GROUP BY director
HAVING COUNT(*) > 2;

-- You can combine WHERE and HAVING in one query
SELECT director, COUNT(*) AS movie_count, AVG(length_min) AS avg_length
FROM movies
WHERE year >= 2000             -- filter rows first
GROUP BY director
HAVING COUNT(*) >= 2           -- then filter groups
ORDER BY avg_length DESC;

Once you have aggregates down, the natural next step is window functions — things like running totals, ranks, and moving averages. SQLBolt does not cover these. Our window functions guide fills that gap with runnable examples.

INSERT, UPDATE, DELETE

SQLBolt Lessons 13-15 cover data modification. These are structurally simple but dangerous — a wrong UPDATE or DELETE without a WHERE clause can wipe out a table.

-- INSERT: single row
INSERT INTO movies (id, title, director, year, length_min)
VALUES (11, 'Brave', 'Brenda Chapman', 2012, 93);

-- INSERT: multiple rows
INSERT INTO movies (id, title, director, year, length_min) VALUES
    (12, 'Inside Out', 'Pete Docter',   2015, 95),
    (13, 'Coco',       'Lee Unkrich',   2017, 105);

-- UPDATE: change specific rows (always use WHERE)
UPDATE movies
SET length_min = 96
WHERE id = 12;

-- UPDATE: multiple columns
UPDATE movies
SET director = 'Mark Andrews', length_min = 94
WHERE title = 'Brave';

-- DELETE: remove specific rows (always use WHERE)
DELETE FROM movies WHERE id = 13;

The golden rule: always write the SELECT first to see exactly which rows your WHERE clause matches, then change it to UPDATE or DELETE once you are sure. This one habit will save you from production incidents.

-- Step 1: verify with SELECT
SELECT * FROM movies WHERE year < 2000;

-- Step 2: once verified, run the destructive statement
-- DELETE FROM movies WHERE year < 2000;

Different databases handle common needs like "insert or update if exists" (upsert) differently. SQLBolt does not cover these:

-- PostgreSQL: ON CONFLICT
INSERT INTO movies (id, title) VALUES (1, 'Toy Story Updated')
ON CONFLICT (id) DO UPDATE SET title = EXCLUDED.title;

-- MySQL: ON DUPLICATE KEY UPDATE
INSERT INTO movies (id, title) VALUES (1, 'Toy Story Updated')
ON DUPLICATE KEY UPDATE title = VALUES(title);

-- SQL Server / Oracle: MERGE
MERGE INTO movies AS target
USING (SELECT 1 AS id, 'Toy Story Updated' AS title) AS src
ON target.id = src.id
WHEN MATCHED THEN UPDATE SET title = src.title
WHEN NOT MATCHED THEN INSERT (id, title) VALUES (src.id, src.title);

These dialect differences are exactly what a modern AI tool handles cleanly. Describe the intent once, pick your database, and generate the right syntax. See our MERGE tutorial for the Oracle / SQL Server variant.

Schema: CREATE, ALTER, DROP

SQLBolt Lessons 16-18 cover schema commands. These are less frequent in day-to-day querying but essential for anyone who designs or migrates databases.

-- CREATE TABLE with constraints
CREATE TABLE directors (
    id         INTEGER PRIMARY KEY,
    name       VARCHAR(100) NOT NULL UNIQUE,
    birth_year INTEGER,
    country    VARCHAR(50) DEFAULT 'USA'
);

-- ALTER TABLE: add column
ALTER TABLE movies ADD COLUMN genre VARCHAR(50);

-- ALTER TABLE: add foreign key
ALTER TABLE movies
ADD COLUMN director_id INTEGER REFERENCES directors(id);

-- ALTER TABLE: drop column (not supported in older SQLite)
ALTER TABLE movies DROP COLUMN length_min;

-- DROP TABLE: remove table and all data
DROP TABLE IF EXISTS box_office;

Schema work benefits enormously from AI assistance because you can describe what you want ("a users table with email, hashed password, created timestamp, and a unique index on email") and get a syntactically correct CREATE statement for your target database. This avoids the 15 minutes of looking up the exact data type names and constraint syntax for each dialect.

Why AI-Powered Practice Beats Static Tutorials

SQLBolt's biggest limitation is that it is static. Every learner sees the same 18 lessons with the same dataset, and the system cannot adapt to your questions or your data. Modern AI SQL tools flip this around.

1. You practice on your own schema. Paste a CREATE TABLE for your actual database — sales, users, events, whatever — and start asking questions in plain English. The queries you write become immediately useful instead of toy exercises.

-- Paste your schema
CREATE TABLE orders (
    id          SERIAL PRIMARY KEY,
    customer_id INT,
    total       DECIMAL(10,2),
    status      VARCHAR(20),
    created_at  TIMESTAMP
);

-- Ask in English: "Show me the top 10 customers by total spend last month"
-- AI generates:
SELECT customer_id, SUM(total) AS total_spend
FROM orders
WHERE created_at >= date_trunc('month', NOW() - INTERVAL '1 month')
  AND created_at <  date_trunc('month', NOW())
  AND status = 'completed'
GROUP BY customer_id
ORDER BY total_spend DESC
LIMIT 10;

2. You get explanations, not just right-or-wrong feedback. When the AI generates a query, you can ask why it used date_trunc instead of YEAR() = 2026, or why SUM is in the SELECT but not in GROUP BY. You learn the reasoning, not just the pattern.

3. You learn your target dialect directly. If you tell the AI you are using PostgreSQL, it uses date_trunc and ::DATE. If you say SQL Server, it uses CONVERT and DATEADD. If you say BigQuery, it uses DATE_TRUNC and SAFE_CAST. You stop writing generic SQL and start writing SQL that actually runs on your system.

4. You can tackle problems that are above your current level. A beginner cannot write a query that ranks customers by last purchase with a 90-day exclusion window and joins to product categories. But they can read one and understand it, especially with explanations. AI-assisted learning lets you punch above your weight and pull up over time.

Try AI-powered SQL practice free. Paste your schema, ask questions in English, get correct SQL for MySQL, PostgreSQL, SQL Server, Snowflake, BigQuery, and more.

How to Actually Learn SQL (Study Tips)

Regardless of which tool you use, the learning outcomes depend on how you practice. Here are four tactics that make the difference.

1. Type every query yourself at first

It is tempting to copy and paste example queries and assume you understand them. You do not. Typing the query builds muscle memory for the syntax, catches small errors like missing commas, and forces you to read each clause. Only after typing 50 or so queries should you start copy-pasting complex ones.

2. Predict the result before you run

Before clicking Run, write down (in your head or on paper) what rows you expect back. Then run and compare. When you are wrong, that gap is where you learn. This is 10x more valuable than just running queries and looking at outputs.

3. Work from a real use case, not textbook exercises

Pick a small project: analyze your Spotify listening history, query a public dataset like the Chicago Taxi data, or build a personal expense tracker. Writing queries to answer questions you actually care about sticks far better than abstract practice.

4. Read production SQL, not just tutorials

Once you have the basics, read open-source database migration scripts, dbt models, or the SQL inside analytics tools. Real queries use CTEs, window functions, and conditional aggregates that tutorials often skip. Pattern-match what you see into your own writing.

Topics Beyond SQLBolt You Will Need

After finishing SQLBolt or any equivalent beginner course, here is the rough syllabus for the "intermediate" SQL you will encounter in jobs:

• Window functions — ROW_NUMBER, RANK, LAG, LEAD, running totals, moving averages
• CTEs (Common Table Expressions) — WITH clauses, recursive CTEs for hierarchies
• CASE expressions — conditional logic inside SELECT and ORDER BY
• JSON and array handling — JSONB in Postgres, JSON functions in MySQL, JSON_VALUE in SQL Server
• Date and time manipulation — time zones, intervals, date truncation, bucketing
• Indexes — when to add them, composite index column order, covering indexes
• Query optimization — reading execution plans, avoiding N+1 queries, statistics
• Transactions and isolation levels — BEGIN / COMMIT / ROLLBACK, read consistency
• Views and stored procedures — encapsulating logic at the database layer
• LATERAL / APPLY — for correlated subqueries and per-row expansions

Each of these deserves its own study session. Our blog has dedicated guides for most of them: window functions, CTEs, CROSS APPLY, indexing, subqueries, and more. Work through them in the order above for a natural progression.

Summary: Is SQLBolt Still Worth Using?

Yes, with caveats. SQLBolt in 2026 is a solid free starting point for absolute beginners. It will get you to "I can write basic SELECT and JOIN queries" in one afternoon. After that, it runs out of runway.

The most effective learning path for someone starting from zero:

1. Do all 18 SQLBolt lessons in 1-2 sessions (4-8 hours total)
2. Set up a free cloud database (Supabase, Neon) or SQLite locally
3. Pick a small project with real data
4. Use an AI SQL tool to see correct queries for your own questions, and study them
5. Work through intermediate topics one at a time (window functions, CTEs, indexes)

If you want to compress steps 3 and 4, you can start with AI2SQL today: paste a schema, ask questions in English, and learn from the generated SQL. The free playground runs in the browser with no setup, and you can connect your own database when you are ready for real practice.

Related Guides

• SQL Practice Exercises (Beginner to Advanced)
• SQL Interview Questions: 50+ Real Examples
• SQL Cheat Sheet: Syntax and Common Patterns
• SQL Query Examples: Patterns You Will Actually Use
• SQL Joins Explained (with Diagrams)
• Text-to-SQL: The Complete Guide

Frequently Asked Questions

Is SQLBolt still good in 2026?

SQLBolt is still a solid free introduction to SQL fundamentals for absolute beginners. The interactive in-browser exercises and short lesson format are well-designed and the SELECT, JOIN, and aggregation material remains correct. However, the site has not had a meaningful content update since 2018, so it does not cover window functions in any depth, recursive CTEs, JSON operators, MERGE/UPSERT, or dialect-specific features in PostgreSQL, MySQL, or SQL Server. Use it as a primer, then move to a tool that handles modern SQL.

What's the best free alternative to SQLBolt?

The best free alternative depends on your goal. Mode SQL Tutorial is the strongest free analytics-focused successor with realistic datasets. Khan Academy Intro to SQL is excellent for absolute beginners who prefer video plus interactive exercises. SQLZoo offers more challenging exercises with multiple databases. For interview prep, LeetCode SQL and DataLemur both have free tiers. AI2SQL has a free tier where you can practice writing queries against your own schema. Most learners pick two tools: one structured tutorial plus one practice sandbox.

Does SQLBolt cover window functions?

No. SQLBolt does not teach window functions. Its 18 main lessons stop at JOINs, aggregates with GROUP BY/HAVING, and basic schema commands. Window functions like ROW_NUMBER, RANK, LAG, LEAD, and OVER (PARTITION BY) clauses are not covered, and neither are recursive CTEs or JSON operators. These are mainstream features in 2026 — most analytics roles expect you to know at least the basics — so plan to learn them from another resource after SQLBolt.

SQLBolt vs LeetCode SQL — which is better?

They serve different stages. SQLBolt is a tutorial — short lessons that teach syntax with guided exercises and small sample data. It is the right starting point if you have never written a SELECT statement. LeetCode SQL is a problem set — harder questions designed to mirror coding interviews at companies like Meta, Amazon, and Google. It assumes you already know joins, aggregations, and window functions. If you are new, start with SQLBolt or Khan Academy. If you can already write joins fluently and want interview prep, go straight to LeetCode SQL or DataLemur.

Can AI replace SQLBolt for learning SQL?

Not as a curriculum replacement, but as a study partner. AI tools like AI2SQL generate SQL from plain-English questions against your own schema, which is excellent for applying concepts on real data and seeing how queries are constructed. They are not a structured tutorial — they will not walk you through SELECT, then WHERE, then JOIN in order, and they will not stop you from skipping fundamentals. The strongest setup is to use a tutorial like SQLBolt or Khan Academy for the structured path, then use AI2SQL to practice on real schemas and learn from generated queries you can dissect.

Where can I practice SQL after SQLBolt?

After finishing SQLBolt, the most productive next step is practicing on real data instead of toy datasets. Three good paths: (1) spin up a free Supabase or Neon Postgres database, load a public dataset, and write queries against it; (2) work through LeetCode SQL or DataLemur problems for interview-style challenges with progressively harder questions; (3) paste your real schema into AI2SQL, ask questions in English, and study the generated queries to see how window functions, CTEs, and joins are used in production. Aim for at least 10–20 hours of practice on real data after the tutorial.