← Atlassian Interview Insights

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

Senior
Jul 2026

Summary

System design round at Atlassian for a software engineer role, focused entirely on building a trending/top-N posts feature for Confluence. Pretty deep dive, they wanted the full pipeline from event ingestion all the way through to serving.

Questions Asked (1)

Q1

Design a system that surfaces the top-N posts on Confluence based on engagement signals like views, likes, and comments within configurable time windows.

System DesignTechnical Trade-offsData Modeling
Author's notes

This is a meaty one.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: define engagement signals, time windows, and what 'top' means (e.g., weighted score). Then propose a scalable architecture that ingests events, computes scores in near real-time or batch, and serves top-N efficiently, discussing trade-offs between freshness, cost, and complexity.

Pro tip: Emphasize the need for a configurable scoring function and pre-aggregation to avoid recomputing from raw events on every query; mention using a lambda architecture or a streaming pipeline with a serving layer like Redis for low-latency reads.

1. Clarify Requirements and Scope

Ask questions to understand expected scale (number of posts, events per second), latency requirements (real-time vs. hourly), and how engagement signals should be weighted. Define configurable time windows (e.g., last 24 hours, last 7 days).

2. Design Data Model and Ingestion

Model events (view, like, comment) with timestamps and post IDs. Propose an ingestion pipeline using a message queue (e.g., Kafka) to handle high throughput and decouple producers from consumers.

3. Compute Engagement Scores

Design a scoring function (e.g., weighted sum) and compute scores either in batch (e.g., Spark) for historical windows or in stream (e.g., Flink) for real-time updates. Use pre-aggregation to reduce computation.

4. Store and Serve Top-N

Store computed scores in a fast lookup store (e.g., Redis sorted sets) and maintain top-N per time window. Serve queries with low latency, possibly using a cache and periodic refresh.

5. Address Trade-offs and Scalability

Discuss trade-offs: batch vs. stream (freshness vs. cost), exact vs. approximate top-N (e.g., using count-min sketch), and how to handle hot posts and skewed data. Mention partitioning and sharding for scalability.

Key Points to Mention

  • Configurable time windows and scoring weights (e.g., views=1, likes=5, comments=10)
  • Event ingestion with Kafka for durability and scalability
  • Stream processing (Flink) for real-time updates vs. batch (Spark) for cost efficiency
  • Pre-aggregation and materialized views to avoid recomputing from raw events
  • Serving layer with Redis sorted sets for O(log(N)) top-N queries
  • Trade-offs: latency vs. accuracy, cost vs. freshness, and handling of skewed data

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