← Atlassian Interview Insights

Atlassian·Software Engineer·Onsite - System Design / Architecture·Intermediate

Intermediate
Jun 2026

Summary

Atlassian software engineering interview with a system design question focused on OOP for a CI/CD notification service. The problem had enough moving parts to keep you busy for a full session, and the rollover logic is where things get interesting.

Questions Asked (1)

Q1

Design an object-oriented CI/CD release notification service. Each day deployments run and authors of included commits get notified with their version. If a deployment fails, the system rolls forward to the next version and carries over all pending authors from the failed deployment. Design the core classes (Deployment, Version, Author, Notifier) and the notify() API.

System DesignData ModelingAPI & Integrations
Author's notes

The rollover logic is what tripped me up at first.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and constraints, then model the domain with core classes and their relationships, focusing on state transitions and notification logic. Design the notify() API to handle success and failure scenarios, ensuring pending authors are carried over correctly. Finally, discuss trade-offs and potential extensions.

Pro tip: Emphasize idempotency and failure handling in notifications to avoid duplicate or missed alerts, and consider how to scale the system for high deployment frequency.

1. Clarify Requirements

Ask questions to understand the scope: What triggers a deployment? How are versions determined? What defines a failed deployment? How should notifications be delivered (email, chat)? Are there retries or acknowledgments?

2. Identify Core Entities and Relationships

Define classes: Deployment (has a Version, status, and associated Authors), Version (immutable identifier), Author (recipient info), Notifier (sends notifications). Establish that a Deployment aggregates commits, each with an Author.

3. Design State Management and Carry-Over Logic

Model deployment states (PENDING, SUCCESS, FAILED). On failure, the next deployment should inherit pending authors from the failed one. Ensure authors are only notified once per version, even if carried over.

4. Define the notify() API

Design notify() to be called after a deployment attempt. It should determine recipients based on deployment status: on success, notify all authors (including carried-over) with the new version; on failure, mark authors as pending for the next deployment.

5. Discuss Trade-offs and Extensions

Consider idempotency, concurrency, and scalability. Mention potential use of queues for notifications, persistent storage for pending authors, and how to handle multiple failures in a row.

Key Points to Mention

  • Use of immutable Version objects to ensure consistency.
  • Deployment status enum (e.g., PENDING, SUCCESS, FAILED) to manage state transitions.
  • Carry-over mechanism: pending authors from failed deployments are merged into the next deployment's author list.
  • Idempotent notification logic to prevent duplicate notifications for the same author and version.
  • Separation of concerns: Notifier interface abstracts delivery mechanism (email, Slack, etc.).
  • Scalability considerations: asynchronous notification processing and persistent storage for pending authors.

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