The Settlement
First SELECT, choosing columns, filtering and sorting — the town takes shape from the registry.
Numeria
Numeria
Numeria is a city that only exists as data. Every query a student writes changes it — 32 lessons that take them from their first SELECT to designing the schema behind a metropolis.
What students learn
SQL is the language every serious data job runs on. Students leave able to query a real database, design one that will not fall apart, and explain why their schema is built the way it is.
Query data with joins, groups, and filters.
Design a schema that holds up.
Protect a database from SQL injection.
Read a query plan and make it faster.
Numeria is a 32-lesson SQL course for ages 15–17 built around a single idea: a city that exists only as data. Students write real SQL in the browser, and every query reshapes the city in front of them. They start with a single SELECT over a village registry and finish nine modules later designing the schema behind a metropolis, querying it from Python, and defending it against SQL injection. SQL is the language behind almost every analytics, finance, marketing and engineering job — this is the course that makes it stick.
Pathway rhythm
The Grid
Keys, relationships and joins. Separate tables become one connected city, then the census and the blackout put it to the test.
Metropolis
Schema design, transactions, indexes and query plans — ending with SQL from Python, stopping an injection attack, and Demo Day.
Module by module
Module 1 · Foundations (The Settlement)
The city begins as a registry. Students learn what a database actually is, write their first SELECT, and choose which columns matter.
What a table really isSELECT and column choiceReading a schemaThinking in rows and columns
- In class
- Four lessons ending with 'Reading the Registry', which unlocks the Town milestone.
- Outcome
- Student can open an unfamiliar table and describe what is in it.
Module 2 · Querying (First Streets)
Filtering with WHERE, combining conditions, sorting and limiting results, and the trap that catches everyone: NULL.
WHERE and boolean logicAND, OR, INORDER BY and LIMITHandling NULL correctly
- In class
- Students answer questions about the growing settlement that can only be resolved by narrowing the data.
- Outcome
- Student can pull the exact rows they need out of a large table.
Module 3 · Aggregation (The Census)
Counting, averaging, grouping by district, and filtering the groups themselves with HAVING — the difference that trips up most self-taught learners.
COUNT, AVG and friendsGROUP BYHAVING vs WHERESummarising honestly
- In class
- Run the city census; the Census milestone unlocks on completion.
- Outcome
- Student turns thousands of rows into a number that answers a real question.
Module 4 · Relationships & JOINs (The Grid)
Keys and relationships, joining two tables, LEFT JOIN to keep everyone, and many-table joins — closing with a blackout the student must investigate across the whole grid.
Primary and foreign keysINNER and LEFT JOINMulti-table queriesInvestigating across tables
- In class
- Blackout Response: trace a city-wide failure through four connected tables.
- Outcome
- Student stops seeing tables in isolation and starts seeing a connected system.
Module 5 · Advanced Querying (Downtown)
Subqueries, CTEs, CASE logic, views and window functions — the tools that separate someone who can query from someone who can answer hard questions.
Subqueries and CTEsCASE expressionsViewsWindow functions
- In class
- Downtown analytics: ranking, running totals and comparisons that plain GROUP BY cannot express.
- Outcome
- Student writes a query a working analyst would recognise as competent.
Module 6 · Schema Design (Master Plan)
Constraints, normalization, and then designing a schema from scratch. This is where students stop consuming a database and start authoring one.
Constraints and data integrityNormalizationSchema design from requirementsJustifying design choices
- In class
- Design the district schema and defend why each table exists.
- Outcome
- Student can turn a written requirement into a database design that will not fall apart.
Module 7 · Writing Data & Integrity (Public Works)
INSERT, UPDATE and DELETE, atomic transactions, and foreign keys enforcing that the city stays consistent even when something fails halfway.
Writing data safelyTransactions and atomicityForeign key enforcementRecovering from partial failure
- In class
- Run public-works changes that must either fully succeed or fully roll back.
- Outcome
- Student understands why real systems wrap writes in transactions.
Module 8 · Performance (Rush Hour)
The city is busy and queries are slow. Students add indexes and, crucially, learn to read the query plan instead of guessing.
Indexes and when they helpReading a query planDiagnosing slow queriesMeasuring instead of guessing
- In class
- Take a query that crawls at rush hour and make it fast, with evidence.
- Outcome
- Student can explain why a query is slow, not just that it is.
Module 9 · Python & Capstone (Metropolis)
SQL from Python, then stopping SQL injection by writing the vulnerable version first — and Demo Day, where the city becomes a megacity.
Database access from PythonParameterised queriesSQL injection and preventionPresenting technical work
- In class
- Demo Day: Megacity — the student presents the database they built and the queries that run it.
- Outcome
- Student ships and presents a working database, and knows why string-concatenated SQL is dangerous.
Skills gained
Reading and writing SQL fluentlyFiltering, sorting and aggregating dataJoins across many tablesCTEs and window functionsSchema design and normalizationConstraints and data integrityTransactionsIndexes and query plansSQL from PythonRecognising and preventing SQL injection
Tools used
A SQL engine running live in the browserQuery plan inspectionSchema design worksheetsPython with a database connection
Final project
Demo Day: Megacity
The student presents the database behind their fully grown city: the schema they designed, the constraints protecting it, the queries that answer its hardest questions, and the injection attack they closed.
Why parents choose it
The most transferable technical skill there is
SQL is used by analysts, marketers, accountants, biologists and product managers — not only by programmers. It is the rare skill that pays off whatever your child studies next.
It teaches precision
A query is either right or it silently returns the wrong number. Numeria trains the habit of checking, which transfers well beyond databases.
Progress you can see
The city grows as the student's skill grows. Milestones unlock at real competence checkpoints, so progress is visible rather than claimed.
University and job ready
By the last module your child is doing what a junior data analyst does on day one: query, design, protect, present.
Project examples
The city registry query set
Blackout response investigation
Full schema design for a district
Demo Day: Megacity
Format
32 lessons across 9 city eras
SQL runs live in the browser
City milestones unlock as students progress
FAQ
Does my child need to code first?
No. SQL is its own language and Numeria starts from zero. Python only appears in the final module, and only to show how the two work together.
Is this useful outside tech?
Very. SQL is the daily tool of analysts, marketers, finance teams and researchers — anyone who has to answer a question with data.
Request information
Ready to choose the right pathway?
Book a focused consultation and map your child's age, interests, and goals to the right Numeris program.