serve robotics·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

May 2026Remote

Summary

Serve Robotics coding round focused entirely on concurrency. One meaty design problem that took up the whole session, and they really wanted to see you think through thread safety rather than just produce working code.

Questions Asked (1)

Design and implement a thread-safe cache with add(key, value, ttl) support and a background scheduler that evicts expired entries every 5 seconds. The design must handle concurrent adds and evictions safely, and you should provide test cases.

System DesignTechnical Trade-offsAlgorithms & Data Structures

Author's notes

This one took me a while to get my footing.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then propose a design using a thread-safe data structure like ConcurrentHashMap with per-entry TTL and a background scheduler (e.g., ScheduledExecutorService). Discuss trade-offs between different locking strategies and eviction policies, and outline test cases for concurrency and expiration.

Pro tip: Mention that you would use a read-write lock or ConcurrentHashMap to minimize contention, and that the scheduler should be resilient to exceptions to avoid silent failures. Also, consider using a delay queue for more efficient eviction.

1. Clarify Requirements and Constraints

Ask about expected load, TTL granularity, memory constraints, and whether eviction should be precise or approximate. Confirm if the cache needs to support other operations like get or remove.

2. Design Data Structures and Concurrency Strategy

Propose using ConcurrentHashMap for thread-safe storage, with entries containing value and expiration timestamp. Discuss locking granularity and alternatives like ReadWriteLock or synchronized blocks.

3. Implement Background Eviction Scheduler

Use ScheduledExecutorService to run eviction every 5 seconds. Ensure the eviction task is thread-safe and handles exceptions. Consider using a DelayQueue for more efficient expiration.

4. Discuss Trade-offs and Edge Cases

Compare periodic eviction vs. lazy eviction on access. Address race conditions between add and eviction, and how to handle TTL updates or removal.

5. Outline Test Cases

Include tests for concurrent adds, eviction correctness, TTL expiration, and thread safety. Use tools like JUnit and stress tests with multiple threads.

Key Points to Mention

Use of ConcurrentHashMap for thread-safe operations without global locking.
ScheduledExecutorService for periodic eviction, with proper exception handling.
Trade-offs between periodic eviction and lazy eviction (e.g., memory vs. CPU).
Handling race conditions between add and eviction (e.g., using atomic operations or locks).
Test cases for concurrency (e.g., multiple threads adding and evicting) and TTL accuracy.
Consideration of alternative designs like using a DelayQueue or Guava Cache.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.