Atlassian Interview Questions: Coding, Design and Values

What Atlassian asks in each round, the problems its LeetCode tag repeats, and its new AI-enabled code design round, with a worked example.

Most Atlassian interview questions for engineers fall into four buckets: a medium-level data structures problem, a code design task, a 60-minute system design prompt, and behavioral questions mapped to Atlassian's five values. The part most prep guides miss is in Atlassian's own candidate guides: the Code Design interview now runs in a HackerRank IDE with AI coding assistants, and you extend an existing codebase rather than solve a blank-page puzzle. LeetCode practice still covers the Data Structures round. For the design round, practise reading unfamiliar code, adding a feature with tests, and explaining your choices out loud.

What changed: an AI assistant in the Code Design round

Atlassian's engineering interview page describes the coding interview as two parts, Data Structures and Code Design, and says you can choose the language you work in. The role-specific guides linked from that page (we read the Backend and Fullstack versions in October 2026) add detail the page does not:

• Data Structures is on your own machine. Atlassian asks you to have an IDE and "your favorite testing framework" ready, with a CodePair environment as a fallback, and you share your screen on Zoom.
• Code Design is "AI-enabled". You get a HackerRank IDE with AI coding assistants and an existing repository, and you are asked to add features, fix bugs or refactor. The codebase uses a specific language. The guides say they are not testing deep knowledge of that language, and that it is fine to ask the AI to explain syntax.
• Testing is part of the grade. Both guides say testing "is crucial to success" and recommend brushing up on test-driven development. A debugger is "welcome and encouraged".
• Each coding interview is capped at 60 minutes and also assesses how you handle blockers, adapt and communicate.

So "choose your language" holds for Data Structures, but the Code Design repository comes in a specific language. If your recruiter has not said which language the design repository uses, ask. A few hours reading an unfamiliar codebase in that language will help more than another ten LeetCode problems.

The shift matches what Karat, which two of the prep sites we read say runs Atlassian's first technical screen, announced in December 2025: interviews where candidates work on multi-file projects with a built-in AI assistant while a human interviewer probes their reasoning and trade-offs. Karat's release names Atlassian among the companies that have used its data to define and measure engineering quality. It does not say which Atlassian rounds use the new format.

The loop, round by round

• Stage — What it is — Source
• Recruiter call — About 30 minutes on your background and interest. — Prep guides (interviewing.io, TechPrep)
• Technical screen — Reported as a Karat interview run by a Karat engineer, with a LeetCode-medium problem for backend and fullstack roles. Atlassian's own guides do not mention it. — Prep guides
• Stage 1: two coding interviews — Data Structures, then AI-enabled Code Design. Fullstack candidates get a frontend browser coding round in place of Data Structures. 60 minutes each. — Atlassian guides
• Stage 2: system design — 60 minutes on a whiteboard, paper or drawing tool. Starts with fundamentals, then builds in complexity. — Atlassian guides
• Stage 2: management — 60 minutes with an engineering manager, structured and scenario-based. — Atlassian guides
• Stage 2: values — 45 minutes of behavioral questions, often with an interviewer from outside the hiring team. — Atlassian guides and careers page
• Debrief and hiring committee — The committee works apart from the interviewers and has access to specific information such as interview feedback and your CV. — Atlassian careers page

Your recruiter tells you after each stage whether you are moving on, so a weak Stage 1 can end the process before the behavioral rounds. If you searched for "Atlassian online assessment questions": Atlassian's guides describe no separate online assessment, and the prep sites we read place the Karat screen as the first technical step. AlgoMonster lists an online assessment but does not say where its process outline comes from.

Data Structures round: what the LeetCode tag shows

The best public proxy is LeetCode's Atlassian company tag. A widely used GitHub mirror of those tags, updated in August 2026, lists 58 Atlassian problems: 5 easy, 39 medium and 14 hard. Interviewing.io's guide says the same thing about the coding questions in general: about LeetCode medium. Tags are reported by users, so read them as patterns, not a question bank.

Recurring problems on the all-time list, grouped by what they test:

