Atlassian logo

Atlassian Software Engineer Interview Questions

27 practice questions for Atlassian Software Engineer interviews

Atlassian software engineer interviews cover algorithms, data structures, system design, and coding problems drawn from real interview rounds.

Software Engineer Backend Engineer Frontend Engineer Full Stack Engineer Mobile Engineer Data Engineer Data Scientist ML Engineer DevOps Engineer DevOps Engineer Product Manager SRE Security Engineer Engineering Manager Data Analyst UX/UI Designer QA Engineer
coding Medium Verified Question #1

1. Door Swipes


Category: Interval-based coding problem

Question Given a list of people who enter and exit, find the people who entered without their badge and who exited without their badge. This...

Input: List
Output: Array
Want to practise this one?
Create a free account to open the full question and practise Atlassian questions with AI.
Sign up free
coding Medium Verified Question #2

2. Agent Vote


Category: String coding problem

Question Design a Customer Support Ticket System that allows customers to rate support agents on a scale of 1 to 5. You need to implement...

Input: List
Output: Array
coding Medium Verified Question #3

3. Middleware Router


Category: String coding problem

Question We want to implement a middleware router for our web service, which based on the path returns different strings. This problem is split...

Input: String
Output: Computed result
coding Hard Verified Question #4

4. Tennis Court Bookings


Category: Algorithm coding problem

Question The input is a list of tennis court bookings, where each booking includes a start and end time. You need to write a program that assigns...

Input: List
Output: Integer
coding Easy Verified Question #5

5. Word Wrap


Category: String coding problem

Question Implement a function that formats a list of words into lines, separating them with hyphens, while ensuring no line exceeds a maximum...

Input: Array of strings
Output: Computed result
coding Medium Verified Question #6

6. Design Rate Limiter


Category: Sliding window coding problem

Design Rate Limiter Design a rate limiter system that controls the number of requests allowed within a specified time window. The rate limiter is...

Input: String
Output: Computed result
coding Medium Verified Question #7

7. Running Commodity Price


Category: Trie-based coding problem
You are given a stream of data points consisting of <timestamp, commodityPrice>. You need to design a data structure that supports upserting...
Input: Given input
Output: Integer
coding Medium Verified Question #8

8. Shuttle Route Pickup


Category: Graph coding problem

Question Two shuttle buses travel different road networks to reach a festival campsite, picking up passengers at stops along the way. Each bus...

Input: Graph (nodes and edges)
Output: Computed result
coding Medium Verified Question #9

9. Storage Hierarchy Stats


Category: Trie-based coding problem

Question Design a StorageHierarchyStats class that manages documents organized into labeled buckets. Buckets can have parent-child relationships...

Input: List
Output: Computed result
coding Medium Verified Question #10

10. Path Router


Category: Algorithm coding problem

Question Design a PathRouter class that maps URL-like path patterns to handler names. Patterns may contain wildcard segments (*) that match any...

Input: Number(s)
Output: Computed result
coding Easy Verified Question #11

11. Snowpack Trail


Category: Array coding problem

Question You are planning a hiking trip along a trail represented as an elevation array. Snow accumulates or melts on the trail each day according...

Input: Array
Output: Computed result
coding Medium Verified Question #12

12. Rocket Launch Board


Category: Algorithm coding problem

Question You are building a simulator for a board game called Rocket Launch. The board has numbered squares from 1 to boardSize. On each...

Input: Number(s)
Output: Computed result
coding Easy Verified Question #13

13. Anagram Substring Search


Category: String coding problem

Question You are given a list of keywords and a text string t. Return the first keyword from the list such that any anagram of that keyword...

Input: List
Output: Computed result
coding Medium Verified Question #14

14. Worm Game


Category: Grid/matrix coding problem

Question Design a WormGame class that simulates a worm moving on a 2D grid. The worm starts at the top-left corner (0, 0) with length 1. It...

Input: 2D grid
Output: Computed result
coding Medium Verified Question #15

15. Jump Board


Category: Array coding problem

Question You are given a 1D board represented as an array of instruction strings. You start at index 0. On each step, you follow the instruction at...

Input: Array
Output: Computed result
coding Medium Verified Question #16

16. Plan Billing


Category: Algorithm coding problem

