How to Approach Any System Design Question: A 6-Step Framework

How to Approach Any System Design Question: A 6-Step Framework

A six-step framework for system design interviews: requirements, estimates, API, data model, high-level design and deep dives, with a worked example.

System design interviews feel open-ended: "Design a URL shortener", "Design WhatsApp", "Design a ride-hailing backend". There is no single correct answer, and that uncertainty makes many candidates either freeze or ramble. A consistent framework solves this. It gives the conversation structure, ensures you cover what interviewers look for, and leaves time for the deep discussion that distinguishes strong candidates. Here is a six-step approach with a worked example.

What interviewers evaluate

  • Requirement gathering: do you clarify scope before designing?
  • High-level design: can you lay out a sensible architecture?
  • Depth: can you go deep on the hardest parts?
  • Trade-offs: do you explain why you chose one option over another?
  • Communication: is your reasoning clear and structured?
  • Practicality: is the design realistic for the stated scale?

Step 1: Clarify requirements (5–8 minutes)

Ask about:

Write the agreed requirements down. Explicitly state what is out of scope.

  • Functional requirements: what must the system do? Which features are in scope?
  • Non-functional requirements: scale, latency, availability, consistency, durability.
  • Users and usage patterns: read-heavy or write-heavy? Global or regional?
  • Constraints: existing systems, budget, team size.

Step 2: Estimate scale (3–5 minutes)

Rough numbers guide design choices. Estimate requests per second, storage over a few years, and bandwidth. Do not over-invest in precision; order of magnitude is enough. Say your assumptions aloud.

Step 3: Define the API (3–5 minutes)

Sketch the main endpoints or operations with inputs and outputs. This clarifies what the system actually does and how clients use it.

Step 4: Design the data model (5 minutes)

Identify the main entities, their relationships, and access patterns. Choose storage based on those patterns: relational databases for transactions and relationships, key-value stores for simple high-throughput lookups, document stores for flexible schemas, and so on. Explain why.

Step 5: High-level design (10 minutes)

Draw the main components: clients, load balancers, application services, databases, caches, queues, and external services. Walk through the main request flows end to end. Keep it simple first, then evolve.

Step 6: Deep dives and trade-offs (15–20 minutes)

This is where most of the evaluation happens. Pick the hardest or most interesting parts — or follow the interviewer's lead — and go deep: scaling the database, caching strategy, consistency guarantees, failure handling, hot keys, rate limiting, monitoring. For each, discuss options and trade-offs.

At each step, end with a quick check: "Does this cover what you had in mind, or would you like me to go deeper anywhere?" Interviewers often have specific areas they want to explore, and checking in helps you spend time where it counts.

Worked example: URL shortener

Requirements

Functional: create a short URL for a long URL; redirect short URLs to the original; optional custom aliases and expiry. Non-functional: redirects must be fast and highly available; the system is read-heavy; short codes must be unique.

Estimates

Assume 100 million new URLs per month and a read-to-write ratio of 100:1. That is roughly 40 writes per second and 4,000 redirects per second on average, with higher peaks. Over five years, about six billion URLs; at roughly 500 bytes each, around 3 TB of storage.

API

Data model

A table mapping `short_code` to `long_url`, `created_at`, `expires_at`, and `user_id`. Access is almost entirely lookup by `short_code`, so a key-value store or a relational database indexed on `short_code` works.

High-level design

Clients call an application service behind a load balancer. Writes generate a unique short code and store the mapping. Reads check a cache (such as Redis) first, then the database, and return a redirect.

Deep dives

  • Generating codes: base62 encoding of a unique ID from a distributed ID generator, versus hashing with collision checks. Seven base62 characters give about 3.5 trillion combinations, plenty for six billion URLs.
  • Caching: popular links get heavy traffic; cache with LRU eviction, and consider a CDN or edge cache for redirects.
  • Redirect type: 301 is cached by browsers (less load, less analytics); 302 allows tracking each click.
  • Scaling storage: partition by short code; replicate for availability.
  • Abuse: rate limiting on creation and scanning for malicious URLs.

Adapting the framework to the level

For early-career candidates, interviewers mainly expect clear requirements, a sensible high-level design and basic trade-offs. For senior candidates, they expect deeper discussion: failure handling, data migration, multi-region concerns, operational monitoring, and the cost of different choices. The steps stay the same; the depth of step 6 changes.

Common mistakes

  • Designing before clarifying requirements.
  • Jumping to microservices, Kafka and sharding for a system that does not need them.
  • Spending too long on estimates or drawing boxes without explaining flows.
  • Not discussing trade-offs.
  • Ignoring failure modes and monitoring.
  • Not leaving time for deep dives.

How to practise

Practise common problems — URL shortener, rate limiter, chat system, news feed, notification system, file storage, ride-hailing — using the six steps, out loud, with a timer. Review real architectures in engineering blogs. See our guide to system design resources and consistency models for deeper study.

Getting to the design round

Make sure your resume shows systems you have designed or owned — the Algnetic ATS resume builder can help — and use auto-apply to keep applications going while you practise.

Key takeaways

  • Use six steps: requirements, estimates, API, data model, high-level design, deep dives.
  • Clarify scope and state assumptions before designing.
  • Start simple and evolve the design based on requirements.
  • Spend the most time on deep dives and trade-offs.
  • Check in with the interviewer and practise aloud under time limits.

Let Algnetic apply to matching jobs for you · More career guides

Related guides

https://algnetic.com/blog/how-to-approach-any-system-design-question