← Atlassian Interview InsightsMachine Learning Engineer

Atlassian·Machine Learning Engineer·Technical Phone Screen·Senior

Senior
May 2026

Summary

Atlassian ML Engineer interview that ended up being more of a systems coding round than anything ML-related. The core problem was a calendar-style booking system with some data structure discussion baked in.

Questions Asked (2)

Q1

Design and implement a tennis court reservation system that supports booking a court for a time interval without overlaps, canceling an exact booking, and querying whether a court is occupied at a given time. Walk through your choice of data structure for managing non-overlapping intervals per court and the time complexity of each operation.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs
Author's notes

I went with a sorted structure per court and explained the overlap check logic first before writing any code.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and assumptions, then propose a balanced BST (or sorted list) per court to store non-overlapping intervals, explaining how each operation leverages the ordering. Walk through insertion, deletion, and query with time complexities, and discuss trade-offs versus alternatives like interval trees or hash maps with bucketing.

Pro tip: Emphasize that the core challenge is maintaining non-overlapping intervals efficiently; mention that using a balanced BST (e.g., TreeMap in Java) gives O(log n) operations, and proactively discuss handling edge cases like adjacent bookings and concurrent access.

1. Clarify requirements and assumptions

Ask about expected scale, concurrency, and whether intervals are inclusive/exclusive; state assumptions like single-threaded or need for locking.

2. Choose data structure per court

Propose a balanced BST (e.g., red-black tree) or sorted list keyed by start time to store non-overlapping intervals, enabling efficient search and updates.

3. Define operations and algorithms

For booking: find predecessor/successor to check overlap, then insert. For cancel: find exact interval and remove. For query: find interval containing time via floor lookup.

4. Analyze time complexity

State that each operation is O(log n) for BST (or O(n) for sorted list insertion/deletion), and discuss space O(n) per court.

5. Discuss trade-offs and extensions

Compare with interval trees, hash maps with time buckets, or database-backed solutions; mention concurrency handling and scalability.

Key Points to Mention

  • Use of balanced BST (e.g., TreeMap) for O(log n) operations
  • Overlap check via predecessor/successor search
  • Handling of adjacent intervals (end == start is not overlap)
  • Time complexity: O(log n) for booking, cancel, query
  • Space complexity: O(n) per court
  • Concurrency considerations (locking or optimistic concurrency)

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 system to support rescheduling a booking and finding the next available slot of a given duration on a specific court?

Algorithms & Data StructuresTechnical Trade-offs
Author's notes

The follow-up caught me a little flat-footed.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the data model and constraints (e.g., court schedules, booking durations, time granularity). Then propose a two-part solution: a rescheduling operation that atomically updates the booking and a slot-finding algorithm that efficiently queries available intervals, discussing trade-offs between precomputation and on-the-fly search.

Pro tip: Emphasize idempotency and concurrency control in rescheduling—real systems must handle simultaneous requests without double-booking. Also, mention that the slot-finding algorithm can be optimized with interval trees or segment trees, but start with a simple approach and iterate based on scale.

1. Clarify requirements and constraints

Ask about booking duration flexibility, time granularity (e.g., 30-min slots), court operating hours, and whether rescheduling must preserve the original duration or allow changes.

2. Design data model and operations

Propose a schema for bookings (court_id, start_time, end_time, user_id) and describe the reschedule operation as a transaction that checks availability and updates the booking atomically.

3. Develop slot-finding algorithm

Outline an algorithm to find the next available slot of a given duration: retrieve existing bookings for the court, merge overlapping intervals, and scan for gaps that fit the duration, returning the earliest.

4. Discuss scalability and trade-offs

Compare approaches: naive O(n log n) sorting per query vs. maintaining a balanced interval tree or segment tree for O(log n) queries. Mention caching or precomputed free slots for high-traffic courts.

5. Address concurrency and edge cases

Explain how to handle concurrent reschedule requests (e.g., optimistic locking, database transactions) and edge cases like no available slot, overlapping bookings, and time zone handling.

Key Points to Mention

  • Interval merging and gap scanning for slot finding
  • Use of interval trees or segment trees for efficient queries
  • Atomicity and concurrency control (e.g., transactions, locks)
  • Trade-offs between precomputation and on-demand computation
  • Handling of time zones and daylight saving
  • Idempotency of reschedule operations

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