### 1. Multi-Dimensional Technical Scoring Rubric | Competency Dimension | Strong No Hire (1) | Lean No Hire (2) | Lean Hire (3) | Strong Hire (4) | | :--- | :--- | :--- | :--- | :--- | | **Problem Solving & Algorithms** | Fails to comprehend sliding window mechanics; relies on brute force without recognizing concurrency limits. | Understands fixed window counter; struggles to adapt logic to a true sliding window log. | Correctly implements sliding window log; identifies timestamp sorting overhead independently. | Effortlessly models sliding window; proactively discusses sliding window counter hybrid optimizations. | | **Code Architecture & Cleanliness** | Monolithic code blocks; global variables; zero modular functions or encapsulation. | Basic functions exist but mix business rules with storage logic; poor variable naming. | Clean modular separation between rate limiter interface and backend storage adapter. | Production-grade design patterns; clean separation of concerns, dependency injection, and idiomatic idioms. | | **Concurrency & Thread Safety** | Ignores race conditions entirely; writes thread-unsafe mutation logic. | Acknowledges concurrency issues but fails to implement proper mutexes or atomic operations. | Correctly applies mutex locks or atomic counters around critical shared state. | Uses fine-grained locking or lock-free atomics; calculates lock contention impacts at scale. | | **Communication & Collaboration** | Codes in silence; resists clarifying questions; defensive when probed on edge cases. | Communicates when prompted but struggles to articulate trade-offs clearly. | Thinks out loud; verifies constraints upfront; receptive to interviewer steering. | Drives structured technical dialogue; proactively surfaces trade-offs, constraints, and assumptions. | --- ### 2. Live Problem Framing & Progressive Hint Ladder * **Prompt:** Design and implement a thread-safe, in-memory rate limiter that restricts clients to N requests per sliding window duration M (e.g., 100 requests per 60 seconds). * **Constraints:** User ID string identifier, millisecond timestamp precision, memory efficiency priority. * **Tier 1 Hint (Subtle Nudge):** How can tracking individual request timestamps help determine if a client has exceeded their limit over the past M milliseconds? * **Tier 2 Hint (Directional Guide):** Consider maintaining a sorted list or queue of past timestamps per user. How do you evict entries older than the current window? * **Tier 3 Hint (Explicit Scaffolding):** Store timestamps in a deque. On each request, pop all timestamps older than current time minus window duration, then verify if remaining count is less than N before appending. --- ### 3. Edge Case & Complexity Evaluation Guide * **Time Complexity Target:** O(log K) or O(1) amortized per request check, where K is the number of logged timestamps in the window. * **Space Complexity Target:** O(K * U) where U is active concurrent users and K is max allowed requests per window. * **Critical Edge Cases:** Rapid bursts at window boundaries; system clock skew; memory exhaustion under large active user pools; empty queue initializations; duplicate simultaneous timestamps. --- ### 4. Structured Debrief Scorecard & Feedback Template * **Candidate:** [Candidate Name] | **Interviewer:** [Interviewer Name] | **Date:** [Interview Date] * **Role/Level:** Senior Backend Engineer (L5) * **Overall Recommendation:** [Strong Hire / Lean Hire / Lean No Hire / Strong No Hire] * **Competency Scores (1-4):** - Problem Solving: [Score] - Code Architecture: [Score] - Concurrency & Reliability: [Score] - Technical Communication: [Score] * **Observable Strengths:** [List 2-3 concrete code implementation behaviors observed] * **Growth Areas / Gaps:** [List 1-2 areas where the candidate required substantial prompting] * **Level Calibration:** [Confirms candidate operates at L5 autonomous complexity vs. L4 execution]