← Atlassian Interview Insights

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

Senior
May 2026

Summary

System design round at Atlassian for a software engineer role. The question was a single sprawling beast about designing a Roblox-style avatar drawing and rendering service, covering basically everything from upload protocol to CDN to moderation. A lot to hold in your head at once.

Questions Asked (1)

Q1

Design the backend for a user-generated avatar drawing system (think Roblox-style), where users submit custom drawings and the service renders and serves the resulting images. Cover the upload protocol for drawing primitives, storage strategy for source vs rasterized formats, the render pipeline including sync vs async tradeoffs and GPU vs CPU workers, CDN distribution and cache invalidation on edits, public feed and sharing access, moderation hooks, and how to scale the renderer under load. Also discuss latency targets, cost, and consistency.

System DesignTechnical Trade-offsAPI & Integrations
Author's notes

This one sprawls in every direction and I think I let it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a high-level architecture that separates upload, rendering, storage, and distribution. Dive into trade-offs for each component, emphasizing async rendering with a job queue, immutable source storage, and CDN caching with versioned URLs for invalidation. Conclude by discussing scaling strategies, moderation integration, and cost/latency considerations.

Pro tip: Treat the drawing primitives as an immutable, versioned artifact and render outputs as derived data; this simplifies cache invalidation, enables re-rendering with improved renderers, and supports rollbacks. Also, consider using a CDN with stale-while-revalidate to balance freshness and latency.

1. Clarify Requirements and Scale

Ask about expected user base, drawing complexity, latency targets, and consistency needs. Establish assumptions for QPS, storage, and rendering time.

2. Design Upload and Storage

Define a JSON-based protocol for drawing primitives, validate and store source immutably (e.g., S3 with versioning). Store rendered outputs separately with metadata linking to source version.

3. Architect Render Pipeline

Choose async rendering with a job queue (e.g., SQS, Kafka) for scalability. Use GPU workers for complex renders and CPU workers for simpler ones, with auto-scaling based on queue depth.

4. Plan Distribution and Caching

Serve rendered images via CDN with versioned URLs (e.g., /render/{source_version}/{render_version}.png). Invalidate cache by updating the version in the URL when source changes.

5. Integrate Moderation and Scale

Add moderation hooks at upload (pre-render) and post-render (image analysis). Scale renderers horizontally, use spot instances for cost savings, and monitor queue latency.

Key Points to Mention

  • Use a job queue for async rendering to decouple upload from render and handle spikes.
  • Store source drawings immutably with versioning; rendered images are derived and can be regenerated.
  • Employ GPU workers for complex renders (e.g., 3D avatars) and CPU workers for simpler 2D, optimizing cost.
  • CDN caching with versioned URLs avoids invalidation issues; use stale-while-revalidate for better UX.
  • Moderation should be multi-layered: pre-render validation of primitives and post-render image scanning.
  • Scale renderers based on queue depth; consider spot instances and pre-warming for latency-sensitive renders.

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