@shaykec/bridge 0.4.24 → 0.4.26

package/modules/sprint-planning/quick-ref.md

@@ -0,0 +1,76 @@
+# Sprint Planning Quick Reference
+
+## The Two Parts
+
+| Part | Focus | Who |
+|------|-------|-----|
+| **What** | Sprint goal, selected items | Product Owner + Team |
+| **How** | Tasks, approach | Development Team |
+
+## Sprint Goal Template
+
+```
+Sprint [X]: [One-sentence outcome]
+Success: [2–3 concrete outcomes]
+Out of scope: [What we're NOT doing]
+```
+
+## Estimation Cheat Sheet
+
+| Technique | When to Use |
+|-----------|-------------|
+| Story points | Backlog refinement, sprint planning |
+| T-shirt sizing | Quick triage, non-technical stakeholders |
+| Planning poker | New or complex stories, alignment needed |
+
+**Fibonacci:** 1, 2, 3, 5, 8, 13, 21
+
+## Velocity vs Capacity
+
+| Term | Formula / Meaning |
+|------|-------------------|
+| Capacity | Team size × Days × Hours × (1 − overhead) |
+| Velocity | Avg points completed (last 2–3 sprints) |
+| Forecast | Pull ~80–90% of velocity |
+
+## Definition of Ready (Example)
+
+- [ ] Acceptance criteria defined
+- [ ] Dependencies identified
+- [ ] Sized by team
+- [ ] Technically feasible
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Better Practice |
+|--------------|-----------------|
+| Over-commit (100%+) | 80–90% of velocity |
+| No sprint goal | One outcome-focused goal |
+| Estimate in hours | Story points (complexity) |
+| Skip "how" | Break into tasks |
+| Stakeholder dictates scope | Team decides |
+
+## Remote Planning Tips
+
+1. **Async prep** — Send items 24–48h ahead
+2. **Shared boards** — Miro, FigJam, Jira, Linear
+3. **Timebox** — 15-min chunks
+4. **Document live** — Capture goal + decisions in shared doc
+5. **Cameras on** — For goal agreement, voting
+
+## Capacity Example
+
+```
+5 devs × 10 days × 6 hrs × 0.85 = 255 person-hours
+Velocity: 45 pts → Forecast: 38–40 pts this sprint
+```
+
+## Mermaid: Sprint Planning Flow
+
+```mermaid
+flowchart LR
+  A[Product Owner: goal + items] --> B[Team: capacity]
+  B --> C[Select items]
+  C --> D[Break into tasks]
+  D --> E[Sprint backlog]
+```

package/modules/sprint-planning/quiz.md

