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
- Ask questions before designing.
- Know the basic building blocks and when to use each.
- Draw a simple, sensible architecture.
- Talk about trade-offs ("a cache makes reads fast but data can be stale").
- Not: memorised diagrams of Uber with 40 boxes.
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
- 1 day ≈ 86,400 s ≈ 10⁵ s → 1 million requests/day ≈ 12 per second.
- Reading from memory ≈ microseconds; from SSD ≈ ~0.1–1 ms; a network round trip across countries ≈ 100+ ms.
- A single decent server handles hundreds to a few thousand simple requests per second.
- Most apps are read-heavy (10:1 to 100:1).
- Availability: 99.9% ≈ 8.8 hours of downtime a year.
A 6-step method for any question
- Clarify requirements (2–3 min) — what must it do? How many users? Read-heavy or write-heavy? Does it need to be real-time?
- Estimate roughly — requests per second, storage per year.
- Define the API — 2–4 main endpoints.
- Design the data — main tables/collections and their keys.
- Draw the high-level design — client → load balancer → servers → cache → database, plus queue/CDN/storage if needed.
- 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
- Requirements: shorten a URL, redirect quickly, optional expiry and click count. Read-heavy (100 redirects per new link).
- Estimate: 1 lakh new links/day ≈ 1–2 writes/s; ~150 redirects/s. Small.
- API:
POST /api/urls {longUrl}→ short code;GET /{code}→ redirect. - Data:
urls(code PK, long_url, created_at, expires_at, clicks). - Design: app servers behind a load balancer → Redis cache for
code → long_url→ database. - 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?"
- Today: one Node server + one MongoDB.
- Static files (React build, images) → move to a CDN and image storage.
- More traffic → run 3–4 Node servers behind a load balancer; keep them stateless (JWT, sessions in Redis).
- Slow pages → indexes on fields you search/sort by (author, createdAt, slug); cache popular posts in Redis.
- Database load → read replicas for reads.
- Emails / notifications → a queue so requests return fast.
- 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
- Jumping to microservices and Kafka for a small problem.
- Not asking how many users or what matters most.
- Storing images/videos in the database.
- Forgetting indexes — the cheapest performance win.
- Never mentioning what happens when something fails.
How to practise
- Read the system design notes: Scalability, Caching, Load Balancing, CAP Theorem.
- Do one design a week out loud: URL shortener, chat app, file storage, news feed.
- Revise system design interview questions.
- 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
- How to Use Codify: A 7-Day Start Plan — New here? Pick a roadmap, make a study plan, start the DSA sheet, revise with notes, practise for placements and test yourself — one step a day, then a daily routine.
- Infosys Preparation Guide: Online Test, Pseudocode and Interview — Roles (SE, DSE, SP), what each section of the Infosys online test checks, how to crack pseudocode and reasoning, a 4-week plan and the interview.
- Wipro Elite NLTH Preparation: Aptitude, Essay and Coding — The Wipro fresher test round by round — quant, logical and verbal, the written essay, two coding problems — plus a 3-week plan and interview tips.
- Accenture Preparation Guide: Cognitive, Technical, Coding and Communication — Every Accenture round explained — cognitive, MS Office/networking/cloud technical MCQs, pseudocode, coding and the spoken-English test — with a 4-week plan.