Back to Basics
Rubric & Approach
Layer 1 — Fundamentals

System Design Rubric & Evaluation Approach

System design interviews evaluate your ability to architect scalable systems. Each dimension is evaluated based on the seniority of the role, resulting in a final score that determines your level.

💡 Analogy

Like grading a university course: quizzes, midterms, and the final project are all scored 0-100, but they carry different weights. We calculate the weighted sum to get your final percentage grade.

🎯 Strategy

Spend 5-10 minutes on requirements and estimation. Allocate 20-25 minutes to high-level architecture, APIs, and data models. Save 15-20 minutes for deep dives and resolving bottlenecks.

A Note on Real-World Interviews: System design interviews are inherently subjective. Your evaluation depends heavily on the individual interviewer's engineering background, their specific team's challenges, and the company culture. While this rubric provides a standardized baseline for preparation, you must always adapt to your interviewer's cues. If they want to skip capacity estimation and dive straight into database internals, follow their lead!

Evaluation Bar by Level

Select your target level to see the score translation. Score yourself out of 100 on each dimension below. Note: Your total score is based on a weighted sum, not a raw average or sum out of 800. Often, it is normalized to 5-point rating scale. Some dimensions are heavily prioritized depending on your seniority level.

Strong No Hire0 - 39Weighted Score
Leaning No40 - 54Weighted Score
Leaning Hire55 - 69Weighted Score
Hire70 - 84Weighted Score
Strong Hire85 - 100Weighted Score
Focus for SWE / SDE I–II:Focuses heavily on functional requirements, basic API design, and logical Data Modeling. Breadth is prioritized over extreme depth—the goal is to prove you can connect the standard building blocks (API, DB, Cache) to create a working system. Identifying and resolving complex bottlenecks is considered a bonus, not a strict requirement.

Step 1: Requirement Clarification

Understand the problem and establish the design scope.

100
Max Points

Cheat Sheet Focus Areas

  • Establish the scope: understand why we need to build the system and who the users are
  • List the unique, important functional features the system must support
  • Explicitly define what is out of scope to constrain the problem

Step 2: Design Considerations (NFRs)

Define the specific system qualities and characteristics.

100
Max Points

Cheat Sheet Focus Areas

  • Discuss Availability vs Consistency trade-offs (CAP theorem)
  • Define specific needs: Latency, Scalability, Accuracy, and Concurrency
  • Address data durability and security requirements (e.g., rate limiting, access control)
  • Identify read-heavy vs write-heavy workloads

Step 3: Back-of-the-envelope Estimation

Calculate capacity requirements to find constraints.

100
Max Points

Cheat Sheet Focus Areas

  • Calculate expected QPS, Storage, and Network Bandwidth
  • Use math to back your design and uncover potential scale challenges
  • Explicitly identify if the system will hit a QPS bottleneck or a Storage bottleneck

Step 4: High Level Design

Propose the core architecture and get buy-in.

100
Max Points

Cheat Sheet Focus Areas

  • Propose multiple design options and walk through the end-to-end flow
  • Reach an agreement/get buy-in with the interviewer on the design direction
  • Include core components without overcomplicating initially

Step 5: Data Model Design

Define how data is stored, accessed, and indexed.

100
Max Points

Cheat Sheet Focus Areas

  • Discuss data access patterns and the read-to-write ratio
  • Create a simplified schema listing only the most important fields
  • Justify your database choice (SQL vs NoSQL) and indexing options for query efficiency

Step 6: API Definition

Design the contract between the client and server.

100
Max Points

Cheat Sheet Focus Areas

  • Standardize the agreement between client and server using REST or GraphQL
  • Define input params, response params, and proper HTTP status codes
  • Address concepts like idempotency, pagination, and client vs server timestamps

Step 7: Detailed Design of Key Component

Provide technical depth on critical parts of the system.

100
Max Points

Cheat Sheet Focus Areas

  • Deep dive into scaling: DB sharding, replication, and caching (S3/CDN vs SQL vs NoSQL)
  • Discuss component interactions (sync vs async) and concurrency (Locks vs Optimistic)
  • Address failure scenarios, data consistency across distributed systems, and metrics

Step 8: Identifying and Resolving Bottlenecks

Structure your approach to system optimization.

100
Max Points

Cheat Sheet Focus Areas

  • Follow a structure: Identify bottlenecks → Propose options → Discuss trade-offs → Recommend
  • Justify design decisions (e.g., why a cache or shard is needed) with math and logical reasons
  • Briefly discuss how to handle the next scale curve and potential future improvements

Keys to High Score

  • ✓ Establish clear scope and get interviewer buy-in
  • ✓ Identify QPS vs Storage bottlenecks early with math
  • ✓ Address data access patterns before picking a DB
  • ✓ Deep dive into concurrency, caching, and sharding
  • ✓ Follow the "Identify → Propose → Trade-offs → Recommend" structure

Common Mistakes to Avoid

  • ✗ Adding APIs that don't support the core functional requirements
  • ✗ Ignoring sync vs async interaction complexities
  • ✗ Not discussing eventual vs strong consistency (CAP)
  • ✗ Proposing technologies without justifying them with reasons/math
  • ✗ Forgetting to define error handling, pagination, and idempotency

Recommended 45-Minute Breakdown

1. Scope, Requirements & Estimation (5-10 min)~15%
2. Architecture, Data Model & APIs (20-25 min)~50%
3. Deep Dives & Bottleneck Resolution (15-20 min)~35%