← Atlassian Interview InsightsSoftware Engineer

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

SeniorPrefer not to say
Jun 2026

Summary

Atlassian system design round that went deep into graph theory pretty fast. The problem started as a classic LCA question but then they kept piling on mutations and concurrency until it was a full distributed systems conversation. Walked away feeling like I'd held my own on maybe 70% of it.

Questions Asked (4)

Q1

Given an organization modeled as a DAG where employees can belong to multiple orgs and orgs can have multiple parent orgs, design a system to find the 'lowest common organization' of two employees.

Algorithms & Data StructuresSystem DesignData Modeling
Author's notes

I jumped straight to the tree-based LCA solution and the interviewer let me finish before pointing out this is a DAG, not a tree.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the problem constraints and assumptions, then model the organization as a DAG and reduce the problem to finding the lowest common ancestor (LCA) in a DAG. Discuss algorithms for LCA in DAGs, considering multiple parents and multiple memberships, and analyze time/space complexity.

Pro tip: Mention that the 'lowest' common org should be defined as the common org with no common descendant orgs, and discuss how to handle cycles or multiple valid lowest common orgs if they exist.

1. Clarify Requirements and Assumptions

Ask clarifying questions about the DAG structure, such as whether it's a tree or a general DAG, if there are cycles, and how to handle multiple lowest common orgs. Confirm that employees can belong to multiple orgs and orgs can have multiple parents.

2. Model the Problem

Represent the organization as a directed acyclic graph where nodes are orgs and edges point from child to parent (or vice versa). Model employee memberships as sets of orgs. Define the lowest common org as a common ancestor org that has no common descendant orgs.

3. Choose an Algorithm

For a DAG, compute the set of all ancestors for each employee's orgs, then find the intersection. Among the intersection, identify those with no descendants in the intersection. Alternatively, use topological sorting and dynamic programming to compute LCA efficiently.

4. Analyze Complexity and Optimize

Discuss time and space complexity. For example, precomputing ancestor sets for all nodes takes O(V*(V+E)) time and space, which may be acceptable for moderate graphs. Consider optimizations like bitsets or memoization for repeated queries.

5. Handle Edge Cases and Extensions

Address cases where employees share no common org, or where multiple lowest common orgs exist. Discuss how to extend the solution to support dynamic updates or large-scale graphs.

Key Points to Mention

  • Definition of lowest common org: a common ancestor with no common descendant orgs.
  • Reduction to LCA in a DAG, noting differences from tree LCA.
  • Algorithm: compute ancestor sets via DFS/BFS or topological sort, then intersect and filter.
  • Time and space complexity: O(V+E) per query with precomputation, or O(V*(V+E)) for all-pairs.
  • Handling multiple parents and multiple memberships: union of ancestors for each employee.
  • Edge cases: no common org, multiple lowest common orgs, cycles (if not strictly a DAG).

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

Q2

How would you extend the LCO system to support live mutations like adding or removing employees, re-parenting orgs, and changing org memberships while still answering queries efficiently?

Algorithms & Data StructuresTechnical Trade-offsSystem Design
Author's notes

This is where it got interesting and also where I started to sweat.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the current LCO system's data model and query patterns, then propose a hybrid approach that combines a mutable graph representation with efficient indexing or caching for read-heavy queries. Discuss trade-offs between consistency, latency, and complexity, and suggest incremental updates with lazy propagation or versioning to balance mutation and query performance.

Pro tip: Emphasize that in real systems, mutations are often less frequent than queries, so optimizing for reads with asynchronous or batched writes is usually acceptable—but always confirm the consistency requirements with the interviewer.

1. Clarify requirements and constraints

Ask about the expected frequency of mutations vs. queries, consistency needs (strong vs. eventual), and scale (number of employees, orgs, memberships). This shapes the entire design.

2. Choose a data model and storage

Propose a graph-based model (e.g., adjacency lists) for orgs and memberships, with indexes on frequently queried fields. Consider using a database that supports efficient updates and traversals, like a graph DB or a relational DB with materialized views.

3. Design mutation handling

For add/remove/re-parent, update the graph and indexes transactionally or with eventual consistency. Use techniques like versioning, tombstones, or change data capture to propagate updates without blocking reads.

4. Optimize query performance

Leverage caching (e.g., Redis) for hot queries, precompute common aggregations, and use read replicas. For complex queries, consider maintaining denormalized views updated asynchronously.

5. Discuss trade-offs and alternatives