Question Design a PlanBilling class that tracks subscription charges on a daily basis and provides monthly and annual billing summaries....

Input: Given input
Output: Computed result
coding Medium Verified Question #17

17. Racing Lap Stats


Category: Algorithm coding problem

Question You are analyzing race lap data for a set of drivers. Each driver has a list of lap times and a set of laps flagged as pit-stop laps...

Input: List
Output: Computed result
coding Easy Verified Question #18

18. Warehouse Trip Saver


Category: Algorithm coding problem

Question A warehouse is organized into sections. Each product belongs to exactly one section. An employee has a pick list of products to collect....

Input: List
Output: Integer
coding Hard linked list #1

1. [Hash Map and Linked List] — Track the most popular Confluence page with recency-based ties


Background
Confluence surfaces popular pages to help teams discover useful documentation. Atlassian interview reports describe a content-popularity tracker with increment, decrement, and maximum queries, followed by recency-based tie handling; this problem adapts that reported pattern to page IDs.
Problem statement
Implement PopularityTracker, an in-memory tracker of positive integer popularity scores for Confluence pages. Initially, no pages are tracked.
Calling increasePopularity(pageId) increases the page's score by one, creating it with score one if necessary. Calling decreasePopularity(pageId) decreases an existing page's score by one; a page whose score reaches zero is removed. Decreasing an untracked page is a no-op.
Calling mostPopular() returns the ID of the tracked page with the highest score, or null if none exists. If several pages have the highest score, return the page whose most recent score-changing operation occurred latest. Both increases and decreases count as score-changing operations, including operations that move a page into a tie. Calls execute sequentially, so operation order defines recency without timestamps. Queries and no-op decreases do not change recency. A removed page can later be created again.
All three operations must run in expected O(1) time, using O(n) space, where n is the number of currently tracked pages. Do not retain historical records for removed pages or empty score groups.
Function or class signature
  • PopularityTracker() — construct an empty tracker.

  • increasePopularity(pageId: str) -> None

  • decreasePopularity(pageId: str) -> None

  • mostPopular() -> str | None


Example 1:
Input:
{
  "operations": [
    ["increasePopularity", "ENG-101"],
    ["increasePopularity", "ENG-202"],
    ["mostPopular"],
    ["increasePopularity", "ENG-101"],
    ["mostPopular"],
    ["increasePopularity", "ENG-202"],
    ["mostPopular"],
    ["decreasePopularity", "ENG-202"],
    ["mostPopular"]
  ]
}
Output, containing results only for mostPopular calls:
["ENG-202", "ENG-101", "ENG-202", "ENG-101"]
Explanation: The first query sees both scores at one, and ENG-202 was updated later. Next, ENG-101 alone has score two. Increasing ENG-202 creates a tie at two that it wins by recency. Decreasing it to one leaves ENG-101 as the unique maximum.
Example 2:
Input:
{
  "operations": [
    ["mostPopular"],
    ["decreasePopularity", "UNKNOWN"],
    ["increasePopularity", "RUNBOOK"],
    ["increasePopularity", "RUNBOOK"],
    ["increasePopularity", "HANDBOOK"],
    ["decreasePopularity", "RUNBOOK"],
    ["mostPopular"],
    ["decreasePopularity", "RUNBOOK"],
    ["mostPopular"],
    ["decreasePopularity", "HANDBOOK"],
    ["mostPopular"],
    ["increasePopularity", "RUNBOOK"],
    ["mostPopular"]
  ]
}
Output:
[null, "RUNBOOK", "HANDBOOK", null, "RUNBOOK"]
Explanation: The tracker starts empty, and decreasing UNKNOWN changes nothing. Decreasing RUNBOOK from two to one makes it the most recently updated page in the tie with HANDBOOK. Removing RUNBOOK leaves HANDBOOK; removing HANDBOOK empties the tracker. Creating RUNBOOK again gives it score one.
Constraints:
  • At most 200000 method calls are made.

  • pageId is a case-sensitive string of 1 to 64 ASCII letters, digits, hyphens, or underscores.

  • Scores are integers between 1 and 200000 for tracked pages.

  • Calls are single-threaded and arrive in their execution order.

  • Expected O(1) time assumes constant-time hashing of these bounded-length IDs.


