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

Senior

May 2026

Summary

System design round at Atlassian for a software engineer role. The problem was building a top-N posts feature for a workspace, which sounds straightforward until you actually try to scope it properly.

Questions Asked (1)

Design a system that returns the top-N posts in a workspace, ranked by engagement, supporting time windows like the last 24 hours, 7 days, and 30 days, with low read latency and high write throughput.

System DesignTechnical Trade-offsData Modeling

Author's notes

The first thing that tripped me up was defining 'top'.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: define engagement, read/write patterns, and scale. Then propose a hybrid architecture using a write-optimized ingestion pipeline (e.g., Kafka) and a read-optimized serving layer (e.g., Redis sorted sets or a precomputed materialized view) with time-windowed aggregations. Discuss trade-offs between precomputation and on-the-fly computation, and how to handle late data and consistency.

Pro tip: Emphasize the importance of precomputing top-N lists for each time window and workspace, and using a cache with TTL to serve reads with low latency. Also mention the need for a fallback mechanism to handle cache misses gracefully.

1. Clarify Requirements and Scale

Ask about the definition of engagement (likes, comments, shares?), expected read/write QPS, number of workspaces, and latency SLA. This ensures the design meets actual needs.

2. High-Level Architecture

Propose a pipeline: ingestion via message queue (Kafka) to handle high write throughput, stream processing (Flink/Spark Streaming) to compute engagement scores and update aggregates, and a serving layer (Redis or DynamoDB) for low-latency reads.

3. Data Modeling and Storage

Design data models: for each workspace and time window, maintain a sorted set of post IDs with scores. Use Redis Sorted Sets for real-time ranking, and periodically persist to a durable store (e.g., Cassandra) for recovery.

4. Handling Time Windows and Updates

Explain how to maintain sliding windows: use bucketed time intervals (e.g., hourly) and combine buckets to answer queries for 24h, 7d, 30d. Discuss strategies for late data and out-of-order events.

5. Trade-offs and Optimizations

Discuss trade-offs: precomputation vs. on-the-fly, consistency vs. latency, and cost. Mention optimizations like caching, sharding by workspace, and using approximate algorithms (e.g., Count-Min Sketch) if exactness is not critical.

Key Points to Mention

Use of Redis Sorted Sets for efficient top-N queries with O(log(N)) updates and O(log(N)+M) range queries.
Stream processing with windowing (tumbling/sliding) to aggregate engagement metrics in real-time.
Sharding by workspace to distribute load and ensure scalability.
Caching strategies: cache top-N results per workspace and time window with TTL, and invalidate on updates.
Handling late data: use watermarks and allowed lateness in stream processing, or lambda architecture with batch corrections.
Trade-offs: precomputation reduces read latency but increases write complexity and storage; on-the-fly computation is simpler but may not meet latency SLA.

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