Catalog My learning Blog
System Design Interview Prep: Framework and Questions · Phase 1 · Lesson 12 · 4 min read

System Design Mock Interviews and Common Mistakes

On this page
  1. The practice problem: design a parking reservation system
  2. Mock interview walkthrough, minute by minute
  3. How to score a mock interview
  4. Five common system design interview mistakes
  5. How to practice system design interviews
  6. Check yourself

The practice problem: design a parking reservation system

Run a mock interview this week. Pick a prompt you haven't prepared, set a 45-minute timer, and ideally have a friend play the interviewer. Then compare your run with the walkthrough below and score yourself.

Prompt: "Design a parking reservation system."

Mock interview walkthrough, minute by minute

0 to 4: requirements. The candidate asks: one garage or many? Reserve in advance or claim on arrival? Different spot sizes? Answers: about 500 garages across a city, both advance booking and drive-up, three vehicle sizes. Then one priority question: "Is double-booking a spot worse than a slow booking?" Yes, much worse.

4 to 9: estimate. 500 garages × 200 spots = 100,000 spots. About 20 requests per spot per day (searches, bookings, check-ins) is 2 million a day, roughly 20 per second on average and maybe 100 at peak. The candidate says the important part out loud: "This is small. One relational database handles it. I won't shard."

9 to 29: high-level design. Stateless API behind a load balancer; one PostgreSQL primary with a replica; tables for garages, spots (size, garage) and reservations (spot, user, start, end, status). Availability searches dominate, so a short-lived cache in front of the search query. The candidate walks through a booking end to end and names the risk: two people booking the same spot for overlapping times.

29 to 40: deep dive. The interviewer goes straight there: "How exactly do you prevent overlapping reservations?" The candidate restates, names options, and commits: an exclusion constraint on spot and time range, so the database rejects an overlapping insert atomically, even under concurrent requests. The app catches the violation and offers another spot.

SQL
CREATE EXTENSION btree_gist;            -- lets a GiST index compare plain integers with =
CREATE TABLE reservations (
  id      bigserial PRIMARY KEY,
  spot_id int NOT NULL,
  user_id int NOT NULL,
  during  tstzrange NOT NULL,
  status  text NOT NULL DEFAULT 'confirmed',
  EXCLUDE USING gist (spot_id WITH =, during WITH &&)   -- same spot, overlapping time: rejected
    WHERE (status <> 'cancelled')                         -- cancelled bookings free the spot
);
-- 09:00-11:00 succeeds; 10:00-12:00 on the same spot fails with
-- "conflicting key value violates exclusion constraint"; 11:00-12:00 succeeds.
-- Cancel the 09:00 booking, and 10:00-12:00 then succeeds.

The WHERE clause matters because the design has a status column. Without it, a cancelled booking would keep blocking its time slot.

40 to 45: wrap-up. The trade-off, stated plainly: strict consistency on bookings costs some write throughput, irrelevant at 100 requests per second and worth it because a double-booked spot is the worst failure. What changes at 100x: cache availability more aggressively, partition reservations by city, and keep each garage's spots in one partition so the constraint still works.

How to score a mock interview

Score each area from 1 to 5, and write one sentence about what you'd do differently. A sentence forces specifics; "felt OK" teaches nothing.

AreaWhat a 5 looks like
RequirementsScope cut to something designable, priorities asked, list confirmed
EstimationQuick numbers that drove a decision, like "no sharding"
ArchitectureEvery component justified; one read and one write traced
DepthOne hard problem solved properly, such as atomic double-booking prevention
Trade-offsCosts stated alongside choices, with what would change them
CommunicationInterviewer never had to ask "what are you thinking?"

Five common system design interview mistakes

The recurring mistakes are jumping to a diagram before clarifying requirements, thinking silently instead of narrating, going equally deep everywhere, and ignoring the clock. The fix for each is procedural, which is why timed, self-scored mock practice is what makes it automatic.
The recurring mistakes are jumping to a diagram before clarifying requirements, thinking silently instead of narrating, going equally deep everywhere, and ignoring the clock. The fix for each is procedural, which is why timed, self-scored mock practice is what makes it automatic.
PitfallWhy it hurtsFix
Drawing before askingYou may design the wrong systemAsk 3 to 5 questions first, every time
Thinking silentlyThe interviewer can't score what they can't hearNarrate choices, even obvious ones
Going deep everywhereTime runs out with nothing finished properlyGo deep on one or two parts; let the interviewer pick
Ignoring the clockWrap-up gets skipped, and with it easy pointsCheck time at roughly 10, 30 and 40 minutes
One option onlySounds memorizedName at least one rejected alternative for each big decision

How to practice system design interviews

  • New prompts. Re-running the URL shortener you've studied tests memory, not design. Use prompts like a parking system, a ticket booking site, a food delivery tracker or a notification service.
  • Out loud, on a clock. Silent practice skips the hardest part.
  • In the tool you'll use. Many rounds now run on a shared online whiteboard. Practice drawing boxes and arrows in the same kind of tool so you aren't learning its shortcuts during the interview.
  • Swap roles. Playing the interviewer teaches you what a clear answer sounds like.
  • Track scores. Your weakest area across three mocks is where the next week of study should go.

Check yourself

The first five minutes: run several mocks where you only do requirements and estimation, until asking the four question categories is automatic.

The estimate showed about 100 requests per second at peak, which one relational database handles easily. Sharding would add complexity with no benefit.

A sentence names the specific behavior to change, such as "didn't state assumptions before estimating", which you can practice deliberately in the next mock. A score alone only tells you that something went wrong in that area, not what to do differently.

Jumping into components before clarifying requirements, skipping estimation, adding complexity the numbers don't justify, never discussing trade-offs or failures, and running out of time before the deep dive. Each one is fixable with structured practice.

Two timed mocks a week on different problem types, scored with a written rubric, plus review of one weak area, such as estimation or databases, with a short focused lesson. Practicing aloud, ideally with a partner, matters as much as reading.