Interview rubric
How System Design Interviews Are Scored: Rubric by Level (2026)
A system design interview is scored on 6 dimensions: requirements and scoping (20%), high-level architecture (20%), data model and storage (15%), deep dives and trade-offs (20%), reliability and operations (10%), communication and driving (15%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on requirements and scoping means: "Raises a key non-functional requirement unprompted and uses an estimate to shape the design."
The dimensions and their weights
| Dimension | Weight | Solid (3) at mid level |
|---|---|---|
| Requirements and scoping | 20% | Works effectively with the given requirements and makes basic scale estimates. |
| High-level architecture | 20% | Produces a clean high-level design with clear components, data flow and APIs. |
| Deep dives and trade-offs | 20% | Completes one solid deep dive and names trade-offs for key choices. |
| Data model and storage | 15% | Gives a schema that fits the access patterns and justifies the storage choice. |
| Communication and driving | 15% | Follows a clear structure from requirements to design and manages time. |
| Reliability and operations | 10% | Mentions concrete failure handling when asked, such as replication and timeouts. |
What changes between levels
On requirements and scoping, the heaviest dimension, an outstanding mid-level answer "raises a key non-functional requirement unprompted and uses an estimate to shape the design", while an outstanding senior answer "sets explicit SLOs and cuts scope deliberately, explaining what is out and why". The same answer can score 4 at mid level and 2 at senior: senior candidates are expected to raise things unprompted that mid-level candidates may be asked about.
Every score, at every level
Requirements and scoping (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Starts drawing or coding without understanding what the API or component must do. | Lists the main features only after the interviewer spells them out. | Works from the given requirements and asks one or two questions about inputs and outputs. | Asks about core use cases and rough usage numbers unprompted before designing. |
| Junior | Designs without confirming the requirements and builds the wrong thing. | Confirms functional requirements only after being redirected. | Works from the given functional requirements and asks basic questions about scale when prompted. | Clarifies functional requirements and one non-functional need such as latency unprompted. |
| Mid-level | Designs without confirming requirements and misses a core use case. | Takes the requirements as given but never estimates scale, even when asked. | Works effectively with the given requirements and makes basic scale estimates. | Raises a key non-functional requirement unprompted and uses an estimate to shape the design. |
| Senior | Designs without confirming requirements or scale. | Waits for the interviewer to supply scale and non-functional requirements. | Surfaces the key non-functional requirements and scale estimates unprompted and agrees scope. | Sets explicit SLOs and cuts scope deliberately, explaining what is out and why. |
| Staff | Designs without confirming requirements or scale. | Surfaces requirements unprompted but misses the constraint that drives the design. | Names the constraint that drives the design before the interviewer points to it. | Names the driving constraint and frames requirements by customer, cost and team ownership. |
High-level architecture (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot sketch how a request flows through even a simple service. | Sketches a client and a database but cannot define the API between them. | Defines a small set of endpoints and the main components with help on data flow. | Defines clean endpoints and traces a request end to end without help. |
| Junior | Proposes components that cannot serve the core use case. | Names correct components but cannot explain how data moves between them. | Draws correct components and APIs and traces the main request path. | Draws a clean design with clear APIs and separates read and write paths. |
| Mid-level | Proposes an architecture that cannot serve the core use case. | Draws a workable design that needs the interviewer to fill gaps in data flow. | Produces a clean high-level design with clear components, data flow and APIs. | Produces a clean design quickly and explains why each component exists. |
| Senior | Proposes an architecture that cannot serve the core use case. | Produces a generic textbook design not adapted to the stated requirements. | Produces a design fitted to the requirements, with each component justified by a need. | Fits the design to the requirements and points out where it will need to change at higher scale. |
| Staff | Proposes an architecture that cannot serve the core use case. | Produces a clean but generic design, the kind that passes at mid level. | Finishes a fitted base design in about 15 minutes and spends the rest on depth. | Finishes the base design fast and shows how it evolves over the next two years. |
Data model and storage (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot describe what data needs to be stored. | Lists the data but cannot shape it into tables or records. | Sketches a simple schema with keys for the main entities, with some help. | Sketches a sensible schema and explains which field each query looks up. |
| Junior | Picks storage that cannot support the core queries. | Sketches a schema but cannot say why that database suits it. | Sketches a correct schema and picks a database with a basic reason. | Sketches a correct schema, picks storage for the access pattern and adds an index. |
| Mid-level | Picks storage that cannot support the core queries. | Gives a schema but storage choice is unjustified or ignores the access pattern. | Gives a schema that fits the access patterns and justifies the storage choice. | Also chooses a partition key and explains the hot-spot risk it avoids. |
| Senior | Picks storage that cannot support the core queries. | Justifies storage but ignores partitioning or consistency until asked. | Justifies schema, partitioning and consistency choices for this workload unprompted. | Compares two storage options with concrete trade-offs and plans for re-partitioning. |
| Staff | Picks storage that cannot support the core queries. | Makes sound storage choices but does not tie consistency to business impact. | Ties consistency and partitioning choices to business impact and data growth. | Covers data lifecycle, migration and cost of the storage choice over time. |
Deep dives and trade-offs (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot explain any choice when asked why. | Explains one choice only after the interviewer suggests the alternative. | Names one trade-off when asked, such as caching against freshness. | Names a trade-off unprompted and explains which way they chose. |
| Junior | Cannot explain any choice when asked why. | Names a trade-off only after the interviewer names it first. | Names one trade-off when asked and explains the choice. | Names trade-offs unprompted and goes one level deeper on a component. |
| Mid-level | Cannot go deeper than the boxes on the diagram. | Attempts a deep dive but needs the interviewer to lead it. | Completes one solid deep dive and names trade-offs for key choices. | Completes a deep dive on the real bottleneck and justifies choices for this context. |
| Senior | Cannot go deeper than the boxes on the diagram. | Completes one deep dive and names trade-offs without tying them to this context. | Completes several deep dives and explains why each choice fits this context. | Picks the deep dives that matter most unprompted and quantifies the trade-offs. |
| Staff | Cannot go deeper than the boxes on the diagram. | Completes solid deep dives but argues trade-offs in textbook terms only. | Ties trade-offs to this team, this quarter and this customer base. | Ties trade-offs to the organisation that will run the system and how it will evolve. |
Reliability and operations (10%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot say what happens when a server or database fails. | Mentions failure only when asked and cannot suggest a fix. | Suggests a basic fix such as retries or a backup when asked about failure. | Raises one failure case unprompted and suggests a simple mitigation. |
| Junior | Cannot say what happens when a component fails. | Discusses failure only when asked, with vague answers. | Handles a failure case when asked, using retries or replication. | Raises a failure case and basic monitoring unprompted. |
| Mid-level | Ignores failure handling even when asked. | Gives vague failure handling when asked. | Mentions concrete failure handling when asked, such as replication and timeouts. | Raises failure modes and monitoring unprompted. |
| Senior | Ignores failure handling even when asked. | Covers failure modes only when asked. | Covers failure modes and monitoring unprompted, with concrete mitigations. | Covers failure modes, alerting on SLOs and graceful degradation unprompted. |
| Staff | Ignores failure handling even when asked. | Covers the obvious failure modes only. | Covers failure modes beyond the obvious, multi-region, cost and on-call ownership. | Covers subtle failure modes, cost, operations and how the design changes for multi-region. |
Communication and driving (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Stays silent or jumps between ideas with no thread. | Explains only when asked and loses track of the design. | Explains the design step by step when guided by the interviewer. | Explains the design in a clear order and checks understanding with the interviewer. |
| Junior | Stays silent or jumps between ideas with no thread. | Follows the interviewer's lead but cannot structure the discussion. | Explains the design clearly while the interviewer sets the agenda. | Explains clearly and proposes the next topic to cover. |
| Mid-level | Stays silent for long stretches or jumps between components with no thread. | Needs the interviewer to set every step of the agenda. | Follows a clear structure from requirements to design and manages time. | Drives the session with a stated agenda and adapts to the interviewer's questions. |
| Senior | Gives a disorganised walkthrough that the interviewer has to structure for them. | Structures the answer but the interviewer has to pull out the depth. | Drives the session, states an agenda, manages time and checks in at key points. | Drives confidently, handles pushback with reasons and finishes with a clear summary. |
| Staff | Cannot present the design coherently, even with the interviewer setting the agenda. | Drives the structure but runs out of time before depth. | Runs the session like a design review and spends most of the time on depth. | Runs a crisp review, invites challenge and summarises risks and next steps. |
Get scored against this rubric
Thita's AI interviewer runs a live system design round and scores you against exactly this rubric, dimension by dimension, for the level you choose.
Practise a system design roundWhere this rubric comes from
These rubrics are researched: they follow the scoring methods big-tech companies describe publicly (behaviourally anchored ratings, bar raisers, leadership principles, named interview signals) and how their rounds are commonly run. No company publishes its actual scoring sheet, so the level-by-level wording is our own synthesis. It is the same rubric our AI interviewer scores every mock against.
Questions, answered
- How is a system design interview scored?
- A system design interview is scored on 6 dimensions: requirements and scoping (20%), high-level architecture (20%), data model and storage (15%), deep dives and trade-offs (20%), reliability and operations (10%), communication and driving (15%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on requirements and scoping means: "Raises a key non-functional requirement unprompted and uses an estimate to shape the design."
- What is the difference between a mid-level and a senior system design answer?
- On requirements and scoping, the heaviest dimension, an outstanding mid-level answer "raises a key non-functional requirement unprompted and uses an estimate to shape the design", while an outstanding senior answer "sets explicit SLOs and cuts scope deliberately, explaining what is out and why". The same answer can score 4 at mid level and 2 at senior: senior candidates are expected to raise things unprompted that mid-level candidates may be asked about.
- What does a score of 3 mean?
- Scores are relative to the level you are interviewing for. A 3 means solid for that level: the bar is met without help on the key points. A 4 means the candidate also raised the important points unprompted. A 2 usually means the interviewer had to lead the candidate to them.
- Is this the official rubric used by Google, Meta or Amazon?
- These rubrics are researched: they follow the scoring methods big-tech companies describe publicly (behaviourally anchored ratings, bar raisers, leadership principles, named interview signals) and how their rounds are commonly run. No company publishes its actual scoring sheet, so the level-by-level wording is our own synthesis. It is the same rubric our AI interviewer scores every mock against.