• Small classes with fast operations. Stock Price Fluctuation, All O\`one Data Structure, Design Snake Game, Logger Rate Limiter, LRU Cache and Design a Food Rating System. Ten of the 58 tagged problems carry LeetCode's "Design" topic. This is the most Atlassian-looking cluster, and it is the same skill the Code Design round tests: state that changes, kept consistent, with clear methods.
• Counting and sorting with tie-breaks. Rank Teams by Votes (top of the all-time list), High-Access Employees and Top K Frequent Elements. Most of the work is getting the ordering rules right.
• Intervals and scheduling. Merge Intervals and Meeting Rooms II. Merge Intervals is also one of only four problems on the six-month list.
• Trees. Lowest Common Ancestor of a Binary Tree appears in four variants on the list, and TechPrep also reports it from candidates.
• Grids and strings. Word Search, Text Justification and Find the Width of Columns of a Grid, which mostly test careful simulation.

TechPrep's round-by-round report names three Data Structures problems: Lowest Common Ancestor, Rank Teams by Votes, and the base logic of a Snake game. All three are on the tag list too, which is a reasonable sign the tag reflects real interviews.

If your time is short, do the design-class cluster and the tie-break problems first.

Code Design: a worked example

TechPrep reports a backend Code Design prompt: a popularity tracker with methods to increase popularity and return the most popular item, including tie-breaks and a concurrency follow-up. All O\`one Data Structure, third on the tag list, is a harder version of the same idea. Here is how to work it the way Atlassian's guides describe, tests first.

Ask before coding: can popularity go down, can it go below zero, and which item wins a tie? Say your assumptions out loud. Below, a decrease never goes below zero, items at zero do not count, and on a tie the most recently changed item wins.

Write the tests before the class:

def test_tracker():
    t = PopularityTracker()
    assert t.most_popular() is None
    t.increase("a"); t.increase("b"); t.increase("b")
    assert t.most_popular() == "b"
    t.decrease("b"); t.decrease("b")
    assert t.most_popular() == "a"
    t.increase("b")                     # tie at 1: the most recent change wins
    assert t.most_popular() == "b"
    t.decrease("a"); t.decrease("a")    # never goes below zero
    assert t.most_popular() == "b"

Then the simplest design that passes: a dictionary of current scores and a max-heap that may hold stale entries, cleaned up lazily when you read the top.

import heapq
import itertools

class PopularityTracker:
    def __init__(self):
        self._score = {}                # content_id -> current popularity
        self._heap = []                 # (-score, -tick, content_id); may hold stale entries
        self._tick = itertools.count()

    def increase(self, content_id):
        self._set(content_id, self._score.get(content_id, 0) + 1)

    def decrease(self, content_id):
        score = self._score.get(content_id, 0)
        if score > 0:
            self._set(content_id, score - 1)

    def most_popular(self):
        while self._heap:
            neg_score, _, content_id = self._heap[0]
            if -neg_score > 0 and self._score.get(content_id) == -neg_score:
                return content_id
            heapq.heappop(self._heap)   # stale entry: drop it and look again
        return None

    def _set(self, content_id, score):
        self._score[content_id] = score
        heapq.heappush(self._heap, (-score, -next(self._tick), content_id))

Updates cost O(log n). Reads are amortised O(log n), because each stale entry is popped once. Say the weakness before the interviewer does: the heap grows with every update, so a busy tracker keeps a lot of dead entries. That sets up the follow-ups this kind of round is built for:

1. "Make every operation O(1)." Move to the All O\`one design: a doubly linked list of buckets, one per score, with a map from item to bucket. Increase and decrease move an item to the neighbouring bucket.
2. "Two threads call increase at once." The read-modify-write in increase is a race. The simplest fix is one lock around each public method. Then discuss whether reads need it too.
3. "Add a top-k method." Your tests already describe the tie rule, so you extend them and change as little code as you can.

In the AI-enabled version, you would more likely meet a tracker like this half-built in an unfamiliar language, with a failing test and a new requirement. The habits are the same: read the existing tests first, decide what to change before you prompt the assistant, and check its output against tests you wrote. Interviewers can only see your judgment if you say it out loud.

System design prompts candidates report

Atlassian's guides say the round starts with fundamentals and builds in complexity, with attention to performance, reliability and keeping "the customer in mind". The careers page adds that follow-ups "ladder" in difficulty and that there is no one right answer. Reported prompts lean on Atlassian's own products:

• A rate limiter for Jira's APIs, a Jira notification service, and a real-time collaborative editing layer like Confluence's (TechPrep).
• A job scheduler, a task list and a tagging system (interviewing.io).

Use the products for an hour before the round. "Who would you involve?" is also a listed theme, so mention the teams you would partner with.

Values and management questions

The values round maps to Atlassian's five values: Open company, no bullshit; Build with heart and balance; Don't #@!% the customer; Play, as a team; Be the change you seek. The guides list sample prompts for each, paraphrased here:

• Play, as a team: how you helped a struggling teammate, and when you put team goals above your own.
• Be the change you seek: a time you pushed for a change, and what happened.
• Don't #@!% the customer: how you put users first, and the trade-off it cost.
• Open company, no bullshit: a difficult conversation, a conflict you resolved, and how you adjusted your style.
• Build with heart and balance: how you make decisions, and a time the team missed the mark and how you fixed it.

The management interview covers four areas: owning outcomes, using your expertise to drive improvements, taking initiative, and your contribution to the team's success. Atlassian suggests projects where you had measurable impact and felt stretched, not only your best or most recent ones. Prepare one story per value and two project deep dives. Many stories can serve both rounds if you can tell them from different angles.

What to do now

If your loop is a week or two out:

1. Ask your recruiter three things: whether you have a Karat screen, your exact Stage 1 rounds, and the language of the Code Design repository.
2. Set up your Data Structures environment with a test runner you can start in seconds. Practise writing a test before each solution.
3. Work the design-class cluster from the tag list, then the tie-break and interval problems. Time each one at 40 to 45 minutes and explain as you go.
4. Practise extending code you did not write. Pick a small open-source project in the repo language, add a feature with tests, and use an AI assistant only for syntax. Then explain every change you accepted.
5. Draft five values stories and two project deep dives, each with a decision you made and what you would do differently.

When you check your practice work, Verve AI's Coding Copilot can capture a problem from your screen; after you have solved it yourself, its Complexity and Edge Case quick actions give you a second analysis to compare with yours. For the screen before the loop, our guide to Karat interview questions covers that format, and this list of common LeetCode interview questions is a broader warm-up.

Sources

• Five-stage process, coding in two parts (Data Structures and Code Design), choose your language, 60-minute systems design with laddering follow-ups, manager interview, values interviewer often from outside the team, independent hiring committee: https://www.atlassian.com/company/careers/resources/interviewing/engineering
• Backend Engineer candidate guide: two stages, 60-minute coding cap, IDE and testing framework, CodePair fallback, AI-enabled Code Design in a HackerRank IDE with AI assistants and an existing repository, TDD, debugger, system design format, 60-minute management interview and its four areas, 45-minute values interview with sample prompts: https://dam-cdn.atl.orangelogic.com/CDNLink/AT12O7ZK.pdf
• Fullstack Engineer candidate guide: frontend browser coding round, AI-enabled backend code design, fullstack system design: https://dam-cdn.atl.orangelogic.com/CDNLink/AT12OJH7.pdf
• Atlassian's five values: https://www.atlassian.com/company/values
• Karat NextGen launch (December 10, 2025), multi-file projects with an AI assistant, Atlassian named among companies that have used Karat's data: https://karat.com/karat-launches-nextgen-interviews-the-first-human-led-ai-enabled-talent-evaluation-solution/
• Recruiter call, Karat technical screen run by a Karat interviewer, LeetCode-medium coding level, system design prompts (job scheduler, task list, tagging system), round lengths: https://interviewing.io/atlassian-interview-questions
• Karat screen with a redo option, reported Data Structures problems (Lowest Common Ancestor, Rank Teams by Votes, Snake game), popularity tracker Code Design prompt with concurrency, debounced search bar for frontend, system design prompts (Jira rate limiter, notification service, collaborative editing): https://www.techprep.app/blog/atlassian-interview-process
• Atlassian LeetCode tag mirror (58 problems, difficulty split, frequency order, Design topics; six-month list): https://github.com/liquidslr/leetcode-company-wise-problems/tree/main/Atlassian
• Process outline with an online assessment step and pattern counts (no methodology given): https://algo.monster/interview-guides/atlassian
• Coding Copilot screen capture and quick actions: https://docs.vervecopilot.com/features/coding-copilot