Learn SQL for free

What it is

SQL (Structured Query Language) is the standard language for asking questions of, and making changes to, data stored in relational databases — data organized into tables of rows and columns. It is one of the most transferable data skills because the core language is broadly consistent across databases: the SELECT you learn against a free local database is essentially the SELECT you would write against a production system. Wherever data lives in tables — analytics, reporting, applications, back-office systems — SQL is how people retrieve exactly the slice they need and reshape it into an answer, which is why it shows up across data-analyst, database-administration, backend-developer, and business-intelligence work.

The skill has a small, high-leverage core you can learn quickly and then deepen. Reading data is the heart of it: SELECT to choose columns, WHERE to filter rows, ORDER BY to sort, and LIMIT to cap results. Combining tables: JOIN (inner and outer) to bring related rows together on a shared key, which is what makes relational data powerful. Summarizing: GROUP BY with aggregate functions like COUNT, SUM, AVG, MIN, and MAX to turn many rows into a few meaningful numbers, and HAVING to filter those groups. Changing data: the basic INSERT, UPDATE, and DELETE statements — used carefully, because they modify what is stored. Master those and you can answer a large share of real data questions.

SQL rewards deliberate practice against data you can see and change: write a query, run it, read the result, and adjust — a tight loop you can run hundreds of times on a tiny free database on your own computer. The best way to start is a lightweight engine like SQLite (a single file, no server to install) or a free in-browser SQL sandbox, where you create a small table of your own data and query it every way you can. This primer sequences free, interactive resources and gives you a first hands-on exercise building and querying your own table.

Why it matters

SQL is a common foundation across data-analyst, database-administration, backend-developer, and business-intelligence roles because so much of the world's operational and analytical data lives in relational tables. The core language transfers across databases and employers, so the skill compounds rather than tying you to a single product.

The free path, in order

1. Learn to read data: SELECT and WHERE. Start with the interactive lessons on SQLBolt: SELECT to pick columns, WHERE to filter rows, ORDER BY to sort. Run every example and change it to see what happens — this is the tight query-read-adjust loop the whole skill is built on.
2. Combine tables with JOIN. Learn inner and outer JOINs to bring related rows together on a shared key. This is the concept that separates 'listing a table' from actually answering questions that span multiple tables.
3. Summarize with GROUP BY and aggregates. Practice COUNT, SUM, AVG, MIN, and MAX with GROUP BY to collapse many rows into a few meaningful numbers, and use HAVING to filter the resulting groups. Mode's SQL Tutorial has clear, worked examples.
4. Set up your own free database. Install SQLite (a single tiny file, no server) or use a free in-browser SQL sandbox on your own machine. Create a small table of your own sample data so you fully control what you query.
5. Learn to change data carefully. Practice INSERT, UPDATE, and DELETE on your own throwaway table, and notice how a missing WHERE on UPDATE/DELETE affects every row. Always test the SELECT first, then apply the change — a habit that protects real data later.

Best free resources

• PostgreSQL — official documentation tutorial OfficialOfficial documentation

  The authoritative, vendor-maintained tutorial for a leading open-source database — the reference for correct, standards-aligned SQL as you move past the basics.

• SQLBolt — interactive SQL lessons Vetted communityFree interactive tutorial

  A free, browser-based set of interactive lessons that teach SELECT, WHERE, JOIN, and GROUP BY by having you write and run real queries — the fastest way to build the core reflex.

• ThoughtSpot (formerly Mode) — SQL Tutorial Vetted communityFree tutorial

  A well-regarded free tutorial that moves from basic to intermediate SQL with clear, analytics-oriented examples of aggregation, joins, and filtering.

• SQLite — official documentation OfficialOfficial documentation

  The docs for the tiny, serverless, single-file database that is the easiest way to run your own SQL practice environment locally with no setup or account.

Every resource is free and dated. Official sources are labeled; vetted community resources are labeled separately. Verify a resource is still free on its own page before relying on it.

Try it (free, safe, hands-on)

Create and query your own tiny database

Build a small table of your own data in SQLite (or a free in-browser SQL sandbox) on your own machine, then answer real questions with SELECT, WHERE, JOIN, and GROUP BY — turning SQL syntax into results you produced yourself.

You will need: SQLite (free, single small download) installed on your own computer, or a free in-browser SQL sandbox; A terminal or the SQLite shell, or the sandbox's query box — free; Your own made-up sample data (nothing private or real about other people)

1. Start SQLite (run 'sqlite3 practice.db') or open a free in-browser SQL sandbox. Create a table: CREATE TABLE books (id INTEGER, title TEXT, genre TEXT, pages INTEGER);
2. Insert a handful of your own rows: INSERT INTO books VALUES (1,'Book A','fiction',210); and repeat for several made-up books across two or three genres.
3. Read and filter: run SELECT title, pages FROM books WHERE pages > 200 ORDER BY pages DESC; and confirm you get only the longer books, sorted.
4. Summarize: run SELECT genre, COUNT(*) AS cnt, AVG(pages) AS avg_pages FROM books GROUP BY genre; to collapse your rows into per-genre counts and averages.
5. Add a second table (CREATE TABLE authors ...) and practice a JOIN to combine books with their authors on a shared key, so you see how JOIN answers cross-table questions.
6. Practice a careful change: run the SELECT first, then an UPDATE with a WHERE clause, and re-query to confirm only the intended row changed. Delete the practice.db file when done.

What you should see: A small database you built, query results you can explain (a filtered and sorted list, per-group counts and averages, and a joined result), and a change you made deliberately and verified — all from SQL you wrote on a machine you own.

Safety: Use only made-up sample data or your own data on your own computer — never real personal data about other people. This exercise runs against a throwaway local database file you create and can delete; it touches no system outside your own machine.

Where this skill gets used

Roles that need it: Data analyst, Database administrator, Backend developer, Business intelligence analyst.

Sources

• PostgreSQL official documentation tutorial (as of 2026-07-10)
• SQLBolt — interactive SQL lessons (as of 2026-07-10)
• Mode — SQL Tutorial (as of 2026-07-10)
• SQLite official documentation (as of 2026-07-10)

Every resource is free and dated; official-first, community clearly labeled. A skill primer is a free learning path, not a certification, not professional experience, and not a job or salary promise. Labs run only on a machine you own, against throwaway data you create. Born draft, pending human review.

All skill primers