🎯 Interview & Career · Chapter 2

The SQL round: how to think out loud

The SQL round isn't graded on the query. It's graded on the evidence the interviewer can write down — and they can only write down what you say.

Study this lesson free in the app →

The basics

The SQL round is a live interview where you're given a schema and a business question — “top 3 drivers by earnings in each city last month” — and write a query in a shared editor while the interviewer watches.

Why thinking out loud matters: the interviewer has to fill in a feedback form afterwards: did they understand the problem? handle edge cases? write clean, correct SQL? communicate? A correct query typed in silence gives them almost nothing to write. A slightly slower query with clear reasoning gives them a page.

The mental model — six moves, every time:

1. Restate the question in your own words
2. Clarify grain, ties, NULLs, duplicates, time window
3. Shape the output: “one row per city per driver, columns …”
4. Build in small CTEs, saying what each produces
5. Check against a tiny example and the edge cases
6. Extend: performance, indexes, alternatives

Words to know: grain, tie-breaking, ROW_NUMBER / RANK / DENSE_RANK, CTE, edge case.

Explained

Two candidates, same question, same correct query.

Candidate A types for six minutes in silence and says “done”.

Candidate B says: “So, per city, I want the three drivers who earned most in October. Quick check — if two drivers tie for third, should both appear? And earnings means completed rides only, excluding cancelled?” — then builds it in three CTEs, explaining each.

A gets “correct, little signal”. B gets “strong hire”. Same SQL. Different evidence.

The tailor's fitting

A good tailor in Police Bazaar doesn't start cutting the moment you say “a shirt”.

He asks: Formal or casual? Slim or regular? Full sleeve? He measures. He says back: “So, slim fit, full sleeve, two pockets.” Only then does he cut — and at the fitting he checks the sleeves while you stand there.

A tailor who silently cuts a perfect shirt is fine. One who cuts the wrong shirt fast is a disaster. Clarify, confirm the shape, cut, then check the fit — that's the SQL round.

The six moves

Clarifying takes 60–90 seconds. It's the highest-return minute of the round.

The query, built the way you'd narrate it

-- “First, completed rides in October, IST.”
WITH oct_rides AS (
  SELECT city, driver_id, fare_inr
  FROM rides
  WHERE status = 'completed'
    AND completed_at >= '2026-10-01' AND completed_at < '2026-11-01'
),
-- “Then one row per city and driver with total earnings.”
earnings AS (
  SELECT city, driver_id, sum(fare_inr) AS earnings_inr
  FROM oct_rides
  GROUP BY city, driver_id
),
-- “Rank within each city. You said ties should both appear, so DENSE_RANK.”
ranked AS (
  SELECT *, DENSE_RANK() OVER (PARTITION BY city ORDER BY earnings_inr DESC) AS rnk
  FROM earnings
)
SELECT city, driver_id, earnings_inr, rnk
FROM ranked
WHERE rnk <= 3
ORDER BY city, rnk;

Notice the half-open date range (< '2026-11-01') — say why: it includes all of 31 October regardless of time.

What the interviewer's form actually says

Most companies score something like:

• Problem understanding — clarified ambiguity before coding?
• Correctness — right result, including ties and NULLs?
• Edge cases — raised without prompting, or only after hints?
• Code quality — readable CTEs, sensible names, no copy-paste?
• Communication — could they follow your reasoning in real time?
• Efficiency — awareness of scans, indexes, unnecessary self-joins?

And the line that matters most is hints needed. Getting there after one hint is fine. Needing the interviewer to point at every bug is a no. Raising the bug yourself — “wait, this LEFT JOIN plus WHERE will drop drivers with no rides” — is one of the strongest signals in the round.

The traps they plant on purpose

• LEFT JOIN then WHERE on the right table — WHERE r.ride_date >= … removes the NULL rows, silently making it an INNER JOIN. Put the filter in ON.
• *COUNT(col) vs COUNT()** — COUNT(driver_id) skips NULL drivers; COUNT(*) counts all rows.
• WHERE vs HAVING — filtering on sum(fare) needs HAVING.
• Ties — ROW_NUMBER silently drops a tied driver. Ask which behaviour they want.
• Date boundaries — BETWEEN '2026-10-01' AND '2026-10-31' on a timestamp misses 31 Oct after midnight.
• Integer division — completed / total returns 0 in some engines; cast or multiply by 1.0.
• Duplicates in source — ask if ride_id is unique before summing.

When you get stuck — what to say

You need each driver's earnings vs the previous month and you blank on the syntax.

Bad: 40 seconds of silence, then “sorry, I don't remember”.

Good: “I want the previous month's value on the same row — that's a window function, LAG partitioned by driver ordered by month. I'm not 100% sure of the default for the first row; I believe it returns NULL, so I'll coalesce it to 0 and treat that as a new driver. Does that match what you want for new drivers?”

You've shown you know the concept, the edge case and the business question — even if the syntax is slightly off. Interviewers forgive syntax. They don't forgive silence.

Restate, clarify, shape, build, check, extend — out loud.

The interviewer can only grade what they hear. Ties, NULLs and the LEFT JOIN trap: raise them before they do.

Words to know

In two minutes

• Interviewers score understanding, correctness, edge cases, code clarity and communication — not just the final result.
• Restate and clarify before writing: grain, ties, NULLs, duplicates, date boundaries, timezone.
• Say the output shape out loud first — ‘one row per city and driver’ — it prevents half the bugs.
• Build in named CTEs, one idea each, narrating what each step returns.
• Test mentally on a tiny example with a tie, a NULL and an empty group.
• Know the classic traps: LEFT JOIN filtered in WHERE, COUNT(col) vs COUNT(*), WHERE vs HAVING, RANK vs ROW_NUMBER.
• When stuck, say what you're trying and ask a precise question; silence is the only thing that always scores badly.

Test yourself

There are 8 questions, 3 puzzles and 5 recall cards for this lesson in the app — the recall cards come back on later days, just before you would forget.