Follow-up: Extend the API with topK(k: int) -> list[str], ordered by descending score and then descending update recency. Can you return the result in O(min(k, n)) time without changing the expected O(1) update bounds?
Want to practise this one?
Create a free account to open the full question and practise Atlassian questions with AI.
Sign up free
coding Medium dynamic programming #2

2. Dynamic Programming — Longest Common Subsequence

Background: Atlassian products often require collaboration tools that manage user input and changes effectively. Analyzing version changes via common subsequences is crucial for tracking modifications in collaborative documents, such as those in Confluence.
Problem statement: Given two strings, text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0. A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. For example, ace is a subsequence of abcde.
Function/class signature:
  • def longest_common_subsequence(text1: str, text2: str) -> int:


Example 1:
  • Input: text1 = "abcde", text2 = "ace"

  • Output: 3

  • Explanation: The longest common subsequence is "ace", which has a length of 3.


Example 2:
  • Input: text1 = "abc", text2 = "abc"

  • Output: 3

  • Explanation: The longest common subsequence is "abc", which has a length of 3.


Constraints:
  • 1 <= text1.length, text2.length <= 100

  • text1 and text2 consist of English letters only.
coding Medium two pointers #3

3. Two Pointers — Remove Duplicates from Sorted Array

Background: Atlassian develops collaborative software tools which often require efficient data manipulation. Managing unique items in lists can speed up operations in products like Jira and Confluence.
Problem statement: You are given a sorted array of integers nums. Your task is to remove the duplicates in-place such that each element appears only once and returns the new length of the array. Elements beyond the returned length will be ignored. The relative order of the elements should be kept the same.
Function/class signature:
  • def remove_duplicates(nums: List[int]) -> int:


Example 1:
Input: nums = [1, 1, 2]
Output: 2
Explanation: The nums array will be modified to [1, 2] and the new length is 2.
Example 2:
Input: nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
Output: 5
Explanation: The nums array will be modified to [0, 1, 2, 3, 4] and the new length is 5.
Constraints:
  • 0 <= nums.length <= 3 * 10^4

  • -100 <= nums[i] <= 100

  • nums is sorted in ascending order.
coding Medium game logic #4

4. Coding — Design a simple snake game

Background: Atlassian is known for its collaborative software tools, and creating interactive prototypes can be essential in their product design process. A snake game serves as a foundational exercise in understanding game logic and user interface dynamics.
Problem statement: Build a simple snake game where the player controls a snake that moves around a grid, eats food to grow, and dies if it runs into itself or the boundaries of the grid. The game should include methods to initialize the game, generate food, move the snake, and check game-over conditions.
Function/class signature:
  • def __init__(self, width: int, height: int): Initializes the game with a specified grid size.

  • def generate_food(self) -> Tuple[int, int]: Generates a food item at a random position on the grid.

  • def move_snake(self, direction: str) -> bool: Moves the snake in the given direction and returns whether the game is still running.

  • def game_over(self) -> bool: Checks if the snake has collided with the wall or itself.

Example 1:
Input: Game(width=10, height=10).generate_food()
Output: (3, 5)
Explanation: Food appears at position (3, 5) on the grid.
Example 2:
Input:
game = Game(10, 10)
game.move_snake('right')
Output: True
Explanation: The snake successfully moved right without hitting walls or itself.
Constraints:
  • Width and height of the grid should be between 5 and 20.

  • The snake can only move in four directions: 'up', 'down', 'left', 'right'.

  • The snake's initial length is 1, and it can grow indefinitely on consuming food.

coding Medium hash map #5

5. Data Structures — Implement a basic task management system

Background: Atlassian is known for its project management tools like Jira. A robust task management system is essential for organizing tasks effectively within teams and improving productivity.
Problem statement: You need to design a task management system that allows you to add, retrieve, and delete tasks. Each task has a unique id, a description, and a status (which can be Pending, In Progress, or Completed). Implement the following functions:
  • add_task(id: int, description: str) -> None: Adds a new task with the given id and description.

  • get_task(id: int) -> Tuple[str, str]: Retrieves the task's description and status by id. Returns None if the task does not exist.

  • delete_task(id: int) -> bool: Deletes the task with the specified id. Returns True if the task was deleted successfully, False otherwise.

