Interview rubric
How Low-Level Design Interviews Are Scored: Rubric by Level (2026)
A low-level design interview is scored on 6 dimensions: requirements and use cases (15%), class and entity modelling (25%), design principles and patterns (15%), extensibility and change handling (15%), code or skeleton quality (15%), communication (15%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on class and entity modelling means: "Models cleanly and separates domain objects from managers or services with reasons."
The dimensions and their weights
| Dimension | Weight | Solid (3) at mid level |
|---|---|---|
| Class and entity modelling | 25% | Models classes with single clear responsibilities and correct relationships. |
| Requirements and use cases | 15% | Clarifies use cases, actors and edge cases unprompted and agrees scope. |
| Design principles and patterns | 15% | Applies SOLID principles and fitting patterns with no pattern-stuffing. |
| Extensibility and change handling | 15% | Handles a mid-interview change by extension, touching few existing classes. |
| Code or skeleton quality | 15% | Writes clean interfaces and a correct core flow; mentions thread safety where relevant. |
| Communication | 15% | Thinks aloud, explains each choice and walks a use case through the design. |
What changes between levels
On class and entity modelling, the heaviest dimension, an outstanding mid-level answer "models cleanly and separates domain objects from managers or services with reasons", while an outstanding senior answer "models cohesive classes with interfaces at the points of change and justifies each". 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 use cases (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Starts writing classes without knowing what the system must do. | Lists use cases only after the interviewer spells them out. | Asks a couple of questions when prompted and lists the main use cases. | Lists the main use cases unprompted and asks what is out of scope. |
| Junior | Designs classes for the wrong problem. | Confirms use cases only after being redirected. | Lists the core use cases and confirms them with the interviewer before modelling. | Lists core use cases and edge cases such as cancellation unprompted. |
| Mid-level | Designs classes for the wrong problem. | Lists use cases only when prompted and misses an important one. | Clarifies use cases, actors and edge cases unprompted and agrees scope. | Also asks which parts are likely to change and plans the design around them. |
| Senior | Designs classes for the wrong problem. | Clarifies basic use cases but misses constraints such as concurrency until asked. | Clarifies use cases, edge cases and constraints such as concurrency unprompted. | Prioritises use cases, cuts scope deliberately and names likely future changes. |
| Staff | Designs classes for the wrong problem. | Clarifies use cases but not the constraints that shape the design. | Clarifies use cases and the constraints that drive the design, and agrees scope quickly. | Frames requirements by how the code will be extended and owned by other teams. |
Class and entity modelling (25%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot name the main classes or puts everything into one class. | Names classes only with heavy help and mixes up their responsibilities. | Names the main classes and their fields, with help on relationships. | Names the main classes, their fields and relationships without help. |
| Junior | Puts all logic into one class or models the wrong entities. | Names classes but gives them overlapping or unclear responsibilities. | Models the main classes with clear responsibilities and basic relationships. | Models classes cleanly and explains each relationship, such as composition. |
| Mid-level | Models the wrong entities or one class that does everything. | Models workable classes that need the interviewer to fix responsibilities. | Models classes with single clear responsibilities and correct relationships. | Models cleanly and separates domain objects from managers or services with reasons. |
| Senior | Models the wrong entities or one class that does everything. | Models correct classes but couples them tightly. | Models cohesive, loosely coupled classes and explains each boundary. | Models cohesive classes with interfaces at the points of change and justifies each. |
| Staff | Models the wrong entities or one class that does everything. | Models a clean design but does not consider how it is extended or owned. | Models cohesive classes with clear boundaries that other teams could extend safely. | Models boundaries that match ownership and explains how they limit future coupling. |
Design principles and patterns (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Shows no use of basic object-oriented ideas such as encapsulation. | Uses classes but exposes all fields and duplicates logic. | Uses encapsulation and inheritance correctly in at least one place. | Uses encapsulation and an interface correctly and explains why. |
| Junior | Puts unrelated responsibilities in one class and exposes internal state everywhere. | Names patterns or principles but applies them wrongly. | Applies encapsulation and polymorphism correctly and avoids obvious duplication. | Applies one fitting pattern, such as strategy, and explains the problem it solves. |
| Mid-level | Builds god classes and deep inheritance chains that break basic object-oriented principles. | Uses patterns for their own sake or misses an obvious fit. | Applies SOLID principles and fitting patterns with no pattern-stuffing. | Explains why a pattern fits here and what simpler option they rejected. |
| Senior | Ignores encapsulation and single responsibility, and cannot justify any structure when challenged. | Applies patterns correctly but cannot justify them against simpler options. | Chooses patterns only where change is expected and justifies each against a simpler option. | Removes or avoids patterns that add cost without benefit, with clear reasons. |
| Staff | Produces tightly coupled classes and cannot explain any principle behind the structure chosen. | Applies patterns by the book without weighing cost. | Balances principles against simplicity and explains the cost of each abstraction. | Sets clear design conventions others could follow and explains the trade-offs. |
Extensibility and change handling (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot adapt the design when a new requirement is added. | Adapts only by rewriting large parts with heavy help. | Adds a new requirement by changing a few classes, with some help. | Adds a new requirement cleanly by adding a class rather than editing many. |
| Junior | Cannot adapt the design when a new requirement is added. | Adapts only by rewriting large parts of the design. | Handles a new requirement with small, local changes. | Handles a new requirement by extension and explains why the design allowed it. |
| Mid-level | Cannot adapt the design when a new requirement is added. | Handles a new requirement with changes spread across many classes. | Handles a mid-interview change by extension, touching few existing classes. | Anticipated the change in the original design and absorbs it with no edits to old classes. |
| Senior | Cannot adapt the design when a new requirement is added. | Handles the change but only after the interviewer suggests the approach. | Absorbs the change by extension and names other changes the design supports. | Anticipates likely changes unprompted and shows the design absorbing two of them. |
| Staff | Cannot adapt the design when a new requirement is added. | Absorbs the change but does not consider backward compatibility. | Absorbs changes cleanly and covers backward compatibility and migration. | Explains how the design evolves over versions and how callers migrate safely. |
Code or skeleton quality (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Writes no usable code or method signatures. | Writes method signatures that do not match the classes described. | Writes class skeletons with fields and key methods, mostly consistent. | Writes clean skeletons and implements one core method correctly. |
| Junior | Writes no usable code or method signatures. | Writes skeletons with inconsistent signatures or missing methods. | Writes consistent skeletons and implements the core flow mostly correctly. | Writes clean interfaces and a correct core flow with sensible names. |
| Mid-level | Writes no usable code or method signatures. | Writes code that needs interviewer help to be consistent with the design. | Writes clean interfaces and a correct core flow; mentions thread safety where relevant. | Writes clean code and handles concurrency correctly where shared state exists. |
| Senior | Writes no usable code or method signatures. | Writes working code but ignores concurrency in shared state. | Writes clean, consistent code and handles concurrency and errors unprompted. | Writes review-ready code with clear error handling and correct locking or immutability. |
| Staff | Writes no usable code or method signatures. | Writes working code but ignores concurrency or error handling. | Writes clean code with sound concurrency and error handling, and explains testability. | Writes production-quality code and explains how to test and evolve it safely. |
Communication (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Stays silent or cannot explain the classes when asked. | Explains only when asked and loses track of the design. | Explains each class and its role when guided by the interviewer. | Explains the design in a clear order and checks in with the interviewer. |
| Junior | Stays silent or explains the design incoherently. | Explains the classes and their roles only when the interviewer asks. | Explains the design and the reasons for key choices. | Explains clearly and walks through a use case across the classes unprompted. |
| Mid-level | Stays silent or explains the design incoherently. | Explains choices only when the interviewer asks why. | Thinks aloud, explains each choice and walks a use case through the design. | Drives the session, manages time and adapts quickly to change requests. |
| Senior | Stays silent or explains the design incoherently. | Explains clearly but needs the interviewer to steer pacing. | Drives the session, manages time and explains trade-offs as they arise. | Drives crisply, handles pushback with reasons and summarises the design at the end. |
| Staff | Stays silent or explains the design incoherently. | Explains when asked but does not lead the discussion. | Leads like a design review, framing options and trade-offs concisely. | Leads crisply, invites challenge and tailors depth to the interviewer's concerns. |
Get scored against this rubric
Thita's AI interviewer runs a live low-level design round and scores you against exactly this rubric, dimension by dimension, for the level you choose.
Practise a low-level 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 low-level design interview scored?
- A low-level design interview is scored on 6 dimensions: requirements and use cases (15%), class and entity modelling (25%), design principles and patterns (15%), extensibility and change handling (15%), code or skeleton quality (15%), communication (15%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on class and entity modelling means: "Models cleanly and separates domain objects from managers or services with reasons."
- What is the difference between a mid-level and a senior low-level design answer?
- On class and entity modelling, the heaviest dimension, an outstanding mid-level answer "models cleanly and separates domain objects from managers or services with reasons", while an outstanding senior answer "models cohesive classes with interfaces at the points of change and justifies each". 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.