Roblox·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say

Jul 2026

Summary

System design round at Roblox for a software engineer role, focused entirely on designing a Likes system from scratch. The depth they expected was pretty serious, covering everything from schema choices to handling celebrity items under load.

Questions Asked (1)

Design a Likes system that supports liking/unliking items, checking if a user has liked something, listing a user's liked items with pagination, and fetching total like counts per item. Focus on scalability and data schema.

System DesignData ModelingTechnical Trade-offs

Author's notes

This one sprawled fast.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying functional and non-functional requirements, then propose a scalable data model using a wide-column store like Cassandra for likes and a distributed counter for like counts. Walk through the API design, data partitioning, caching, and trade-offs between consistency and availability, emphasizing how the design handles Roblox-scale traffic.

Pro tip: Explicitly discuss how you would handle hot partitions (e.g., a viral item) using techniques like sharding counters or write-ahead logging, and mention idempotency to prevent duplicate likes. This shows you understand real-world failure modes at scale.

1. Clarify Requirements and Scale

Ask about expected QPS, latency requirements, consistency needs, and whether likes are public or private. Estimate scale (e.g., millions of likes per second) to inform design choices.

2. Design Data Schema and Storage

Propose tables: one for user likes (user_id, item_id, timestamp) and one for item like counts (item_id, count). Choose a distributed database like Cassandra for its scalability and tunable consistency.

3. Define API and Access Patterns

Outline endpoints: POST /like, DELETE /unlike, GET /liked?user_id=&page=, GET /count?item_id=. Ensure each query maps efficiently to the schema (e.g., partition by user_id for listing likes).

4. Address Scalability and Performance

Discuss caching (Redis for counts), sharding counters to avoid hot partitions, and using eventual consistency for counts. Mention asynchronous processing for writes if needed.

5. Discuss Trade-offs and Failure Handling

Compare SQL vs NoSQL, consistency vs availability, and how to handle duplicate likes (idempotency), counter drift, and recovery. Highlight monitoring and backfill strategies.

Key Points to Mention

Data model: user_likes table partitioned by user_id for efficient listing, and item_likes table partitioned by item_id for counting.
Scalability: use of Cassandra or DynamoDB for horizontal scaling, and Redis for caching hot counts.
Hot partition mitigation: shard counters across multiple rows and aggregate on read, or use a write-ahead log for high-velocity items.
Idempotency: ensure like/unlike operations are idempotent using unique constraints or conditional writes.
Consistency trade-offs: eventual consistency for like counts is acceptable, but user's own like status should be strongly consistent.
Pagination: use cursor-based pagination (e.g., timestamp or item_id) instead of offset for large datasets.

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