← Atlassian Interview Insights
This is the kind of question where you think you've got it in the first five minutes and then you don't.
Start by clarifying requirements and constraints, then design a RESTful API with clear resource modeling and standard HTTP methods. Focus on the core operations: tag CRUD, attaching/detaching tags to entities, listing tags per entity, and searching entities by tags with AND/OR semantics. Discuss data modeling, scalability, and edge cases like tag normalization and permissions.
Pro tip: Demonstrate awareness of real-world concerns like tag name normalization (case-insensitivity, trimming) and idempotency of attach/detach operations. Also, mention how to handle large result sets with pagination and filtering to show production readiness.
Ask questions to understand the entities (e.g., pages, issues), expected scale, permission model, and whether tags are global or scoped. Confirm the need for AND/OR search and any constraints like tag name uniqueness.
Define resources: /tags for tag CRUD, /entities/{entityId}/tags for attaching/detaching/listing tags on an entity, and /entities?tags=tag1,tag2&match=all/any for searching. Use standard HTTP methods (GET, POST, PUT, DELETE) and status codes.
Specify request/response bodies for each endpoint, including how to attach (POST with tag ID or name) and detach (DELETE with tag ID). For search, define query parameters for AND/OR semantics and pagination.
Discuss how to store tags and associations (e.g., many-to-many relationship). Consider indexing for efficient search, normalization of tag names, and handling of tag deletion (cascade or orphan cleanup).
Cover pagination, rate limiting, permissions (who can tag what), idempotency, and error handling. Mention potential performance optimizations like caching or denormalization for search.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
Start by clarifying the requirements and constraints, such as expected concurrency levels and consistency needs. Then propose a design that ensures idempotency (e.g., using idempotency keys or conditional writes) and handles concurrency (e.g., optimistic locking or serializable transactions). Finally, discuss trade-offs and how you would test and monitor the solution.
Pro tip: Emphasize that idempotency is not just about duplicate requests but also about ensuring that the same operation can be safely retried after partial failures, and that concurrency control should be applied at the right granularity to avoid bottlenecks.
Ask about expected concurrency, consistency requirements, and whether the operations are part of a larger transaction. This shows you don't jump to solutions without understanding the problem.
Propose using idempotency keys for each request, storing them with a unique constraint to detect duplicates. Alternatively, use conditional writes (e.g., 'add tag if not present') to make operations naturally idempotent.
Discuss concurrency control mechanisms such as optimistic locking (version numbers) or pessimistic locking (SELECT FOR UPDATE). Consider the trade-offs between them in terms of performance and complexity.
Explain how to handle partial failures, retries, and timeouts. For example, if a detach operation fails after removing the tag but before acknowledging, the retry should not fail because the tag is already gone.
Compare different approaches (e.g., database constraints vs. application-level checks) and mention how you would test concurrency and idempotency, such as with stress tests and chaos engineering.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
The rename collision one I actually liked.
Start by framing the problem: tags are shared references, so deletion, rename, and bulk operations must handle referential integrity and concurrency. Then walk through each edge case systematically, covering data model implications, API design, and user experience. Emphasize trade-offs like soft delete vs. hard delete, optimistic locking, and asynchronous processing for bulk operations.
Pro tip: Atlassian values scalability and user trust, so highlight how you'd prevent data loss and ensure consistency across workspaces, perhaps by referencing their existing patterns like soft deletes in Jira or Confluence.
Ask about expected scale, consistency requirements, and whether tags are global or workspace-scoped. This shows you think before coding.
Propose a schema with a tags table and a join table for entity-tag relationships, including metadata like created_at and deleted_at for soft deletes.
Discuss soft delete vs. hard delete, cascading vs. orphaned associations, and how to maintain referential integrity. Consider asynchronous cleanup for large datasets.
Enforce uniqueness per workspace, use optimistic locking or transactions to handle concurrent renames, and define clear error responses or auto-suffixing strategies.
Design idempotent batch APIs with partial success handling, rate limiting, and asynchronous job processing for large volumes. Ensure atomicity where needed.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.
Start by clarifying the requirements and constraints of each endpoint, then propose a pagination strategy that balances performance, scalability, and ease of use. Discuss trade-offs between offset-based and cursor-based pagination, and recommend a hybrid or context-specific approach with clear API design.
Pro tip: Atlassian values API consistency and developer experience; emphasize how your pagination design aligns with existing Atlassian API patterns (e.g., Jira's cursor-based pagination) and how it handles edge cases like concurrent modifications.
Ask about expected data volume, update frequency, and client needs (e.g., random access vs. sequential). Identify if the tag list is static or dynamic, and if entity search supports complex queries.
For tag list, consider offset-based pagination if tags are relatively stable; for entity search, prefer cursor-based pagination to handle large, changing datasets and avoid duplicates/skips.
Define parameters like limit, offset, cursor, and sort order. Include metadata in responses (e.g., total count, next cursor, links) and standardize error handling for invalid cursors.
Discuss indexing, caching, and database query optimization. For cursor-based, ensure cursors are opaque and encode necessary state (e.g., last ID, sort key).
Cover scenarios like concurrent updates, deleted items, and cursor expiration. Explain how to maintain stable ordering and avoid duplicates or missing results.
AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.