@@ -0,0 +1,102 @@
+# Sprint Planning — Quiz
+
+## Question 1
+
+In Scrum, what are the two parts of sprint planning?
+
+A) Estimate and commit
+B) What and how
+C) Scope and schedule
+D) Backlog and capacity
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: The Scrum Guide defines sprint planning as having two parts: (1) What can we achieve?—the Product Owner presents the goal and proposed items; (2) How will we build it?—the Development Team plans tasks and approach. -->
+
+## Question 2
+
+What is the main purpose of a sprint goal?
+
+A) To list all stories in the sprint
+B) To create a single, cohesive objective that guides trade-offs
+C) To satisfy stakeholders
+D) To track velocity
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: The sprint goal is a unifying objective. When the team faces trade-offs mid-sprint, they ask: "Does this support the goal?" Instead of a list of features, it describes the outcome they're aiming for. -->
+
+## Question 3
+
+Velocity and capacity differ in that:
+
+A) Velocity is in hours, capacity is in points
+B) Velocity is historical throughput; capacity is planned available time
+C) Velocity is set by the Product Owner; capacity by the Scrum Master
+D) They are the same thing
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: Velocity = how many points the team typically completes (measured after the sprint). Capacity = how much person-time is available (planned before the sprint). Capacity helps you sanity-check; velocity helps you forecast. -->
+
+## Question 4
+
+Which estimation technique encourages discussion and surfaces assumptions?
+
+A) T-shirt sizing
+B) Hours
+C) Planning poker
+D) Random guessing
+
+<!-- ANSWER: C -->
+<!-- EXPLANATION: Planning poker involves private voting, reveal, and discussion of outliers. The conversation—"Why did you pick 8?"—surfaces hidden assumptions, dependencies, and knowledge gaps. The estimate is secondary to the alignment. -->
+
+## Question 5
+
+A common anti-pattern in sprint planning is:
+
+A) Writing a clear sprint goal
+B) Estimating in story points
+C) Over-committing to 100%+ of velocity
+D) Using a Definition of Ready
+
+<!-- ANSWER: C -->
+<!-- EXPLANATION: Over-commitment leaves no buffer for unknowns, interrupts, or discovery. Teams often load the sprint to 100% or more of past velocity, then spill work or cut quality. A healthier approach is 80–90% to leave slack. -->
+
+## Question 6
+
+In Scrum, the team commits to:
+
+A) Delivering every story in the sprint backlog
+B) The sprint goal
+C) A fixed scope with no changes
+D) Completing all tasks in the first week
+
+<!-- ANSWER: B -->
+<!-- EXPLANATION: The team commits to the sprint goal—the outcome they're aiming for. The product backlog items selected are a forecast, not a contract. Scope can be rebalanced as the team learns, as long as the goal remains valid. -->
+
+## Question 7
+
+<!-- VISUAL: quiz-drag-order -->
+
+Put these Scrum sprint ceremonies in the order they occur within a sprint:
+
+A) Sprint Review
+B) Sprint Retrospective
+C) Sprint Planning
+D) Daily Scrum (each day)
+
+<!-- ANSWER: C,D,A,B -->
+<!-- EXPLANATION: Sprint starts with planning. Daily Scrum runs each day. At the end, Sprint Review (inspect the increment) and Sprint Retrospective (improve the process) close the sprint. -->
+
+## Question 8
+
+<!-- VISUAL: quiz-drag-order -->
+
+Put these story refinement steps in the correct order:
+
+A) Split or combine as needed
+B) Ensure Definition of Ready is met
+C) Clarify acceptance criteria
+D) Estimate (planning poker or similar)
+E) Discuss and ask questions
+
+<!-- ANSWER: E,C,A,D,B -->
+<!-- EXPLANATION: Refinement starts with discussion and questions to clarify. Define acceptance criteria, then split or combine stories. Estimate, and finally verify the Definition of Ready before adding to the sprint. -->

package/modules/sprint-planning/resources.md

