Top Atlassian Software Engineer Interview Questions 2026

Issues form a directed graph where edges represent "blocks" / "is blocked by". BFS for shortest path between issues. DFS with three-color marking for cycle detection in blocking relationships (a cycle is a bug — you can't have circular dependencies). Topological sort (Kahn's) for sprint planning order — assign work in dependency order, parallelize independent items.

WebSocket per board for live updates. Event-sourced issue state (Kafka log) — all mutations are events, projection rebuilds state. CRDT (e.g., LWW-register per field) for concurrent column moves so user reorders don't conflict. Optimistic UI with conflict reconciliation. Server fans out events only to subscribers viewing this board, with permission filtering.

Maps to Build with heart and balance / Craftsmanship value. Choose a story where you went beyond "it works" — refactored for clarity, raised test coverage, wrote architecture docs, established a coding pattern others adopted. End with the long-term impact (reduced bug rate, faster onboarding for new team members).

Two clean approaches. (1) DFS/BFS from each unvisited node — each traversal yields one component. O(V+E) time. (2) Union-Find (Disjoint Set Union) — union endpoints of every edge, then count distinct roots. Near-O(V+E) with path compression and union by rank. Choose UF when edges arrive incrementally (streaming).

Elasticsearch index with one document per page version. Fields: title (boosted), body, space, labels, author. Permission filter at query time (post-filter or attribute-based ACL). BM25 baseline plus boosts for recency, current user's recently-viewed, and personalization. Faceting on space/contributor. Snippet highlighting. Async indexing pipeline from page-change events.

Split on whitespace, reverse the list of words, join with single space. Handles multiple spaces by ignoring empty splits in most languages (or filter empties explicitly). In-place variant for char arrays: reverse the whole string, then reverse each word. O(n) time, O(1) extra space for the in-place version.

Diff generation with Myers algorithm (Git's default). Inline comment threading: comments anchor to (file, line, side) with a stable diff hunk identifier so they survive rebases. Review state machine: open → needs-work → approved → merged. Merge checks pipeline: required reviewers, CI green, no unresolved threads. Webhook integration with CI providers. Branch permissions and protected-branch rules.

Maps to Be the change you seek / Courage value. Story where you raised an uncomfortable issue (a flawed launch plan, an unethical pattern, a teammate underperforming), gave hard feedback, or challenged a senior decision. Show how you delivered it respectfully and what changed afterward. Courage without empathy is just being abrasive — show both.

Node has children map (Char → Node) and isEnd boolean. insert: walk/create nodes for each char, mark isEnd. search: walk; return false on missing or non-end. startsWith: walk; return whether the prefix path exists. Each op is O(L) where L is word length. For autocomplete, store top-K completions cached at each node updated on insert.

Hierarchical: global → product → project → issue. Role-based groups (admin, developer, viewer) with permission schemes. Compute effective permissions at query time using cached ACL lookups; invalidate on group/role changes. Async propagation for large bulk changes (e.g., project archived). Permission schemes are versioned so changes are auditable. For very large orgs, attribute-based access control with policy evaluation.

Maps to Build with heart and balance value. Tell a story where you shipped an MVP under pressure but defined an explicit quality threshold (test coverage, monitoring, rollback plan) and tracked the tech debt afterward. Show that you didn't ignore quality — you made a conscious, documented tradeoff and paid the debt down.

Map of topic → Set of subscriber callbacks. subscribe(topic, fn): add to set. unsubscribe: remove. publish(topic, msg): iterate subscribers and invoke. Use a ReadWriteLock or ConcurrentHashMap for thread safety. Consider isolation: a slow subscriber shouldn't block others — fire callbacks on a thread pool or queue messages per subscriber. Handle exceptions per subscriber so one failure doesn't break the publish.

Event bus (Kafka) for app events. Notification service consumes, applies user preferences (channel: email/in-app/mobile; granularity per project), and fans out to delivery workers. Digest mode for high-volume users — batch and send hourly/daily. At-least-once delivery with idempotent recipient-side dedupe. Bounce handling for email. Push tokens (APNS/FCM) with refresh.

Recursive: for each element, if it's a list call recursively and extend result; else append. In Python: flatten = lambda xs: [y for x in xs for y in (flatten(x) if isinstance(x, list) else [x])]. Iterative variant uses an explicit stack for large depths to avoid recursion limit.

Maps to Play as a team value. Show facilitation, not domination. Story arc: surfaced different positions, gathered data, ran a quick prototype to falsify positions, timeboxed the decision (no decision = decision). End with a decision everyone could commit to (even if they would have chosen differently). Document and move on.

Event-sourced sprint data: every story-point change, transition, and add/remove emits an event. Daily aggregation job rolls events into per-sprint snapshots in a time-series DB (e.g., OpenSearch). Velocity = points-completed-per-sprint moving average. Burndown = remaining points over time. Pre-compute metrics so chart endpoints are O(1). Historical trend analysis as a separate batch job.