Free lesson · Mastering SQL
How This Course Works - Format, Exercises, and How to Get the Most Out of Every Lesson
Alex: Before we get into actual SQL, I want to understand how this course is set up. You and I are having a conversation right now - is the whole course like this?
Emeka: Good instinct to ask that before diving in. No, the whole course is not exactly like this, and that is by design. Let me explain why.
SQL is a strange subject because it contains two very different kinds of knowledge. There is intuition knowledge - understanding why NULLs behave the way they do, grasping the mental model behind a window function, learning how to think about query performance. That kind of knowledge transfers best through conversation, through story, through a back-and-forth where you ask the questions a real learner would ask and I answer them the way I would answer a friend sitting across from me.
Then there is reference knowledge - the exact syntax for a LEFT JOIN, the list of string functions available in PostgreSQL, the precise behavior of BETWEEN with timestamps. That kind of knowledge transfers best as clean, scannable documentation. When you are cramming the night before a Meta SQL interview and you need to double-check whether BETWEEN includes the endpoints, you do not want to scroll through a Socratic dialogue to find the answer. You want a direct statement, a code example, and you want it in five seconds.
This course respects both kinds by using three different formats depending on what the topic needs.
The Three Formats
graph LR
subgraph R1["Dialogue-Led"]
R1A["Full conversation"]
R1B["You ask, I explain"]
R1C["Stories and intuition"]
R1D["Mental model building"]
end
subgraph R2["Hybrid"]
R2A["Conversational opening"]
R2B["Why this matters"]
R2C["Scannable reference body"]
R2D["Short conversational close"]
end
subgraph R3["Reference-Led"]
R3A["Light framing"]
R3B["Maximum scannability"]
R3C["Syntax, tables, examples"]
R3D["Quick lookup optimized"]
end
R1 -.->|"Foundations, reasoning,<br/>interview strategy"| R2
R2 -.->|"Syntax, lookup,<br/>pure reference"| R3
style R1 fill:#6366f1,color:#fff
style R2 fill:#8b5cf6,color:#fff
style R3 fill:#a78bfa,color:#fff
This diagram shows three format boxes arranged left to right. The first box, labeled Dialogue-Led, contains four items: full conversation, you ask I explain, stories and intuition, and mental model building. It is colored dark indigo. The second box, labeled Hybrid, contains: conversational opening, why this matters, scannable reference body, and short conversational close. It is medium purple. The third box, labeled Reference-Led, contains: light framing, maximum scannability, syntax tables and examples, and quick lookup optimized. It is light purple. Arrows between the boxes indicate that dialogue-led is used for foundations and reasoning and interview strategy, hybrid transitions toward syntax and lookup topics, and reference-led serves pure reference needs.
Format 1 - Dialogue-Led
This is what you are reading right now. You and I talking. You ask questions, I explain, I tell stories from my actual work at Netflix and Booking.com, we build mental models together.
You will see this format in:
- Foundation topics where the "aha" moment is the whole point - like understanding three-valued logic, or grasping why joins are really filtered cross products
- Interview reasoning topics where I need to teach you how to think, not just what to type - like the gaps-and-islands pattern, or how to think aloud during a SQL interview
- Scale topics where my production experience adds something a reference page cannot - like how Netflix processes billions of events with streaming SQL
These lessons are longer. They take more time to read. That is intentional - the concepts they teach are the ones that need space to breathe.
Format 2 - Hybrid
The hybrid format opens with a short conversational section - I frame why this topic matters and when you will need it. Then the body of the lesson switches to clean, structured reference content: callout boxes, comparison tables, code examples with expected output, step-by-step breakdowns. At the end, a short conversational close ties it back.
You will see this format for most concept-plus-syntax topics:
- GROUP BY and HAVING - I frame the execution-order insight, then the reference body covers every syntax detail
- Correlated subqueries - I explain the mental model of "once per outer row," then the reference body shows three clean examples
- Locking mechanisms - I frame when you would actually encounter locks in production, then the reference body catalogs lock types precisely
Hybrid lessons are medium length. Enough depth to be thorough, enough structure to be scannable when you come back later.
Format 3 - Reference-Led
Pure reference. Light framing at the top - maybe two sentences on what this feature is for - then straight into syntax, examples, tables, and callouts. No dialogue, no stories. Optimized for looking things up.
You will see this format for topics like:
- BETWEEN and IN - you know what filtering is; you just need the exact syntax and edge cases
- DISTINCT - one concept, documented cleanly
- Table and column aliases - syntax rules, when they are mandatory, done
These are the shortest lessons in the course, but they are dense. Every sentence earns its place.
Alex: So I do not get to talk to you in every lesson?
Emeka: You get me in every lesson - the voice, the perspective, the production lens. But in some lessons you get the full conversation, and in others you get a clean reference page written by someone who has used this syntax in production at scale. Both are me. One is the mentor, the other is the colleague who writes clear documentation.
And honestly? When you are studying for an interview and you need to quickly check how COALESCE handles nested NULLs, you will thank me for not burying the answer inside a conversation.
The Two Personas
Let me formally introduce the two people in this course.
You - Alex. A learner. Maybe a complete beginner. Maybe a working developer. Maybe a senior engineer who has been avoiding SQL for years and suddenly needs to pass a data-intensive interview round. Alex asks the questions that real learners ask, including the "dumb" ones that everyone thinks but nobody says out loud. There are no dumb questions in this course. If Alex asks it, it needed to be asked.
Me - Emeka Okafor. Senior Software Engineer at Netflix, Data Platform team. I build the pipelines that process real-time viewing events - billions of them per day - using Apache Kafka, Apache Flink, and a lot of SQL. Before Netflix, I was at Booking.com handling 1.5 million hotel bookings per day. Before that, Paystack (one of Africa's largest payment platforms). Before that, the Andela Fellowship in Lagos - where I went from self-taught coder to professional engineer.
I am not a professor. I am not a tutorial narrator. I am the engineer sitting next to you explaining how this stuff actually works, why it works that way, and what happens when it breaks at scale. When I tell you something about query performance, it is because I have watched that exact query melt a production database at 2 AM. When I tell you how Netflix processes streaming data, it is because that is literally my job.
Note: A note on the dialogue format: In dialogue-led lessons, you will see our names as conversation markers - Alex: and Emeka: - to make it clear who is speaking. This is not a chatbot interaction. Think of it as a structured conversation between a curious learner and a patient mentor, edited for clarity and pacing. Everything Alex asks is something a real learner has asked me.
How Exercises Work
Every lesson contains practice opportunities, but they show up in different ways depending on what the topic needs.
In-Lesson Exercises
These are embedded directly in the lesson as callout boxes. You will see three tiers:
Exercise: Starter: A straightforward application of what was just taught. Everyone should do these.
Intermediate: A twist or extension. Requires combining the current concept with something from an earlier module.
Advanced: The interview-grade version. Often mirrors the exact type of question you would see in a FAANG SQL round.
The starter exercises are not optional. If you skip them, you are reading a textbook, not learning SQL. The intermediate exercises are where real understanding starts. The advanced exercises are where interview readiness lives.
End-of-Lesson Challenges
Some lessons close with a larger challenge that ties together multiple concepts from the lesson. These are structured as problem statements with expected output - similar to what you would see on a platform like LeetCode, but designed to test the specific concept from the lesson, not just generic SQL skill.
How to Approach Exercises
Alex: Do I need a database set up on my machine to do these?
Emeka: Here is what I recommend. For the first few modules, you can use any free online SQL playground - there are several that let you paste a query and run it against sample data without installing anything. DB Fiddle, SQLite Online, or PostgreSQL's own interactive terminal in the browser all work.
As you get deeper into the course, especially for the performance and transactions modules, having a local PostgreSQL installation is worth the setup time. I will flag when a specific exercise benefits from a local environment.
But here is the most important thing: write the query before you look at the answer. I know that sounds obvious, but the temptation to read the solution and think "yeah, I would have written that" is the single biggest trap in SQL learning. You did not write it. You recognized it. Those are different skills. The interview tests the first one.
How AI Features Enhance Your Learning
This course runs on the AlgoInsight platform, which has two AI features built into every lesson. Let me explain how they fit into your learning.
AI-Generated Summaries
At the bottom of every lesson, the platform generates a condensed summary of the key points. This is not a replacement for reading the lesson - it is a companion to it.
Use the summary for:
- Quick refresher when you return to a topic weeks later and need to remember the core idea
- Pre-interview review when you are scanning through concepts the night before
- Spaced repetition - read the full lesson on Day 1, then revisit the summary on Days 3, 7, and 14
The summary exists because this course's lessons are deliberately longer and more narrative than what you find on most platforms. The depth is the feature - but depth means you need a quick-reference layer on top of it. That is what the summary provides.
AI-Generated Quizzes
After every lesson, the platform generates quiz questions that test whether the concepts actually landed. These are not trivia questions. They are designed to catch the specific misunderstandings that each topic commonly produces.
For example, after the lesson on three-valued logic, the quiz will not ask "what are the three truth values in SQL?" It will give you a query with a NULL comparison and ask you to predict the output. That is the difference between testing recall and testing understanding.
Tip: The best study loop is: Lesson → Exercise → Quiz → Summary review a few days later. This maps to how memory actually works. The lesson builds the initial understanding. The exercise forces you to apply it. The quiz catches gaps you missed. The summary review triggers recall after your brain has had time to consolidate.
Using This Course as a Reference
Alex: What happens after I finish the course? Can I come back to look things up?
Emeka: Absolutely, and this is something I designed into the course structure specifically. Different formats serve different purposes when you come back.
The dialogue-led lessons are for re-reading when you need to rebuild intuition. If six months from now you are interviewing again and you need to remember how to think about window functions - not just the syntax, but the mental model - you re-read that dialogue. It will click again faster the second time.
The hybrid lessons work as reference documents. The conversational opening is a quick context-setter, and the structured body has everything you need - syntax, examples, edge cases - in a scannable format.
The reference-led lessons are pure lookup tools. Bookmark them. When you need the exact syntax for COALESCE or the difference between RANK and DENSE_RANK, those lessons give you the answer in seconds.
The AI summaries at the bottom of every lesson make this even more efficient. If you just need the essentials of a topic you studied three months ago, the summary might be all you need. If it is not enough, you have the full lesson right above it.
How the Modules Build on Each Other
Let me give you one more mental model for how to navigate this course.
graph TD
subgraph Foundation["PHASE 1: Foundation"]
A["M1: SQL Foundations"]
B["M2: Querying Data"]
C["M3: Aggregations"]
D["M4: Joins"]
end
subgraph Power["PHASE 2: Power Tools"]
E["M5: Subqueries & CTEs"]
F["M6: Window Functions"]
G["M7: Set Operations"]
H["M8: DDL & DML"]
end
subgraph Production["PHASE 3: Production"]
I["M9: Data Modeling"]
J["M10: Indexing & Performance"]
K["M11: Transactions"]
L["M12: SQL at Scale"]
end
subgraph Interview["PHASE 4: Interview"]
M["M15: Interview Patterns"]
N["M16: Strategy & Mock"]
end
A --> B --> C --> E
B --> D --> E
E --> F --> G
F --> M --> N
E --> H
F --> I
F --> J --> K --> L
style Foundation fill:#6366f1,color:#fff
style Power fill:#8b5cf6,color:#fff
style Production fill:#a78bfa,color:#fff
style Interview fill:#f59e0b,color:#000
This diagram shows four phases of the course. Phase one, Foundation, includes Modules one through four in dark indigo: SQL Foundations, Querying Data, Aggregations, and Joins. Phase two, Power Tools, includes Modules five through eight in medium purple: Subqueries and CTEs, Window Functions, Set Operations, and DDL and DML. Phase three, Production, includes Modules nine through twelve in light purple: Data Modeling, Indexing and Performance, Transactions, and SQL at Scale. Phase four, Interview, is highlighted in gold and includes Modules fifteen and sixteen: Interview Patterns and Strategy and Mock. Arrows show dependencies: Querying leads to both Aggregations and Joins, which converge into Subqueries, which leads to Window Functions - the central hub connecting forward to everything else. Window Functions leads directly to Interview Patterns, showing it is the most interview-critical skill.
The key insight in this diagram: Module 6 (Window Functions) is the central hub. Almost everything in the interview and production phases depends on it. That is not an accident - window functions are the most tested SQL skill in FAANG interviews, and they are the most useful SQL skill in production analytics. The entire course is designed to get you to Module 6 prepared, then to leverage Module 6 in everything that follows.
Alex: So if I am short on time and only have a few weeks before an interview, what is the minimum path?
Emeka: Modules 1 through 6 - the foundation plus window functions - then jump straight to Module 15 (Interview Patterns) and Module 16 (Interview Strategy). That is the critical path. Everything else is valuable, but those modules are where interview performance lives.
Important: The minimum interview-prep path:
M1 (Foundations) → M2 (Querying) → M3 (Aggregations) → M4 (Joins) → M5 (Subqueries & CTEs) → M6 (Window Functions) → M15 (Interview Patterns) → M16 (Interview Strategy & Mock)
If you can only study eight modules, study these eight.
Alex: Got it. I think I am ready to actually start learning SQL.
Emeka: Almost. One more stop first - the next lesson is my story. How I got from Lagos to Netflix, and why that matters for how I teach this course. After that, we cover SQL dialects - because a query that works in PostgreSQL might break in MySQL, and I want you to understand why before it trips you up.
Then we start Module 1, and you write your first real query.
Tip: Your next step: Move on to the next topic - Meet Emeka - Lagos to Netflix - where I share my full story and explain why it shapes the way this course teaches SQL.