Coding and Code Design (DSA + Implementation)
Atlassian assesses whether you can take a problem from statement to working code with tests. You will often start with a straightforward baseline (correctness first), then improve complexity or structure. Strong performance looks like crisp decomposition, data structure choice justification, simple tests, and measured optimization.
Be ready to go over:
- Arrays, hash maps, sets, stacks/queues – Iteration patterns, frequency maps, two-pointer patterns.
- Sorting and searching – Custom comparators, stability, and when to prefer heap/priority queue.
- OOP and code design – Cohesive classes, clear interfaces, input validation, and basic TDD mindset.
Advanced concepts (less common):
- Heaps/priority queues and interval problems
- Graphs and BFS/DFS variations
- Streaming/online algorithms under constraints
Example questions or scenarios:
- “Design and code a Snake game; handle movement, collisions, and scoring. Add end-game conditions.”
- “Implement a file report generator from logs; produce summaries with sorting and grouping.”
- “Solve a voting/candidate ranking problem with two-dimensional sorting; then optimize.”
- “Dictionary/hash-map manipulation with classes; add tests and handle edge cases.”
- “Find and fix a bug in a JS closure (let vs var) snippet.”
System Design (High-Level and API-First)
System design emphasizes API clarity, data modeling, and depth on bottlenecks and scale. Interviewers often push for deeper API-level detail, not just boxes and arrows. Strong answers tie user requirements to API contracts, data schemas, and operational readiness (cache, rate limiting, backpressure, monitoring).
Be ready to go over:
- API design and data models – Resource naming, request/response shapes, pagination, errors, idempotency.
- Storage and indexing – Read/write patterns, sharding vs partitioning, eventual consistency trade-offs.
- Performance and reliability – Caching, queues, rate limiting, retries, timeouts, and observability.
Advanced concepts (less common):
- CAP theorem trade-offs in specific flows
- Crawler/scheduler architectures and link graph considerations
- Rate limiter designs (token/leaky bucket) at scale
Example questions or scenarios:
- “Design a web/URL scraping system; go deep on the core scraping API, request/response schema, and dedup.”
- “Build a rate limiter for an API; discuss token bucket vs leaky bucket and multi-tenant fairness.”
- “Scale a todo list service with API design and persistence. Add consistency guarantees and caching.”
Frontend/Browser Coding (for Frontend/Fullstack tracks)
Browser coding rounds stress practical UI engineering under time constraints. You may be asked to implement components in vanilla JS or React, manipulate the DOM, or style to a provided spec. Strong performance balances correctness, modularity, and clarity of state management and fetch lifecycles.
Be ready to go over:
- Vanilla JS DOM manipulation – Events, async fetch, JSON decoding, dynamic rendering.
- React component design – Props/state, effect management, controlled inputs, error handling.
- CSS layout fundamentals – Flexbox/Grid and responsive considerations.
Advanced concepts (less common):
- Feature flag mechanisms
- Performance optimizations and memoization
- Accessibility basics (ARIA, keyboard nav)
Example questions or scenarios:
- “Create a nested bullet list where items can expand/collapse into sublists.”
- “Build a todo list in vanilla JS; fetch items from an API and render with filters.”
- “Design a file tree component; discuss state shape and performance.”
- “Implement feature flags and show how to toggle behavior safely.”
Values and Behavioral (Leadership and Craft)
Values interviews are decisive. Interviewers expect concrete STAR stories showing customer focus, ownership, teamwork, and candor. Strong performance connects actions to outcomes, highlights difficult trade-offs, and reflects on learnings—especially around failures or course-corrections.
Be ready to go over:
- Customer empathy and quality – Mitigating risk, communicating incidents, preventing regressions.
- Collaboration and conflict – Navigating misalignment, influencing without authority.
- Delivery and iteration – Slicing scope, de-risking assumptions, and measurable impact.
Advanced concepts (less common):
- Leading cross-team initiatives
- Mentorship and uplifting others’ craft
- Driving process change aligned to values
Example questions or scenarios:
- “Tell me about a time you disagreed with a teammate. What did you do and what changed?”
- “Describe a failure and how you handled impact to customers.”
- “When did you simplify a complex solution to ship faster without sacrificing quality?”
Communication and Collaboration (Cross-cutting)
Your ability to clarify requirements, summarize decisions, and time-manage is continuously evaluated. Strong candidates turn vague prompts into concrete checkpoints, make trade-offs explicit, and keep the interviewer aligned.
Be ready to go over:
- Clarifying assumptions – Restating scope, confirming constraints before diving in.
- Checkpoints and summaries – “Here’s the baseline,” “Here’s the optimization,” “Open questions.”
- Resilience under ambiguity – Proceeding with a reasonable strawman when direction is thin.
Advanced concepts (less common):
- Facilitating technical decisions with trade-off matrices
- Writing short design notes under time pressure
- Defusing miscommunication with crisp restatements
Example questions or scenarios:
- “Interviewer gives a vague coding prompt; you must ask targeted questions to pin down requirements.”
- “System design feedback suggests more depth; you choose an area (e.g., consistency or monitoring) to go deep.”
