Getting everything ready for you…

Loading courses, problems and your progress. This takes just a moment.

0s

Guides › Interviews

System Design for Freshers: The Basics, a Method and Two Examples

What interviewers expect from freshers, the building blocks (load balancer, cache, CDN, queues, sharding), a 6-step method and worked examples.

System design used to be only for experienced engineers. Now many companies ask freshers a light version — "How would you design a URL shortener?" or "How would your project handle a million users?" — and project discussions often turn into system design. The good news: at fresher level they're checking how you think, not whether you've run Netflix. This guide gives you the building blocks, a step-by-step method and two worked examples.

What interviewers expect from a fresher

The building blocks

Block One-line idea Learn more
Client / server Browsers and apps call your server over HTTP What happens when you type a URL
Load balancer Spreads requests across many servers Load Balancing
Stateless app servers Any server can handle any request, so you can add more Scalability
Database SQL for structured, related data; NoSQL for flexible/huge scale SQL vs NoSQL
Index Makes lookups O(log n) instead of scanning everything same note
Cache (Redis) Keep hot data in memory — milliseconds faster Caching & CDN
CDN Serve images/JS/CSS from servers near the user same note
Replication Copies of the DB for reads and failover Sharding & Replication
Sharding Split data across DB servers when one is too small same note
Message queue Do slow work later (emails, video processing) Message Queues
Object storage Store files (S3) — not in the database —

Five numbers worth remembering

A 6-step method for any question

  1. Clarify requirements (2–3 min) — what must it do? How many users? Read-heavy or write-heavy? Does it need to be real-time?
  2. Estimate roughly — requests per second, storage per year.
  3. Define the API — 2–4 main endpoints.
  4. Design the data — main tables/collections and their keys.
  5. Draw the high-level design — client → load balancer → servers → cache → database, plus queue/CDN/storage if needed.
  6. Improve and discuss trade-offs — bottlenecks, failure of a component, scaling the DB.

Say each step out loud. Silence is the biggest mistake.

Worked example 1: URL shortener

  1. Requirements: shorten a URL, redirect quickly, optional expiry and click count. Read-heavy (100 redirects per new link).
  2. Estimate: 1 lakh new links/day ≈ 1–2 writes/s; ~150 redirects/s. Small.
  3. API: POST /api/urls {longUrl} → short code; GET /{code} → redirect.
  4. Data: urls(code PK, long_url, created_at, expires_at, clicks).
  5. Design: app servers behind a load balancer → Redis cache for code → long_url → database.
  6. Trade-offs: generate codes with a counter + base62 (no collisions) vs hashing (collisions to handle); 301 (browser caches, fewer hits) vs 302 (every click counted).

The full interview-level version: Design a URL Shortener. Build it yourself: URL shortener project.

Worked example 2: "Scale your own project"

Say you built a MERN blog. "What if 1 lakh people use it?"

  1. Today: one Node server + one MongoDB.
  2. Static files (React build, images) → move to a CDN and image storage.
  3. More traffic → run 3–4 Node servers behind a load balancer; keep them stateless (JWT, sessions in Redis).
  4. Slow pages → indexes on fields you search/sort by (author, createdAt, slug); cache popular posts in Redis.
  5. Database load → read replicas for reads.
  6. Emails / notifications → a queue so requests return fast.
  7. Monitoring → logs, error tracking, uptime alerts.

This answer works for almost any project — practise it on yours.

Low-level design (LLD) — the other kind

Some interviews ask you to design classes instead: a parking lot, a library, an elevator. That's OOP + design patterns. See Low-Level Design: Parking Lot and SOLID Principles.

Common mistakes

How to practise

  1. Read the system design notes: Scalability, Caching, Load Balancing, CAP Theorem.
  2. Do one design a week out loud: URL shortener, chat app, file storage, news feed.
  3. Revise system design interview questions.
  4. Explain your own project's architecture in an AI mock interview.

You don't need to know everything — you need a clear method, the basic blocks, and the habit of talking about trade-offs.

More guides