← Coupang Interview Insights

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

SeniorPrefer not to say
May 2026

Summary

Coupang system design round focused entirely on YouTube, specifically the video upload path. Pretty intense scope for a single session, they wanted real depth not just a surface walkthrough.

Questions Asked (5)

Q1

Design YouTube, with a focus on how large video files get uploaded reliably from the client to the backend.

System DesignTechnical Trade-offsAPI & Integrations
Author's notes

This is where I spent most of the session.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying functional and non-functional requirements, then sketch a high-level architecture for YouTube before diving deep into the upload pipeline. Focus on reliability, scalability, and trade-offs in chunked, resumable uploads with integrity checks and asynchronous processing.

Pro tip: Emphasize idempotency and exactly-once semantics for upload sessions, and discuss how you'd handle partial failures and retries without duplicating data—this shows production maturity beyond textbook designs.

1. Clarify Requirements and Scope

Ask about scale (daily uploads, file sizes), reliability guarantees, supported clients, and whether live streaming is in scope. Define core features: upload, transcode, store, and serve videos.

2. High-Level Architecture

Outline components: client, API gateway, upload service, object storage (e.g., S3), transcoding pipeline, metadata DB, CDN. Explain how they interact for upload and playback.

3. Design the Upload Protocol

Propose chunked, resumable uploads (e.g., tus, S3 multipart) with unique upload IDs, checksums per chunk, and retry logic. Discuss client-side chunking and parallel uploads.

4. Ensure Reliability and Integrity

Detail how to handle network failures, resume uploads, verify integrity via checksums, and use idempotent operations to avoid duplicates. Mention server-side validation and virus scanning.

5. Scale and Optimize

Explain how to scale upload service horizontally, use CDN for upload acceleration, and decouple transcoding via message queues. Discuss trade-offs like chunk size, retry policies, and cost.

Key Points to Mention

  • Chunked and resumable upload protocols (e.g., tus, S3 multipart upload)
  • Idempotency and exactly-once semantics for upload sessions
  • Integrity checks (checksums, hashes) and error handling
  • Asynchronous processing with message queues for transcoding
  • Scalability and cost trade-offs (chunk size, parallel uploads, storage tiers)
  • Security considerations (pre-signed URLs, virus scanning, access control)

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

Q2

Walk through the post-upload processing pipeline: transcoding to multiple resolutions, generating thumbnails, and how you coordinate all of that.

System DesignTechnical Trade-offs
Author's notes

I went with an async queue approach, separate workers for transcoding jobs per resolution, and a fan-out after the raw upload lands in object storage.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale (e.g., video sizes, upload volume, latency expectations), then describe a pipeline using a message queue and worker pool for asynchronous processing. Walk through each stage—validation, transcoding to multiple resolutions, thumbnail generation, and coordination—while highlighting trade-offs like synchronous vs. asynchronous processing and cost vs. speed.

Pro tip: Emphasize idempotency and failure handling: each processing job should be retryable without duplicating work, and use a state machine to track progress. This shows you think about real-world reliability, not just the happy path.

1. Clarify requirements and constraints

Ask about expected upload volume, video length/resolutions, latency SLAs, and storage budget. This frames your design decisions and shows you avoid over-engineering.

2. Design the ingestion and queueing layer

Describe how the uploaded file is stored (e.g., S3) and a message is enqueued (e.g., SQS/Kafka) to decouple upload from processing. Mention validation (format, size) before enqueueing.

3. Orchestrate transcoding and thumbnail generation

Explain how worker pools consume jobs, transcode to multiple resolutions (e.g., using FFmpeg), and generate thumbnails in parallel. Discuss coordination via a state machine or workflow engine (e.g., AWS Step Functions) to track completion of all outputs.

4. Handle failures, retries, and idempotency

Detail how to make each step idempotent, use dead-letter queues for poison messages, and implement retries with exponential backoff. Mention monitoring and alerting for stuck jobs.

5. Discuss trade-offs and optimizations

Compare synchronous vs. asynchronous processing, on-the-fly transcoding vs. pre-transcoding, and cost implications. Suggest optimizations like priority queues for premium users or spot instances for cost savings.

Key Points to Mention

  • Asynchronous processing with message queues to decouple upload from heavy compute
  • Transcoding to multiple resolutions using tools like FFmpeg, possibly with GPU acceleration
  • Thumbnail generation as a separate parallel task, with options for frame selection
  • Coordination via a state machine or workflow orchestrator to ensure all outputs are ready before marking job complete
  • Idempotency and retry mechanisms to handle failures without duplicating work
  • Trade-offs: cost vs. latency, pre-transcoding vs. on-demand, and scalability considerations

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

Q3

How would you handle failures and retries across the upload and processing pipeline, especially for multi-GB files?

System DesignTechnical Trade-offsAlgorithms & Data Structures
Author's notes

Went okay but I over-indexed on the upload side and forgot to address processing failures separately.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the pipeline stages (upload, storage, processing) and the failure modes at each stage. Then propose a layered strategy: chunked uploads with resumability, idempotent processing with checkpoints, and a retry mechanism with exponential backoff and dead-letter queues. Emphasize trade-offs between consistency, latency, and cost, and how to handle partial failures for multi-GB files.

Pro tip: Mention that for multi-GB files, you should avoid re-uploading the entire file on failure by using chunk-level checksums and resumable uploads (e.g., S3 multipart upload). Also, highlight the importance of idempotency keys to prevent duplicate processing when retries occur.

1. Clarify requirements and failure modes

