Skip to main content
    Deep Dive

    System Design Interviews Were My Weakness. Then I Found a Framework.

    January 4, 2026
    16 min read
    System architecture diagram visualization

    Two years ago, system design interviews terrified me. The questions felt impossibly open-ended. "Design Twitter." Cool, where do I even start? I'd ramble about databases and load balancers while the interviewer's eyes glazed over.

    Then I developed a framework. Not a magic trick - just a structured approach that works for any system design question. I've used it in interviews at Google, Meta, Amazon, and multiple startups. It works.

    The 5-Step Framework

    My System Design Structure (45-60 min)

    1. 1
      Requirements & Constraints (5 min)

      Ask questions. Clarify scope. Define functional and non-functional requirements.

    2. 2
      Capacity Estimation (5 min)

      Back-of-envelope math. Users, requests per second, storage, bandwidth.

    3. 3
      High-Level Design (10-15 min)

      Draw the main components. APIs. Data flow. Keep it simple first.

    4. 4
      Deep Dive (15-20 min)

      Pick 2-3 components to detail. Database schema. Caching strategy. Specific algorithms.

    5. 5
      Bottlenecks & Trade-offs (5-10 min)

      What could break? How would you scale? What are you trading off?

    Step 1: Requirements & Constraints

    This is where most people mess up. They hear "Design Instagram" and start drawing boxes. Don't. Ask questions first.

    Questions to Ask

    Functional Requirements
    • • What are the core features? (post photos, follow users, news feed)
    • • What can we skip? (stories, reels, DMs, search)
    • • Any specific user flows to focus on?
    Non-Functional Requirements
    • • Scale: How many users? DAU? Peak traffic?
    • • Latency: What's acceptable? 100ms? 500ms?
    • • Availability: 99.9%? 99.99%?
    • • Consistency: Strong or eventual?

    Common Mistake

    Skipping requirements to "save time." The interviewer wants to see you scope the problem. Spending 5 minutes here shows maturity and prevents you from designing the wrong thing.

    Step 2: Capacity Estimation

    Back-of-envelope math. You don't need exact numbers - you need the right order of magnitude. This tells you if you need 1 server or 1000.

    Example: Instagram-like System

    Users: 500M DAU
    Posts per day: 50M new posts
    Average post size: 500KB (compressed image)
    
    Storage (daily): 50M * 500KB = 25TB/day
    Storage (yearly): 25TB * 365 = ~9PB/year
    
    Read requests: Assume 100 reads per user per day
      500M * 100 = 50B reads/day
      = ~580K reads/second
    
    Write requests: 50M posts/day
      = ~580 writes/second
    
    Ratio: Read-heavy (~1000:1 read:write)

    Numbers to memorize:

    • • 1 day = 86,400 seconds ≈ 100K seconds
    • • 1 million requests/day ≈ 12 requests/second
    • • 1 byte = 8 bits
    • • 1KB = 1000 bytes, 1MB = 1000KB, 1GB = 1000MB, 1TB = 1000GB
    • • Typical server handles ~1000-10000 QPS depending on complexity

    Step 3: High-Level Design

    Now you draw. Start simple. Add complexity only when needed.

    Standard Components to Consider

    Client & Load Balancer

    Entry point. Distribute traffic.

    API Gateway

    Authentication, rate limiting, routing.

    Application Servers

    Business logic. Stateless ideally.

    Database

    SQL vs NoSQL. Sharding strategy.

    Cache

    Redis/Memcached. What to cache?

    CDN & Object Storage

    For static content, images, videos.

    Message Queue

    Async processing. Kafka, RabbitMQ, SQS.

    Search

    Elasticsearch for text search.

    API Design

    Define your main APIs before diving deeper. This shows you're thinking about interfaces, not just infrastructure.

    Example APIs (Instagram)

    POST /posts
      body: { image_url, caption, location }
      returns: { post_id, created_at }
    
    GET /feed?user_id={id}&cursor={cursor}&limit=20
      returns: { posts: [...], next_cursor }
    
    POST /follow
      body: { follower_id, followee_id }
    
    GET /users/{id}/posts?cursor={cursor}&limit=20

    Step 4: Deep Dive

    The interviewer will ask you to go deeper on specific areas. Be ready to discuss:

    Database Schema

    Know when to use SQL vs NoSQL. Discuss your schema choices.

    Users Table:
      user_id (PK), username, email, created_at
    
    Posts Table:
      post_id (PK), user_id (FK), image_url,
      caption, created_at, location
    
    Follows Table:
      follower_id, followee_id, created_at
      (composite PK or separate index)

    Caching Strategy

    What to cache, where, and for how long.

    • User profiles: High read, low write. Cache with 1hr TTL.
    • Feed: Pre-compute and cache for active users.
    • Post counts: Update async, cache aggressively.
    • Cache invalidation: Write-through or TTL-based?

    News Feed Generation

    The classic deep-dive question for social systems.

    Pull Model (Fan-out on read)

    When user requests feed, query all followees' posts and merge. Simple but slow for users following many accounts.

    Push Model (Fan-out on write)

    When user posts, push to all followers' pre-computed feeds. Fast reads, expensive writes. Bad for celebrities.

    Hybrid (What most do)

    Push for normal users, pull for celebrities. Most practical at scale.

    Step 5: Bottlenecks & Trade-offs

    Always end by discussing what could break and how you'd address it. This shows senior-level thinking.

    Database Bottleneck

    "The database will be our bottleneck at scale. I'd address this with read replicas for read-heavy traffic, and sharding by user_id for writes. For the follows table specifically, we might need a graph database like Neo4j."

    Hot Partitions

    "Celebrity accounts create hot partitions. We'd handle this by not pre-computing their posts into feeds, and instead fetching their posts at read time for their followers."

    Consistency vs Availability

    "We're choosing eventual consistency for the feed - it's okay if a new post takes a few seconds to appear. But for follow/unfollow actions, we want stronger consistency so the UX is clear."

    Common System Design Questions

    Must-Know Systems

    • • URL Shortener (TinyURL)
    • • Twitter/News Feed
    • • Chat System (WhatsApp)
    • • Instagram/Photo Sharing
    • • Rate Limiter
    • • Web Crawler

    Advanced Systems

    • • Distributed Cache
    • • Search Autocomplete
    • • Video Streaming (Netflix)
    • • Ride Sharing (Uber)
    • • Distributed Job Scheduler
    • • Notification System

    How to Practice

    • Study one system per day. Read about the design, draw the diagram, explain it out loud.
    • Practice on a whiteboard or drawing tool. The physical act of drawing while explaining is different from just reading.
    • Time yourself. 45 minutes is standard. If you can't cover the basics in 45 min, you're going too deep too early.
    • Mock interviews are essential. System design is interactive. You need someone asking questions and poking at your design.

    I use LastRound AI for system design practice. It asks follow-up questions like a real interviewer: "What happens if this service goes down?" "How would you handle 10x traffic?" Helps me practice thinking on my feet.

    Practice System Design

    AI-powered mock interviews with follow-up questions. 15 free credits monthly.

    Resources I Used

    • Designing Data-Intensive Applications by Martin Kleppmann - The bible. Dense but essential.
    • System Design Interview by Alex Xu - Great for structured prep. Covers common questions.
    • ByteByteGo - Good visuals and explanations.
    • Actual engineering blogs - How Netflix, Uber, Meta actually built their systems.

    Final Thoughts

    System design interviews are less about having the "right" answer and more about demonstrating structured thinking. Use a framework, ask questions, explain your trade-offs, and be honest about what you don't know.

    The more systems you study, the more patterns you'll recognize. And patterns are what make these interviews manageable.

    Last updated: January 2026

    More Technical Guides