Compare approaches: e.g., immediate vs. batched updates, strong vs. eventual consistency, and the impact on latency and complexity. Mention how you'd monitor and adapt based on metrics.

Key Points to Mention

  • Graph data structures (adjacency lists, edge lists) for representing orgs and memberships
  • Indexing strategies (B-trees, hash indexes) for fast lookups on employee IDs, org IDs, etc.
  • Caching layers (in-memory, distributed) and cache invalidation strategies
  • Consistency models: strong vs. eventual, and how to handle read-after-write
  • Batch processing or asynchronous updates to avoid blocking queries
  • Versioning or timestamping to handle concurrent mutations and queries

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

Q3

What are the consistency guarantees your system provides between writes and LCO reads, and how do you handle concurrent mutations?

System DesignTechnical Trade-offs
Author's notes

Didn't see this coming as a follow-up.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying what LCO reads are and the system context, then explicitly state the consistency model (e.g., eventual, strong, read-your-writes) and justify it with trade-offs. Explain how concurrent mutations are handled (e.g., optimistic locking, versioning, conflict resolution) and tie it back to the consistency guarantees.

Pro tip: Acknowledge that consistency is a spectrum and that the right choice depends on business requirements; mention how you measure and monitor consistency violations in production to build trust.

1. Clarify LCO and system context

Define what LCO reads are (e.g., reads from a local cache or replica) and briefly describe the system architecture to set the stage.

2. State consistency guarantees

Explicitly list the guarantees provided (e.g., read-your-writes, monotonic reads, eventual consistency) and explain why they were chosen based on requirements.

3. Explain concurrent mutation handling

Describe the mechanisms used to handle concurrent writes (e.g., optimistic concurrency control, version vectors, CRDTs) and how they interact with LCO reads.

4. Discuss trade-offs and failure modes

Highlight the trade-offs made (e.g., latency vs. consistency) and how the system behaves under failures or network partitions.

5. Summarize with real-world impact

Conclude by explaining how these choices affect users and business, and mention any monitoring or testing for consistency.

Key Points to Mention

  • Definition of LCO reads and why they matter (e.g., performance, scalability)
  • Consistency models: strong, eventual, read-your-writes, monotonic reads
  • Concurrency control: optimistic vs. pessimistic locking, versioning, timestamps
  • Conflict resolution strategies: last-write-wins, merge, CRDTs
  • Trade-offs: latency, availability, complexity, cost
  • Monitoring and testing for consistency violations (e.g., consistency checks, metrics)

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

Q4

Given your expected query-to-update ratio, which data structure or architectural approach wins, and why?

Technical Trade-offsSystem Design
Author's notes

Basically a forced trade-off question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the expected read/write ratio and other constraints (consistency, latency, scale). Then compare candidate data structures or architectures (e.g., B-tree vs LSM-tree, SQL vs NoSQL) based on that ratio, and justify your choice with trade-offs. Conclude with a recommendation and mention how you'd validate it.

Pro tip: Acknowledge that real-world systems often use hybrid approaches (e.g., LSM-trees with Bloom filters) and that the 'winner' depends on the specific workload—showing you avoid dogmatic answers.

1. Clarify requirements

Ask about the expected query-to-update ratio, data size, latency and consistency requirements, and access patterns. This ensures your answer is tailored to the scenario.

2. Identify candidate structures

List plausible data structures or architectures (e.g., B+ trees, LSM-trees, hash indexes, inverted indexes, SQL vs NoSQL) that could fit the workload.

3. Analyze trade-offs

Compare candidates on read/write performance, space amplification, write amplification, complexity, and consistency. Use the query-to-update ratio to weigh which matters most.

4. Select and justify

Choose the best option for the given ratio and explain why, referencing the trade-offs. Acknowledge any assumptions or edge cases.

5. Discuss validation and evolution

Mention how you would benchmark or monitor the system to confirm the choice, and how the design could evolve if the ratio changes.

Key Points to Mention

  • Read-heavy workloads often favor B-trees or read-optimized stores due to efficient point and range queries.
  • Write-heavy workloads often favor LSM-trees or write-optimized stores due to sequential writes and lower write amplification.
  • Consider hybrid approaches like combining an LSM-tree with a cache or using a B-tree with write-ahead logging.
  • Discuss the impact of the ratio on indexing strategies (e.g., more indexes speed reads but slow writes).
  • Mention real-world systems (e.g., PostgreSQL uses B-trees, Cassandra uses LSM-trees) to ground your answer.
  • Highlight that the 'winner' depends on the specific ratio and other constraints, not a one-size-fits-all answer.

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