Function/class signature:
  • add_task(id: int, description: str) -> None

  • get_task(id: int) -> Tuple[str, str]

  • delete_task(id: int) -> bool

Example 1:
  • Input: add_task(1, "Write unit tests")

  • Output: None

  • Explanation: A task is created with id 1 and the description "Write unit tests".

Example 2:
  • Input: get_task(1)

  • Output: ("Write unit tests", "Pending")

  • Explanation: Retrieves the task with id 1, which currently is "Write unit tests" and is in status "Pending".

Constraints:
  • 1 <= id <= 10^6

  • description is non-empty and has at most 100 characters

  • At most 10^5 operations are performed.
coding Medium api design #6

6. Cloud Architecture Fundamentals — Implement a simplified cloud service manager


Background: Atlassian relies heavily on cloud services to provide robust software tools for collaboration and project management. A clear understanding of cloud architecture is vital for maintaining scalability and efficiency in this ecosystem.
Problem statement: You are tasked with developing a simplified version of a cloud service manager. This manager will keep track of various cloud services in terms of their name, status, and region. You need to implement methods for adding a service, retrieving the status of a service, and listing all services based on a specific status.
Function/class signature:
  • def add_service(name: str, status: str, region: str) -> None:

  • def get_service_status(name: str) -> str:

  • def list_services_by_status(status: str) -> List[str]:


Example 1:
  • Input: add_service('Jira', 'active', 'US-East')

  • Input: get_service_status('Jira')

  • Output: 'active'

  • Explanation: The service Jira was added as active.


Example 2:
  • Input: add_service('Confluence', 'inactive', 'US-West')

  • Input: list_services_by_status('active')

  • Output: ['Jira']

  • Explanation: Only the active service Jira is listed.


Constraints:
  • Service names are unique strings (1-100 characters).

  • Status can only be either "active" or "inactive."

  • Region can be any string (1-50 characters).

coding Medium dynamic programming #7

7. Dynamic Programming — Maximum Profit from Tasks

Background: Atlassian's tools often facilitate project management and time tracking for development teams. A problem arises when teams want to maximize their productivity by selecting tasks they can complete within given time constraints.
Problem statement: You are given a list of tasks, where each task has a duration and a profit associated with it. Your goal is to find the maximum profit you can achieve by completing tasks without exceeding a total available time. The tasks cannot overlap and must be completed within the given total time.
def maximum_profit(tasks: List[Tuple[int, int]], total_time: int) -> int:
    pass
Example 1:
Input: tasks = [(2, 50), (3, 60), (1, 30)], total_time = 4
Output: 80
Explanation: You can complete the tasks with durations 2 and 1, thus earning a profit of 50 + 30 = 80.
Example 2:
Input: tasks = [(3, 40), (4, 50), (2, 20)], total_time = 5
Output: 50
Explanation: The best option is to complete only the task with duration 4, earning 50 profit.
Constraints:
  • 1 <= len(tasks) <= 100

  • Each task duration and profit is a positive integer, with 1 <= duration, profit <= 100

  • 1 <= total_time <= 100

coding Medium graph #8

8. Graph — Finding the Shortest Path in Jira Issue Links

Background: In Jira, issues can be related to each other through links. These links can represent dependencies, blocks, or references. Understanding the shortest path between issues can help teams efficiently navigate dependencies and address blocking issues.
Problem statement: Given a directed graph representing issues as nodes and links as edges, implement a function to find the shortest path from a start issue to a target issue. Return the list of issue IDs representing the path or an empty list if no path exists.
Function/class signature:
  • def shortest_path(links: List[Tuple[str, str]], start: str, target: str) -> List[str]:

