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

Senior

Apr 2026

Summary

Adobe system design round focused entirely on one massive question about building a multi-modal embedding pipeline. No warmup, no small talk, just straight into the deep end for the full hour.

Questions Asked (1)

Design a system that generates and stores embeddings for user-uploaded files across multiple modalities (documents, images, videos), covering the ingestion API, preprocessing per modality, model selection, batching and GPU scheduling, storage strategy, similarity search, deduplication, retry/idempotency handling, model update backfills, monitoring, cost controls, and privacy considerations.

System DesignTechnical Trade-offsData Modeling

Author's notes

This is basically five system design questions stapled together.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the end-to-end pipeline from ingestion to search, making explicit trade-offs at each stage (e.g., synchronous vs. asynchronous processing, model choice, storage tiering). Emphasize idempotency, backfills, and cost controls as first-class concerns, and tie privacy considerations to Adobe's enterprise context.

Pro tip: Treat model updates as a versioned, replayable pipeline: store raw files and processing metadata so you can re-embed without re-uploading, and use shadow deployments to validate new models before switching. This shows you think about long-term operability, not just the happy path.

1. Clarify requirements and constraints

Ask about scale (files/day, size limits), latency expectations, supported modalities, privacy/compliance needs, and budget. This shapes architecture choices like synchronous vs. batch processing and storage tiers.

2. Design ingestion and preprocessing

Define an API that accepts uploads, validates, and stores raw files in object storage (e.g., S3) with metadata in a database. For each modality, outline preprocessing: text extraction/chunking for documents, resizing/normalization for images, frame sampling/transcoding for videos.

3. Model selection, batching, and GPU scheduling

Choose modality-specific embedding models (e.g., CLIP for images, Sentence-BERT for text, VideoMAE for video) and explain batching strategies to maximize GPU utilization. Describe a queue-based scheduler with priority and autoscaling to handle variable load.

4. Storage, indexing, and similarity search

Store embeddings in a vector database (e.g., FAISS, Milvus, Pinecone) with metadata for filtering. Explain index type (HNSW, IVF) and trade-offs between recall, latency, and cost. Include deduplication via hashing or near-duplicate detection.

5. Operational concerns: retries, backfills, monitoring, cost, privacy

Implement idempotent processing with retries and dead-letter queues. For model updates, version embeddings and run backfills as batch jobs. Monitor pipeline health, embedding drift, and costs; enforce privacy via encryption, access controls, and data retention policies.

Key Points to Mention

Idempotency and retry handling: use unique file IDs, deduplication, and exactly-once semantics via transactional writes or idempotency keys.
Model versioning and backfills: store model version with each embedding, and design a replayable pipeline to re-embed when models improve.
Batching and GPU scheduling: dynamic batching, priority queues, and autoscaling to balance latency and cost.
Storage strategy: separate raw files (object storage) from embeddings (vector DB) and metadata (relational/NoSQL), with lifecycle policies.
Similarity search trade-offs: index choice (HNSW vs. IVF), approximate vs. exact, and filtering by metadata.
Privacy and compliance: encryption at rest/in transit, access controls, data residency, and retention policies aligned with Adobe's enterprise requirements.

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