@@ -0,0 +1,39 @@
+# Sprint Planning — Resources
+
+## Official Guides
+
+- [Scrum Guide](https://scrumguides.org) — The definitive Scrum framework. Free; covers sprint planning, roles, and events.
+- [Scrum Guide — Sprint Planning](https://scrumguides.org/scrum-guide.html#sprint-planning) — Direct link to the sprint planning section.
+
+## Articles and Readings
+
+- [Sprint Planning](https://www.mountaingoatsoftware.com/agile/scrum/meetings/sprint-planning-meeting) — Mountain Goat Software. Practical guide to running the ceremony.
+- [Velocity vs Capacity in Agile](https://www.mountaingoatsoftware.com/blog/velocity-vs-capacity) — Mike Cohn. Clarifies the difference and when to use each.
+- [Story Points: Why They Work](https://www.mountaingoatsoftware.com/blog/story-points-why-they-work) — Mike Cohn. The case for relative estimation.
+- [Planning Poker](https://www.mountaingoatsoftware.com/agile/planning-poker) — Mountain Goat Software. How to run planning poker effectively.
+- [Definition of Ready](https://www.scrum.org/resources/blog/definition-ready-empiricism) — Scrum.org. Why DoR matters and how to define it.
+- [Sprint Goal — Why It Matters](https://www.scrum.org/resources/blog/sprint-goal) — Scrum.org. The power of a single, cohesive goal.
+
+## Books
+
+- **Scrum: The Art of Doing Twice the Work in Half the Time** by Jeff Sutherland — Origins of Scrum, including sprint planning.
+- **Agile Estimating and Planning** by Mike Cohn — Deep dive on story points, velocity, and planning. The canonical reference.
+- **Succeeding with Agile** by Mike Cohn — Broader agile adoption, including planning best practices.
+
+## Podcasts
+
+- [Agile for Humans](https://ryanripley.com/agile-for-humans/) — Ryan Ripley. Episodes on sprint planning, estimation, and Scrum.
+- [Scrum Master Toolbox](https://www.scrummastertoolbox.com/) — Daily tips and stories from practicing Scrum Masters.
+
+## Tools
+
+- [Jira](https://www.atlassian.com/software/jira) — Sprint planning, backlog, velocity charts.
+- [Linear](https://linear.app/) — Modern issue tracking with cycles (sprints) and capacity.
+- [Notion](https://www.notion.so/) — Flexible boards for backlog and sprint planning.
+- [Planning Poker Online](https://www.planningpoker.com/) — Free planning poker for distributed teams.
+- [Miro](https://miro.com/) — Virtual whiteboards for remote sprint planning.
+
+## Videos
+
+- [Sprint Planning in Under 10 Minutes](https://www.youtube.com/results?search_query=sprint+planning+scrum) — Search for "sprint planning scrum" for short explainers.
+- [Mountain Goat Software — Agile Videos](https://www.mountaingoatsoftware.com/agile-videos) — Mike Cohn's video library on estimation and planning.

package/modules/sprint-planning/walkthrough.md

@@ -0,0 +1,75 @@
+# Sprint Planning Walkthrough — Learn by Doing
+
+## Before We Begin
+
+**Diagnostic:** What is a sprint, and why plan one? In one sentence: what should a team have at the end of sprint planning that they didn't have at the start?
+
+**Checkpoint:** You can distinguish "a list of work" from "a committed plan with a shared goal"—and explain why the latter matters.
+
+---
+
+## Step 1: Draft a Sprint Goal
+
+**Task:** Pick a product area (e.g., "password reset," "search," "notifications"). Write a one-sentence sprint goal that describes the *outcome* the team is aiming for, not the list of features.
+
+**Question:** If someone asked "Why does this matter?" could you answer in terms of user or business value? Or are you describing output (features) instead of outcome?
+
+**Checkpoint:** The goal is outcome-focused and could guide trade-off decisions mid-sprint.
+
+---
+
+## Step 2: Estimate Three Stories
+
+<!-- hint:buttons type="single" prompt="Which estimation technique helps teams discuss complexity together?" options="Story points,T-shirt sizes,Hours,No estimate" -->
+
+**Task:** Take three backlog items (real or hypothetical): "Add email validation to signup form," "Refactor payment module for testability," "Design and implement dark mode toggle." Estimate each using story points (1, 2, 3, 5, 8). Write one sentence justifying your estimate for each.
+
+**Question:** What makes one story "bigger" than another? Is it effort, uncertainty, or both? How might two teammates disagree—and what would that discussion surface?
+
+**Checkpoint:** Estimates are relative (the 5 is bigger than the 2) and justified.
+
+---
+
+## Step 3: Calculate Capacity and Forecast
+
+**Task:** For a 5-person team, 2-week sprint, with 20% of time in meetings: calculate capacity in person-hours. If last sprint's velocity was 38 points, how many points would you forecast for this sprint? What if 2 people have 2 days of PTO each?
+
+**Question:** Why might you pull *fewer* points than your velocity even when no one is out? What buffers do you want?
+
+**Checkpoint:** Capacity math is correct; forecast is justified and conservative.
+
+---
+
+## Step 4: Apply Definition of Ready
+
+<!-- hint:list style="checklist" -->
+
+**Task:** Write a Definition of Ready (3–5 criteria) for your team. Then take one backlog item and score it: does it meet each criterion? If not, what's missing?
+
+**Question:** What happens to sprint planning when half the items aren't ready? Who owns getting items ready—Product Owner, team, or shared?
+
+**Checkpoint:** DoR criteria are testable; at least one gap is identified for the sample item.
+
+---
+
+## Step 5: Spot Anti-Patterns
+
+<!-- hint:card type="warning" title="Sprint Planning Anti-Patterns" -->
+
+**Task:** Read this scenario: "The stakeholder asked the team to add 5 more stories to 'fill the sprint.' The team added them. Sprint goal: 'Complete all backlog items.'" List 2–3 anti-patterns. Rewrite the sprint goal to be outcome-focused.
+
+**Question:** Why do teams often accept pressure to over-commit? What would you say to the stakeholder to protect the team's ownership of the sprint?
+
+**Checkpoint:** Anti-patterns are named; the goal is rewritten to focus on outcome.
+
+---
+
+## Step 6: Plan a Remote Sprint Planning Agenda
+
+<!-- hint:celebrate -->
+
+**Task:** Design a 2-hour remote sprint planning agenda. Include: async prep, Part 1 (what), Part 2 (how), timeboxes, and how decisions will be captured.
+
+**Question:** What typically goes wrong in remote planning? How does your agenda address those risks?
+
+**Checkpoint:** Agenda has clear sections, timeboxes, and an outcome (sprint goal + backlog) documented.

package/modules/sql-fundamentals/content.md

@@ -0,0 +1,160 @@
+# SQL — Queries, Joins, and Data Modeling Essentials
+
+## SELECT Basics
+
+Fetch data with `SELECT`, `FROM`, and optionally `WHERE`:
+
+```sql
+SELECT * FROM users;
+SELECT id, name, email FROM users WHERE status = 'active';
+SELECT DISTINCT country FROM users;
+```
+
+## WHERE Clauses
+
+Filter rows with conditions:
+
+```sql
+SELECT * FROM orders WHERE amount > 100;
+SELECT * FROM users WHERE created_at >= '2024-01-01' AND status = 'active';
+SELECT * FROM products WHERE name LIKE 'Widget%';  -- starts with Widget
+SELECT * FROM users WHERE email IN ('a@x.com', 'b@x.com');
+SELECT * FROM users WHERE phone IS NOT NULL;
+```
+
+## JOINs
+
+Combine rows from two or more tables based on a related column.
+
+### INNER JOIN
+
+Only rows with matches in **both** tables:
+
+```sql
+SELECT orders.id, orders.amount, users.name
+FROM orders
+INNER JOIN users ON orders.user_id = users.id;
+```
+
+### LEFT JOIN
+
+All rows from left table; matching rows from right (NULL if no match):
+
+```sql
+SELECT users.name, orders.id
+FROM users
+LEFT JOIN orders ON users.id = orders.user_id;
+-- Users with no orders still appear; orders columns are NULL
+```
+
+### RIGHT JOIN
+
+All rows from right table; matching from left. (Less common; often rephrased as LEFT JOIN.)
+
+### FULL OUTER JOIN
+
+All rows from both tables; NULL where no match.
+
+## JOIN Quick Reference
+
+| Join Type | Left Table | Right Table |
+|-----------|------------|-------------|
+| INNER | Only matches | Only matches |
+| LEFT | All | Matches only |
+| RIGHT | Matches only | All |
+| FULL | All | All |
+
+## GROUP BY and Aggregation
+
+Aggregate rows by a column:
+
+```sql
+SELECT status, COUNT(*) as count FROM orders GROUP BY status;
+SELECT user_id, SUM(amount) as total FROM orders GROUP BY user_id;
+SELECT category, AVG(price) as avg_price FROM products GROUP BY category;
+```
+
+**HAVING** filters after aggregation:
+
+```sql
+SELECT user_id, SUM(amount) as total
+FROM orders
+GROUP BY user_id
+HAVING SUM(amount) > 1000;
+```
+
+## ORDER BY
+
+Sort results:
+
+```sql
+SELECT * FROM products ORDER BY price DESC;
+SELECT * FROM users ORDER BY name ASC, created_at DESC;
+```
+
+## Subqueries
+
+Use a query inside another:
+
+```sql
+SELECT * FROM users WHERE id IN (SELECT user_id FROM orders WHERE amount > 100);
+SELECT name, (SELECT COUNT(*) FROM orders WHERE orders.user_id = users.id) as order_count
+FROM users;
+```
+
+## Indexes
+
+Speed up lookups. Create on columns used in WHERE, JOIN, ORDER BY:
+
+```sql
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_orders_user_id ON orders(user_id);
+```
+
+## Normalization
+
+Reduce redundancy and update anomalies.
+
+**1NF:** Atomic values; no repeating groups. Each cell has one value.
+
+**2NF:** 1NF + no partial dependencies. All non-key attributes depend on the whole primary key.
+
+**3NF:** 2NF + no transitive dependencies. Non-key attributes don't depend on other non-key attributes.
+
+## ER Diagram Example
+
+```mermaid
+erDiagram
+    users ||--o{ orders : places
+    products ||--o{ order_items : "ordered in"
+    orders ||--o{ order_items : contains
+    users {
+        int id PK
+        string name
+        string email
+    }
+    orders {
+        int id PK
+        int user_id FK
+        date created_at
+    }
+    products {
+        int id PK
+        string name
+        decimal price
+    }
+    order_items {
+        int order_id FK
+        int product_id FK
+        int quantity
+    }
+```
+
+## Common Patterns
+
+| Need | SQL |
+|------|-----|
+| Pagination | `LIMIT 10 OFFSET 20` |
+| Unique values | `DISTINCT` or `GROUP BY` |
+| Top N per group | Window functions or subquery |
+| Exists check | `EXISTS (SELECT 1 FROM ...)` |

package/modules/sql-fundamentals/exercises.md

@@ -0,0 +1,87 @@
+# SQL Exercises
+
+## Exercise 1: Basic Queries
+
+**Task:** Given `products` (id, name, price, category), write queries to:
+1. Get all products in category 'Electronics'
+2. Get product names and prices, sorted by price descending
+3. Get the count of products per category
+
+**Validation:**
+- [ ] WHERE filters correctly
+- [ ] ORDER BY produces correct sort
+- [ ] GROUP BY with COUNT gives per-category counts
+
+**Hints:**
+1. SELECT name, price FROM products WHERE category = 'Electronics'
+2. ORDER BY price DESC
+3. SELECT category, COUNT(*) FROM products GROUP BY category
+
+---
+
+## Exercise 2: INNER vs LEFT JOIN
+
+**Task:** Tables: `customers` (id, name), `orders` (id, customer_id, total). Write:
+1. INNER JOIN: orders with customer names (exclude orders with invalid customer_id)
+2. LEFT JOIN from orders to customers: all orders with customer name, or NULL if customer missing
+
+**Validation:**
+- [ ] INNER returns only orders with valid customer
+- [ ] LEFT returns all orders; NULL for orphaned orders
+- [ ] Correct ON condition (orders.customer_id = customers.id)
+
+**Hints:**
+1. JOIN customers ON orders.customer_id = customers.id
+2. LEFT JOIN keeps all rows from left (orders)
+3. Test with an order whose customer_id doesn't exist
+
+---
+
+## Exercise 3: Aggregation and HAVING
+
+**Task:** From `orders` (id, customer_id, total, status), find:
+1. Total sales per customer
+2. Customers with total sales > 1000
+3. Count of orders per status
+
+**Validation:**
+- [ ] SUM(total) grouped by customer_id
+- [ ] HAVING SUM(total) > 1000
+- [ ] GROUP BY status with COUNT
+
+**Hints:**
+1. GROUP BY customer_id, SUM(total)
+2. HAVING goes after GROUP BY
+3. GROUP BY status
+
+---
+
+## Exercise 4: Subquery
+
+**Task:** Find all products (id, name, price) that have been ordered (table `order_items`: order_id, product_id, quantity). Use a subquery with IN or EXISTS.
+
+**Validation:**
+- [ ] Only products that appear in order_items
+- [ ] Subquery correctly correlates or filters
+- [ ] No duplicate products (DISTINCT if using IN)
+
+**Hints:**
+1. SELECT * FROM products WHERE id IN (SELECT DISTINCT product_id FROM order_items)
+2. Or: WHERE EXISTS (SELECT 1 FROM order_items WHERE order_items.product_id = products.id)
+
+---
+
+## Exercise 5: Normalization
+
+**Task:** This table has redundancy: `sales` (id, product_name, product_price, category, quantity, sale_date). Split into `products` and `sales` to satisfy 2NF. Define the new tables and relationship.
+
+**Validation:**
+- [ ] products: id, name, price, category
+- [ ] sales: id, product_id (FK), quantity, sale_date
+- [ ] No repeated product info in sales
+- [ ] Can join to get product details for a sale
+
+**Hints:**
+1. products holds product_name, product_price, category once
+2. sales references product_id
+3. JOIN sales ON products.id = sales.product_id for full info

package/modules/sql-fundamentals/game.yaml

@@ -0,0 +1,105 @@
+games:
+  - type: command-sprint
+    title: "SQL Query Sprint"
+    challenges:
+      - prompt: "Get all users from the users table."
+        answer: "SELECT * FROM users;"
+        alternates: ["SELECT * FROM users", "select * from users;"]
+        timeLimit: 15
+      - prompt: "Get all users older than 25. Table has columns id, name, age."
+        answer: "SELECT * FROM users WHERE age > 25;"
+        alternates: ["SELECT * FROM users WHERE age>25", "select * from users where age > 25;"]
+        timeLimit: 18
+      - prompt: "Get users with names starting with 'J'. Use the LIKE operator."
+        answer: "SELECT * FROM users WHERE name LIKE 'J%';"
+        alternates: ["SELECT * FROM users WHERE name LIKE 'J%'", "select * from users where name like 'J%';"]
+        timeLimit: 20
+      - prompt: "Get the count of users in the users table."
+        answer: "SELECT COUNT(*) FROM users;"
+        alternates: ["SELECT COUNT(*) FROM users", "select count(*) from users;"]
+        timeLimit: 18
+      - prompt: "Get users ordered by name alphabetically (A to Z)."
+        answer: "SELECT * FROM users ORDER BY name ASC;"
+        alternates: ["SELECT * FROM users ORDER BY name", "select * from users order by name asc;"]
+        timeLimit: 20
+      - prompt: "Get user names and their order totals. Join users (id, name) with orders (user_id, total)."
+        answer: "SELECT users.name, orders.total FROM users INNER JOIN orders ON users.id = orders.user_id;"
+        alternates: ["SELECT users.name, orders.total FROM users JOIN orders ON users.id = orders.user_id"]
+        timeLimit: 22
+      - prompt: "Get all users and their order count. Include users with zero orders. Table orders has user_id."
+        answer: "SELECT users.name, COUNT(orders.id) FROM users LEFT JOIN orders ON users.id = orders.user_id GROUP BY users.id, users.name;"
+        alternates: ["SELECT users.name, COUNT(orders.id) FROM users LEFT JOIN orders ON users.id = orders.user_id GROUP BY users.id, users.name"]
+        timeLimit: 25
+      - prompt: "Get department names and the average salary per department. Table employees has dept_id, salary; departments has id, name."
+        answer: "SELECT departments.name, AVG(employees.salary) FROM departments INNER JOIN employees ON departments.id = employees.dept_id GROUP BY departments.id, departments.name;"
+        alternates: ["SELECT d.name, AVG(e.salary) FROM departments d INNER JOIN employees e ON d.id = e.dept_id GROUP BY d.id, d.name"]
+        timeLimit: 25
+      - prompt: "Get departments with more than 5 employees. Join departments and employees on dept_id."
+        answer: "SELECT departments.name FROM departments INNER JOIN employees ON departments.id = employees.dept_id GROUP BY departments.id, departments.name HAVING COUNT(*) > 5;"
+        alternates: ["SELECT d.name FROM departments d INNER JOIN employees e ON d.id = e.dept_id GROUP BY d.id, d.name HAVING COUNT(*) > 5"]
+        timeLimit: 25
+      - prompt: "Get products with price above the average product price. Use a subquery."
+        answer: "SELECT * FROM products WHERE price > (SELECT AVG(price) FROM products);"
+        alternates: ["SELECT * FROM products WHERE price > (SELECT AVG(price) FROM products)"]
+        timeLimit: 22
+
+  - type: bug-hunt
+    title: "Query Bug Finder"
+    snippets:
+      - code: |
+          SELECT department, name, COUNT(*)
+          FROM employees
+          GROUP BY department;
+        bugLine: 1
+        explanation: "The column 'name' is in SELECT but not in GROUP BY. Every non-aggregated column in SELECT must appear in the GROUP BY clause."
+        hint: "Every non-aggregate column in SELECT must appear in GROUP BY."
+      - code: |
+          SELECT users.name, orders.total
+          FROM users
+          LEFT JOIN orders ON users.id = orders.user_id
+          WHERE orders.total > 100;
+        bugLine: 4
+        explanation: "Using WHERE orders.total > 100 with a LEFT JOIN filters out users with no orders (NULL), turning it into an effective INNER JOIN. Use a subquery or move the filter to preserve LEFT JOIN semantics."
+        hint: "LEFT JOIN + WHERE on the right table excludes NULL rows. What happens to users with no orders?"
+      - code: |
+          SELECT * FROM users
+          WHERE age = 25
+          ODER BY name;
+        bugLine: 3
+        explanation: "Typo: ODER should be ORDER. The SQL keyword for sorting is ORDER BY."
+        hint: "Check the spelling of the sort keyword."
+      - code: |
+          SELECT category, SUM(price) AS total
+          FROM products
+          GROUP BY category
+          WHERE total > 1000;
+        bugLine: 4
+        explanation: "WHERE cannot reference aggregate aliases or aggregates. Use HAVING for aggregate conditions: HAVING SUM(price) > 1000."
+        hint: "WHERE runs before grouping. Aggregate conditions need HAVING."
+      - code: |
+          SELECT name, email
+          FROM users
+          JOIN orders ON id = orders.user_id;
+        bugLine: 3
+        explanation: "Ambiguous column: 'id' could refer to users.id or orders.id. Qualify with the table name: users.id."
+        hint: "When two tables have a column with the same name, you must specify which table."
+      - code: |
+          UPDATE users
+          SET status = 'inactive';
+        bugLine: 2
+        explanation: "Missing WHERE clause. This updates every row in the table. Always add a WHERE clause to limit which rows are updated."
+        hint: "An UPDATE without WHERE affects every row. Always verify the filter."
+      - code: |
+          SELECT name, MAX(salary)
+          FROM employees
+          GROUP BY department;
+        bugLine: 1
+        explanation: "SELECT includes 'name' which is not in GROUP BY. Either add name to GROUP BY or use an aggregate/subquery for name."
+        hint: "Non-aggregated columns in SELECT must appear in GROUP BY."
+      - code: |
+          SELECT users.name
+          FROM users
+          INNER JOIN orders ON id = orders.user_id;
+        bugLine: 3
+        explanation: "Ambiguous column reference: 'id' could mean users.id or orders.id. Qualify it as users.id."
+        hint: "Which table does 'id' belong to? Both might have it."

package/modules/sql-fundamentals/module.yaml

@@ -0,0 +1,45 @@
+slug: sql-fundamentals
+title: "SQL — Queries, Joins, and Data Modeling Essentials"
+version: 1.0.0
+description: "Master SQL queries, joins, aggregation, and database normalization."
+category: data
+tags: [sql, databases, queries, joins, data-modeling]
+difficulty: beginner
+
+xp:
+  read: 10
+  walkthrough: 30
+  exercise: 20
+  quiz: 15
+  quiz-perfect-bonus: 10
+  game: 20
+  game-perfect-bonus: 10
+
+time:
+  quick: 5
+  read: 15
+  guided: 45
+
+prerequisites: []
+related: [system-design]
+
+triggers:
+  - "How do SQL joins work?"
+  - "How do I write a SQL query?"
+  - "What's the difference between INNER and LEFT join?"
+  - "How do I design a database schema?"
+
+visuals:
+  diagrams: [diagram-mermaid]
+  quiz-types: [quiz-drag-order, quiz-fill-blank]
+  game-types: [command-sprint, bug-hunt]
+  playground: bash
+  web-embeds: true
+
+sources:
+  - url: "https://www.postgresql.org/docs/"
+    label: "PostgreSQL Docs"
+    type: docs
+  - url: "https://sqlbolt.com"
+    label: "SQLBolt"
+    type: docs