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

Senior

Jun 2026

Summary

System design round at Atlassian focused entirely on diagnosing and fixing a slow recipe lookup service. The question had a lot of surface area and I felt like I was sprinting through topics the whole time.

Questions Asked (1)

You have a recipe lookup and serving system that's too slow. Walk through how you'd reduce end-to-end latency, covering caching at multiple layers, database read scaling, query and index tuning, payload shaping, and async vs sync paths. Also discuss where you'd instrument and measure, and how you'd prioritize given an SLO target.

System DesignTechnical Trade-offsRoot Cause Analysis

Author's notes

Big question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the SLO and current latency breakdown, then systematically address each layer: caching (client, CDN, application, database), read scaling (replicas, sharding), query/index tuning, payload optimization, and async processing. Emphasize instrumentation to measure impact and prioritize changes by expected latency reduction versus effort.

Pro tip: Frame your answer around the SLO: 'To meet p99 < 200ms, I'd focus first on the 80% of requests that are reads, since caching and read replicas can yield immediate wins.' This shows you prioritize based on data, not guesswork.

1. Establish Baseline and SLO

Measure current end-to-end latency, identify bottlenecks via tracing, and clarify the SLO target (e.g., p99 < 200ms). This ensures you optimize the right things.

2. Implement Multi-Layer Caching

Add caching at client (HTTP cache headers), CDN (static assets), application (Redis/Memcached for recipe data), and database (query cache, materialized views). Use appropriate TTLs and invalidation strategies.

3. Scale Database Reads and Tune Queries

Introduce read replicas for horizontal scaling, optimize slow queries with indexes, and consider denormalization or covering indexes for frequent lookups.

4. Optimize Payload and Async Paths

Reduce payload size via compression, field selection, and pagination. Move non-critical work (e.g., logging, recommendations) to async queues to keep the critical path lean.

5. Instrument, Measure, and Prioritize

Add metrics (latency percentiles, cache hit rates, DB load) and tracing. Prioritize changes by expected impact on SLO and effort, iterating based on measurements.

Key Points to Mention

Cache invalidation strategies (TTL, write-through, event-based) and their trade-offs
Read replicas and potential replication lag; when to use sharding or CQRS
Query optimization: EXPLAIN plans, composite indexes, avoiding N+1 queries
Payload shaping: compression (gzip, brotli), sparse fieldsets, pagination
Async processing: message queues (Kafka, SQS) for non-blocking tasks
Instrumentation: distributed tracing (Jaeger), metrics (Prometheus), logging, and SLO monitoring

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