Interview rubric
How Frontend Coding Interviews Are Scored: Rubric by Level (2026)
A frontend coding interview is scored on 5 dimensions: language and platform fluency (25%), component and API design (20%), correctness and edge cases (20%), performance, UX and accessibility (15%), communication and verification (20%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on language and platform fluency means: "Explains how the runtime handles their code, such as the event loop, unprompted."
The dimensions and their weights
| Dimension | Weight | Solid (3) at mid level |
|---|---|---|
| Language and platform fluency | 25% | Writes idiomatic code and explains closures, async ordering or hooks when asked. |
| Component and API design | 20% | Designs a clean state shape, clear props and separation of concerns. |
| Correctness and edge cases | 20% | Handles empty, loading and error states and one async race unprompted. |
| Communication and verification | 20% | Thinks aloud, explains decisions and tests edge cases unprompted. |
| Performance, UX and accessibility | 15% | Explains causes such as unneeded rerenders and applies fixes when asked. |
What changes between levels
On language and platform fluency, the heaviest dimension, an outstanding mid-level answer "explains how the runtime handles their code, such as the event loop, unprompted", while an outstanding senior answer "explains framework internals, such as reconciliation, and uses them to justify code choices". 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
Language and platform fluency (25%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot write basic syntax in the chosen language without help. | Writes basic syntax but needs help with common library calls. | Uses core syntax and common library or DOM calls, looking up a few details. | Uses core syntax and the standard library fluently, including basic async code. |
| Junior | Cannot write basic syntax in the chosen language without help. | Writes working code but misuses common APIs or async patterns. | Uses the standard library, DOM or framework APIs correctly for common tasks. | Uses idiomatic patterns such as closures and promises correctly and explains them. |
| Mid-level | Cannot write basic syntax in the chosen language without help. | Writes working but non-idiomatic code and misreads async behaviour. | Writes idiomatic code and explains closures, async ordering or hooks when asked. | Explains how the runtime handles their code, such as the event loop, unprompted. |
| Senior | Cannot write basic syntax in the chosen language without help. | Writes idiomatic code but cannot explain runtime behaviour when probed. | Writes idiomatic code and explains runtime behaviour and framework internals when probed. | Explains framework internals, such as reconciliation, and uses them to justify code choices. |
| Staff | Cannot write basic syntax in the chosen language without help. | Writes fluent code but cannot reason about platform limits. | Explains runtime and framework internals and the platform limits they impose. | Relates platform internals to choices a whole codebase should make, with reasons. |
Component and API design (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Puts all logic and markup in one block with no structure. | Splits code into pieces only when the interviewer suggests how. | Splits the UI or code into a few sensible components or functions with help. | Splits code into sensible components and passes data between them cleanly. |
| Junior | Puts all logic and markup in one block with no structure. | Splits components but duplicates state across them. | Splits components sensibly with clear props and a single source of state. | Designs clean props and state, and explains where state should live. |
| Mid-level | Puts all logic and markup in one block with no structure. | Has workable components but tangled state or unclear props. | Designs a clean state shape, clear props and separation of concerns. | Designs a reusable component API and explains how it would be extended. |
| Senior | Puts all logic and markup in one block with no structure. | Designs clean components but cannot justify state placement against alternatives. | Justifies state placement and component API against alternatives for this use. | Designs a component API others could reuse, with clear contracts and defaults. |
| Staff | Puts all logic and markup in one block with no structure. | Designs a clean component but not for reuse across teams. | Designs component APIs for reuse across teams, with versioning in view. | Sets component conventions for a codebase and explains their long-term cost. |
Correctness and edge cases (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Code does not work for the main case. | Main case works only after the interviewer fixes several bugs. | Main case works; handles an empty or error state when asked. | Main case works and handles empty and error states unprompted. |
| Junior | Code does not work for the main case. | Main case works only with major help. | Main case works and empty or error states are handled when prompted. | Handles empty, loading and error states unprompted. |
| Mid-level | Code does not work for the main case. | Main case works but empty, error or loading states are missing. | Handles empty, loading and error states and one async race unprompted. | Handles async races, cancellation and error states, and explains each fix. |
| Senior | Code does not work for the main case. | Handles basic states but misses async races until asked. | Handles async races, cancellation, errors and keyboard access unprompted. | Handles subtle races and accessibility edge cases and catches own bugs before the interviewer. |
| Staff | Code does not work for the main case. | Handles basic states but misses async races until asked. | Handles races, errors and accessibility unprompted and explains failure handling. | Handles all of these and explains how to prevent such bugs across a codebase. |
Performance, UX and accessibility (15%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Cannot answer any question about speed or usability of the code. | Mentions performance or accessibility only in vague terms when asked. | Names one concrete improvement, such as debouncing input or alt text, when asked. | Names a concrete performance and an accessibility improvement when asked, with reasons. |
| Junior | Cannot answer any question about speed or usability of the code. | Gives vague answers on performance or accessibility when asked. | Names concrete fixes such as debouncing or semantic markup when asked. | Raises one performance or accessibility issue unprompted and fixes it. |
| Mid-level | Ignores performance and accessibility even when asked. | Names fixes when asked but cannot explain the cause. | Explains causes such as unneeded rerenders and applies fixes when asked. | Raises rerenders, debouncing or accessibility unprompted and fixes them. |
| Senior | Ignores performance and accessibility even when asked. | Addresses performance or accessibility only when asked. | Raises performance, accessibility and UX issues unprompted and fixes the main ones. | Raises them unprompted, explains how to measure them and prioritises fixes. |
| Staff | Ignores performance and accessibility even when asked. | Addresses performance or accessibility only when asked. | Raises issues unprompted and sets measurable budgets, such as render time. | Sets budgets and checks others could enforce, and explains the user impact. |
Communication and verification (20%)
| Level | 1 · Poor | 2 · Borderline | 3 · Solid | 4 · Outstanding |
|---|---|---|---|---|
| Intern / new grad | Stays silent and never checks the code, even when asked. | Explains and tests only when the interviewer leads. | Thinks aloud when nudged and tests the main case when asked. | Thinks aloud unprompted and tests the main case and one edge case. |
| Junior | Stays silent and never checks the code. | Narrates only when asked and tests only the happy path. | Explains the plan and tests the main flow when asked. | Explains decisions and tests edge cases unprompted. |
| Mid-level | Stays silent and never checks the code. | Explains when asked; tests only the happy path. | Thinks aloud, explains decisions and tests edge cases unprompted. | Drives the session and names the unit tests they would write. |
| Senior | Stays silent and never checks the code. | Explains clearly but raises testing only when asked. | Drives the session and raises a testing approach unprompted, such as component tests. | Drives the session, names a testing strategy and catches bugs through it. |
| Staff | Stays silent and never checks the code. | Explains clearly but raises testing only when asked. | Leads the session and explains testing at unit, integration and end-to-end level. | Leads crisply and explains how testing would be enforced across the codebase. |
Get scored against this rubric
Thita's AI interviewer runs a live frontend coding round and scores you against exactly this rubric, dimension by dimension, for the level you choose.
Practise a frontend 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 frontend coding interview scored?
- A frontend coding interview is scored on 5 dimensions: language and platform fluency (25%), component and API design (20%), correctness and edge cases (20%), performance, UX and accessibility (15%), communication and verification (20%). Each is rated 1 to 4 against anchors that rise with the level. At mid level, an outstanding score on language and platform fluency means: "Explains how the runtime handles their code, such as the event loop, unprompted."
- What is the difference between a mid-level and a senior frontend coding answer?
- On language and platform fluency, the heaviest dimension, an outstanding mid-level answer "explains how the runtime handles their code, such as the event loop, unprompted", while an outstanding senior answer "explains framework internals, such as reconciliation, and uses them to justify code choices". 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.