Article
How to prepare for the System Design Interview
Detailed article about preparing for System Design interviews
The question of how to prepare for the System Design Interview has come up frequently. The answer depends heavily on preparation time. In this chapter we will look at a long-term approach to developing architectural thinking and a systematic interview framework.
7-Step System Design Interview Framework
This 7-step System Design Interview framework was created by the author at T-Bank and validated in hundreds of interviews personally, and at company scale across tens of thousands of System Design Interviews.
Before we talk about preparation, it is important to understand the structure of the interview itself. We use a 7-step framework that helps us take a systematic approach to the design of any system:
Task statement
- Baseline context
- Functional requirements
- Non-functional requirements
Formalization
- Core functions
- Key -ilities
- Basic sizing: users, requests...
System boundaries
- Use cases
- Public API
- Integration contracts
Technology choices
- Concrete technologies
- Capacity planning
- Failure domains
Additional questions
- Observability
- Security
- Deployment
- Advanced topics
Workflow & components
- Happy path
- Scaling for NFRs
- Corner cases and failures
Conceptual diagram
- Public API in the diagram
- Components with classes (K/V, RDBMS)
- Data models
- Stateful/Stateless
Task statement
- Baseline context
- Functional requirements
- Non-functional requirements
Formalization
- Core functions
- Key -ilities
- Basic sizing: users, requests...
System boundaries
- Use cases
- Public API
- Integration contracts
Workflow & components
- Happy path
- Scaling for NFRs
- Corner cases and failures
Conceptual diagram
- Public API in the diagram
- Components with classes (K/V, RDBMS)
- Data models
- Stateful/Stateless
Technology choices
- Concrete technologies
- Capacity planning
- Failure domains
Additional questions
- Observability
- Security
- Deployment
- Advanced topics
Now let's look at each step in more detail and figure out how to prepare for it.
Related chapter
Software Requirements (Wigers)
Requirement levels, identification techniques, prioritization and change management.
Step 1: Formalization of requirements
At this stage you clarify functional requirements (what the system should do) and non-functional requirements (how she should do it). This is a critical step because without it you risk designing the wrong system.
Non-functional requirements (-ilities)
- High Availability — the system must be available 99.9%+ of the time
- Scalability — the system must cope with increasing load
- Performance — latency p99 < 100ms or other SLO
- Durability — data should not be lost
- Consistency — eventual vs strong consistency - an informed choice
- Fault Tolerance — the system experiences component failures
Key Tip
Always check with the interviewer: what characteristics are critical? Cannot be optimized everything at once - choose your priorities. For example, for a banking system consistency is more important than latency, and for a social network feed it’s the other way around.
Related chapter
API Gateway
API contracts, routing, limits and access control at the external perimeter.
Step 2: System Boundaries (Public API)
Determine how the outside world will interact with your system. This is a contract between the system and its clients.
REST API
Standard choice for public APIs. Well suited for CRUD operations.
RPC (gRPC)
Effective for internal services. Strict contracts via protobuf.
Messaging
For asynchronous integration. Kafka, RabbitMQ, SQS.
Related chapter
Event-Driven Architecture
Data flows, events, retry and compensation in distributed scenarios.
Step 3: Core Flows and Components
Draw the main data flows in the system. Start with happy path — main use case and then add exceptional flows.
- Read path — how data is read from the system (caches, replicas)
- Write path — how data is recorded (queues, logging)
- Happy path — main successful scenario
- Exceptional flows — error handling, retrays, fallbacks
Related chapter
Guide to Databases
Conceptual data modeling and storage selection for load scenarios.
Step 4: Conceptual Data Diagram
Design a data model without committing to specific technologies just yet. Identify the main entities and the relationships between them.
Stateful components
- Databases
- Caches with persistence
- Message Queues
- File storage
Stateless components
- API servers
- Workers/Processors
- Load balancers
- Gateways
Related chapter
Database Selection Framework
A practical framework for choosing a DBMS, taking into account trade-offs and requirements.
Step 5: Real Circuit (Technology)
Now we choose specific technologies. It is important to understand the trade-offs of each decision and be able to justify your choice.
Failure Domains
Be sure to consider what will happen if each component fails. What is the blast radius? How will the system recover? This shows the maturity of the engineer.
Related chapter
Design principles for scalable systems
Vertical/horizontal scaling, sharding and bottlenecks.
Step 6: Scaling
When the basic architecture is ready, discuss how the system will scale with load growth of 10x, 100x, 1000x.
- Vertical scaling — increasing the resources of one machine (easier, but limited)
- Horizontal scaling — adding new instances (more difficult, but unlimited)
- Data partitioning — separating data by key (user_id, region, time)
- Sharding — distribution of data across several databases
- Consistent hashing — minimizing redistribution when adding nodes
Related chapter
Observability & Monitoring Design
Deep analysis of logs/metrics/traces and alerting practices.
Step 7: Advanced Topics
If there is time left, discuss topics for long-term system operation:
- Observability — metrics, logs, traces - how to understand that the system is healthy
- Alerting — what to be alert for and how not to get drowned in noise
- Deployment — blue-green, canary, feature flags
- Disaster Recovery — RTO/RPO, backup strategies, failover
- Security — authentication, authorization, encryption at rest/in transit
Related chapter
Interview assessment and difficulty variation
How the interviewer calibrates the level and by what criteria the solution is assessed.
Tips for a successful interview
I've put together a short list of tips that I think will improve your efficiency. interview and the likelihood that you will be able to show your best sides:
- Remember the time — The interview time is usually limited to an hour and a lot needs to be discussed during it. That is why you should not get bogged down in any details, but control the timing and move towards solving the problem
- Don't start designing right away — It is important to clearly understand the problem and only then begin to solve it. If you have questions after reading the terms and conditions, it is better to get answers to them first, otherwise you may start a task that is not the one you were asked to do.
- Share your thoughts — This type of interview is needed in order to understand how you solve complex problems and how you think when solving them. If you mostly silently draw a diagram and occasionally tell what you have drawn, then the interviewer will not understand the full depth of your idea
- Show independence in design — this is an open interview where the candidate can show his strengths and show how he designs. But if the interviewer has to guide the candidate through the task, giving structure and helping with the solution, then this will not add points to the candidate
- Respond to leading questions — usually the interviewer with such questions tries to lead the candidate to the right thoughts when he has stalled
- Speak confidently about what you know — You shouldn’t talk about something you’ve only vaguely heard about, as the interviewer may ask for details and then the candidate will have to blush
- Prepare questions for the interviewer — in case there is time left for them - this shows that you are interested in learning about the company and what is happening in it
Related chapter
Recommendations for preparation (long term)
A detailed long-term plan for developing skills for each step of the interview.
Long-term training: what to read
For a deep understanding of System Design, we recommend studying professional literature. Books provide a foundation that will not be out of date in a year and help you understand the principles and not just remember ready-made solutions.
Part 4: Review of System Design Sources
A complete collection of book reviews on distributed systems, architecture, microservices, DDD and SRE - with key ideas and practical conclusions
Conclusion
Long-term preparation for the System Design Interview is development of engineering thinking, rather than memorizing ready-made answers. Read books, study the architecture of real systems, practice mock interviews.
Use the 7-step framework as a structure for any interview. He will help don’t get lost and show a systematic approach to design.
In the next chapter we will look at short-term preparation tactics - what to do, if the interview is in a week.
