← Atlassian Interview Insights

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

SeniorPrefer not to say
May 2026

Summary

Atlassian system design round for a software engineer role. The main problem was building a content popularity tracker with increment, decrement, and max-lookup operations. Pretty meaty discussion about data structures and distributed scaling.

Questions Asked (1)

Q1

Design a system that tracks content popularity on a social media platform, supporting increment, decrement, and a most-popular lookup. Walk through your choice of data structures, time complexity trade-offs, and how you'd scale this across multiple servers.

System DesignAlgorithms & Data StructuresTechnical Trade-offs
Author's notes

My first instinct was a hash map plus a max-heap and I just went with it before thinking through the decrement case.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (e.g., real-time vs. eventual consistency, scale, read/write ratio) and then propose a data structure like a hash map for counts plus a heap or balanced BST for most-popular. Discuss trade-offs (time/space complexity, concurrency) and then scale horizontally using sharding and aggregation.

Pro tip: Mention that exact real-time most-popular is hard at scale; propose approximate solutions (e.g., count-min sketch) or windowed popularity to balance accuracy and performance.

1. Clarify Requirements

Ask about expected scale, read/write patterns, consistency needs, and whether popularity is global or per-region/time window.

2. Single-Server Design

Propose a hash map for counts and a max-heap or balanced BST for most-popular; analyze time complexity for increment, decrement, and lookup.

3. Optimize and Trade-offs

Discuss alternatives like sorted sets (Redis), skip lists, or approximate structures; compare update vs. lookup costs and memory.

4. Scale Across Servers

Shard by content ID, use a distributed cache, and aggregate results; consider eventual consistency and fault tolerance.

5. Address Edge Cases

Handle decrement to zero, hot keys, concurrency, and failure recovery; mention monitoring and backpressure.

Key Points to Mention

  • Time complexity: O(1) for increment/decrement with hash map, O(log n) or O(1) for most-popular with heap or sorted set.
  • Space complexity: O(n) for counts, plus overhead for auxiliary structures.
  • Concurrency: use locks, atomic operations, or CRDTs for distributed counters.
  • Sharding strategies: consistent hashing, range partitioning, and handling hot shards.
  • Approximate algorithms: count-min sketch, lossy counting for scalability.
  • Real-world systems: Redis sorted sets, Apache Kafka for stream processing, and Lambda architecture.

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