Example 1:
Input: links = [("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("D", "E")], start = "A", target = "E"
Output: ["A", "B", "D", "E"]
Explanation: The shortest path from A to E is through B and D.
Example 2:
Input: links = [("A", "B"), ("B", "C"), ("C", "D")], start = "A", target = "D"
Output: ["A", "B", "C", "D"]
Constraints:
  • 1 <= len(links) <= 1000

  • All issue IDs are unique strings consisting of uppercase letters and digits.

  • Graph can contain multiple edges (but no self-loops).
system design Hard heap #9

9. Design ConfluencePopularityTracker — rank pages and recommend unseen content


Background
Atlassian Confluence helps teams discover useful knowledge across a workspace. Implement an in-memory component that maintains changing page-popularity scores and recommends popular pages that a particular user has not viewed. This exercise adapts candidate-reported Atlassian popularity-tracker and unseen-page recommendation questions; the exact API and rules below are specified for this exercise.
Requirements
1. Each page has a nonnegative integer popularity score, initially zero. Increasing popularity adds one; decreasing subtracts one. Arbitrary signed adjustments are also supported, with the resulting score clamped to zero. Only pages with positive scores participate in rankings.
2. Rank pages by descending popularity, breaking ties by lexicographically ascending page ID. Page IDs contain only lowercase ASCII letters and digits.
3. Return the globally most popular page, or null when no page has a positive score. Updates must take O(log n) time and this lookup must take O(1), where n is the number of positively scored pages.
4. Record which pages each user has viewed. Recording a view is idempotent and does not change popularity. Views may be recorded before a page becomes popular, and remain recorded even if that page later reaches zero popularity.
5. Return up to k ranked pages that the requesting user has not viewed. This operation must not change scores, ranking state, or viewing history. Avoid sorting all active pages on every request; traversal may still inspect every active page when exclusions require it.
6. Public methods must be thread-safe and linearizable within one process. Persistence, distributed coordination, page permissions, and time-based score decay are outside scope.
Class API
  • ConfluencePopularityTracker() — create an empty tracker.

  • increasePopularity(pageId: str) -> int — add one and return the resulting score.

  • decreasePopularity(pageId: str) -> int — subtract one, clamp at zero, and return the resulting score.

  • adjustPopularity(pageId: str, delta: int) -> int — apply a signed adjustment and return the resulting score; adjusting an unknown page by zero or a negative amount leaves it inactive.

  • getMostPopular() -> str | None — return the highest-ranked active page, or null.

  • markViewed(userId: str, pageId: str) -> None — record that the user has viewed the page.

  • getRecommendations(userId: str, k: int) -> list[str] — return at most k unseen page IDs in ranking order; an unknown user has no viewed pages, and k = 0 returns an empty list.


Example 1:
Input sequence, on a new tracker:
[
  ["adjustPopularity", "architecture", 5],
  ["adjustPopularity", "runbook", 5],
  ["increasePopularity", "onboarding"],
  ["getMostPopular"],
  ["markViewed", "alice", "architecture"],
  ["getRecommendations", "alice", 2],
  ["decreasePopularity", "architecture"],
  ["getMostPopular"]
]

Output, one result per call:
[5, 5, 1, "architecture", null, ["runbook", "onboarding"], 4, "runbook"]

Explanation: Architecture and runbook initially tie at 5, so architecture wins lexicographically. Alice's recommendations exclude architecture. Decreasing architecture to 4 makes runbook the global leader.
Example 2:
Input sequence, on a new tracker:
[
  ["markViewed", "bob", "runbook"],
  ["adjustPopularity", "runbook", 3],
  ["adjustPopularity", "runbook", -10],
  ["getMostPopular"],
  ["increasePopularity", "runbook"],
  ["increasePopularity", "architecture"],
  ["getRecommendations", "bob", 5],
  ["getRecommendations", "carol", 5],
  ["getRecommendations", "bob", 0]
]

Output:
[null, 3, 0, null, 1, 1, ["architecture"], ["architecture", "runbook"], []]

Explanation: Subtracting 10 from 3 clamps runbook to zero and removes it from rankings. Its later reactivation does not erase Bob's viewing history. Both active pages then have score 1, so architecture ranks first.
Constraints
  • At most 100,000 public method calls, 100,000 distinct page IDs, and 100,000 distinct user IDs per tracker.

  • IDs are nonempty strings of at most 64 lowercase ASCII letters or digits; inputs satisfy these bounds.

  • Each delta is an integer in [-10^9, 10^9]; 0 ≤ k ≤ 100.

  • At most 100,000 distinct user-page view pairs are stored. View history is retained for the lifetime of the tracker.

  • Concurrent callers may invoke any public methods; each recommendation must reflect one consistent snapshot.

Related Atlassian Software Engineer interview prep

Start practicing Atlassian questions

Sign up for free to access walkthroughs, AI-generated questions, and more.

Get Started Free