Ask about file size limits, expected failure rates, latency requirements, and consistency needs. Identify failure points: network interruptions during upload, storage failures, processing errors, and partial writes.

2. Design for resumable and chunked uploads

Propose breaking files into chunks (e.g., 5-10 MB) and uploading them independently with checksums. Use a manifest to track uploaded chunks and allow resuming from the last successful chunk.

3. Implement idempotent and checkpointed processing

Ensure processing steps are idempotent using unique job IDs and store intermediate results. Use checkpoints to resume processing from the last successful step instead of reprocessing the entire file.

4. Define retry policies and backoff strategies

Use exponential backoff with jitter for transient errors, and set a maximum retry limit. For non-retryable errors, route to a dead-letter queue for manual inspection.

5. Monitor, alert, and handle partial failures

Instrument the pipeline with metrics (e.g., upload success rate, processing latency) and alerts. For partial failures, ensure cleanup of orphaned chunks and provide a way to restart from a known good state.

Key Points to Mention

  • Chunked/resumable uploads (e.g., S3 multipart upload) to avoid re-uploading entire multi-GB files.
  • Idempotency keys and deduplication to prevent duplicate processing on retries.
  • Checkpointing and state management to resume processing from the last successful step.
  • Exponential backoff with jitter and maximum retry limits for transient errors.
  • Dead-letter queues for non-retryable failures and manual intervention.
  • Monitoring and alerting for pipeline health, with metrics on failure rates and latency.

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

Q4

How does the CDN fit into your design, and how do you make sure users are served the right resolution efficiently?

System DesignTechnical Trade-offs
Author's notes

Honestly the CDN piece felt like a relief after the upload grilling.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by explaining the CDN's role in caching and delivering content from edge locations close to users, then detail how you handle multiple resolutions through adaptive bitrate streaming or device detection. Emphasize efficiency by discussing caching strategies, resolution selection logic, and trade-offs between quality and latency.

Pro tip: Mention how you'd use CDN logs and real-user monitoring to continuously optimize resolution delivery, showing a data-driven approach to performance tuning.

1. Define CDN's role

Explain that the CDN caches content at edge servers to reduce latency and offload origin, and how it fits into your overall system architecture.

2. Handle multiple resolutions

Describe how you store and serve different resolutions, such as using adaptive bitrate streaming (HLS/DASH) or separate URLs for each resolution.

3. Select right resolution

Detail the logic for choosing the appropriate resolution based on device capabilities, network conditions, and user preferences, possibly using client-side detection or server-side decisions.

4. Ensure efficient delivery

Discuss caching strategies (e.g., TTL, cache invalidation), CDN configuration (e.g., edge rules), and optimization techniques like compression and prefetching.

5. Monitor and optimize

Explain how you'd measure performance (e.g., cache hit ratio, latency, error rates) and iterate on the design using CDN analytics and A/B testing.

Key Points to Mention

  • Adaptive bitrate streaming (HLS/DASH) for dynamic resolution switching
  • Device detection and network condition assessment (e.g., client hints, bandwidth estimation)
  • CDN caching strategies: TTL, cache keys, and invalidation
  • Edge computing for dynamic resolution selection
  • Trade-offs between quality, latency, and cost
  • Monitoring and analytics for continuous improvement

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

Q5

Where and how would you store video metadata, and what does that schema look like?

Data ModelingSystem Design
Author's notes

Short discussion.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scale and access patterns (e.g., read-heavy, write-heavy, global distribution) to justify your storage choice. Then propose a hybrid storage architecture: a relational database for transactional metadata and a NoSQL or search store for scalable reads. Finally, outline a concrete schema with key fields, indexes, and partitioning strategy.

Pro tip: Mention that video metadata often includes both structured fields (e.g., duration, codec) and semi-structured data (e.g., tags, user-generated descriptions), so a flexible schema or a combination of stores is often necessary. Also, discuss how you would handle schema evolution and versioning to avoid breaking changes.

1. Clarify Requirements

Ask about scale (number of videos, QPS), access patterns (read vs. write, query types), consistency needs, and latency requirements. This determines whether a single store suffices or a polyglot approach is needed.

2. Choose Storage Technology

Select a primary store (e.g., PostgreSQL for ACID transactions) and complementary stores (e.g., Elasticsearch for full-text search, Redis for caching, S3 for thumbnails). Justify each based on requirements.

3. Design the Schema

Define core tables/collections: videos (id, title, description, duration, format, resolution, upload_date, status), users, tags, and video_tags. Include indexes on frequently queried fields (e.g., upload_date, user_id, status).

4. Address Scalability and Partitioning

Explain how to shard or partition data (e.g., by user_id or video_id) to distribute load. Discuss replication for high availability and caching strategies for hot data.

5. Handle Evolution and Consistency

Describe how to manage schema changes (e.g., using migrations, versioned APIs) and ensure consistency across stores (e.g., via change data capture or dual writes with idempotency).

Key Points to Mention

  • Polyglot persistence: using different databases for different access patterns (e.g., RDBMS for transactions, NoSQL for scale, search engine for queries).
  • Schema design: normalized tables for core metadata, with foreign keys and indexes; consider denormalization for read performance.
  • Partitioning/sharding strategy: horizontal scaling by user_id or video_id, with consistent hashing to avoid hotspots.
  • Caching: use Redis or Memcached to cache frequently accessed metadata to reduce database load.
  • Data consistency: eventual consistency vs. strong consistency; use of transactions or sagas for cross-store updates.
  • Schema evolution: backward-compatible changes, versioning, and migration strategies to handle new metadata fields.

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