High-Level Design

Problem brief

Build a review platform where public posts do not reveal the author's identity.

Core requirements

• Accept text and photo uploads.
• Browse reviews and moderate abuse.

Design points to discuss

Discuss anonymity boundaries, upload storage, abuse controls, deletion, and pagination without exposing private account data.

Problem brief

Build a location-aware dating platform.

Core requirements

• Discover eligible profiles and record swipes.
• Create a match when interest is mutual.

Design points to discuss

Discuss geospatial retrieval, privacy, duplicate swipe handling, match consistency, and partitioning popular regions.

Problem brief

Track and share fitness activities.

Core requirements

• Ingest GPS samples and compute route summaries.
• Show activity feeds and segment rankings.

Design points to discuss

Discuss offline uploads, geospatial storage, deduplication, privacy zones, and asynchronous metric computation.

Problem brief

Build a short-post social network.

Core requirements

• Publish posts and follow accounts.
• Serve a personalized timeline.

Design points to discuss

Compare fan-out on write and read; handle celebrity accounts, feed pagination, deletion, and availability during partial failure.

Problem brief

Design the core of a social network rather than every product feature.

Core requirements

• Manage profiles and relationships.
• Publish posts and assemble a permission-aware feed.

Design points to discuss

Define service boundaries; discuss graph storage, feed ranking, media storage, and privacy changes propagating to cached content.

Problem brief

Build a photo-sharing application.

Core requirements

• Upload media and follow creators.
• Serve a feed with likes and comments.

Design points to discuss

Discuss upload processing, object storage, CDN delivery, feed fan-out, and consistent handling of deleted or private posts.

Problem brief

Build a professional networking platform.

Core requirements

• Maintain profiles and connections.
• Search people or jobs and serve professional updates.

Design points to discuss

Discuss graph traversal, search indexing, privacy, high-degree accounts, and separating feed and recruitment workloads.

Problem brief

Build a multi-device messaging service.

Core requirements

• Send direct and group messages.
• Provide delivery status and offline history.

Design points to discuss

Discuss connection gateways, per-conversation ordering, retries, device synchronization, and end-to-end encryption boundaries.

Problem brief

Find the best book offer across independent sellers.

Core requirements

• Accept buyer requests with a price limit.
• Query seller APIs and compare available offers.

Design points to discuss

Discuss adapter interfaces, vendor timeouts, partial results, caching, asynchronous quotes, and quote expiry before purchase.

Problem brief

Build a hotel booking platform with reliable availability.

Core requirements

• Search by destination and dates.
• Hold and confirm rooms with payment.

Design points to discuss

Discuss room-night inventory, search freshness, oversell prevention, payment compensation, and supplier integration.

Problem brief

Build a vehicle rental marketplace or fleet service.

Core requirements

• Search cars by location and rental interval.
• Reserve, collect, and return a vehicle.

Design points to discuss

Discuss interval inventory, branch transfers, pricing snapshots, payment holds, and concurrent reservations.

Problem brief

Keep merchant catalogs current while serving shoppers.

Core requirements

• Accept individual and bulk listing changes.
• Expose searchable product information.

Design points to discuss

Discuss ingestion queues, validation, index lag, ordering of updates, and isolating large merchants from smaller tenants.

Problem brief

Coordinate reservations for library copies across branches.

Core requirements

• Search the catalog and place holds.
• Allocate returned copies to waiting readers.

Design points to discuss

Discuss queue fairness, copy ownership, branch transfers, hold expiry, and consistency between search and circulation records.

Problem brief

Allow tickets to be securely resold through partner platforms.

Core requirements

• Verify ticket ownership.
• Transfer a ticket and invalidate the old admission token.

Design points to discuss

Discuss idempotent partner APIs, concurrent resale attempts, barcode revocation, and failure recovery across organizations.

Problem brief

Select popular products through user voting.

Core requirements

• Record votes and show counts.
• Close voting and determine eligible winners.

Design points to discuss

Discuss duplicate votes, abuse prevention, hot counters, eventual display consistency, and authoritative results at closing time.

Problem brief

Notify customers when previously unavailable bookings open.

Core requirements

• Join or leave a date-specific waitlist.
• Offer released capacity to eligible users.

Design points to discuss

Discuss fairness, notification fan-out, offer expiration, overlapping date ranges, and atomically claiming availability.

Problem brief

Build an airline reservation service.

Core requirements

• Search itineraries and fares.
• Hold seats, issue tickets, and manage cancellations.

Design points to discuss

Discuss external inventory systems, multi-leg reservations, fare expiry, idempotent payments, and compensating failed bookings.

Problem brief

Deliver goods from nearby local warehouses.

Core requirements

• Show location-specific stock.
• Place orders and dispatch deliveries.

Design points to discuss

Discuss inventory reservations, geographic service boundaries, order state, delivery assignment, and stock changes during checkout.

Problem brief

Run auctions with a defined closing time.

Core requirements

• Accept bids and stream the current price.
• Select a winner and initiate settlement.

Design points to discuss

Discuss bid ordering, concurrent bids, authoritative clocks, closing rules, idempotency, and hot-item partitioning.

Problem brief

Track product prices over time and alert users.

Core requirements

• Collect prices from multiple merchants.
• Serve history and trigger threshold alerts.

Design points to discuss

Discuss crawl scheduling, product identity, stale quotes, time-series storage, alert deduplication, and vendor rate limits.

Problem brief

Sell scarce inventory during a sudden traffic spike.

Core requirements

• Admit purchase attempts fairly.
• Reserve stock and confirm paid orders.

Design points to discuss

Discuss waiting rooms, hot counters, atomic reservations, hold expiry, duplicate requests, and payment recovery without overselling.

Problem brief

Design an online shopping platform with a focused purchase path.

Core requirements

• Browse and search a catalog.
• Manage carts, orders, and checkout.

Design points to discuss

Discuss service boundaries, stock reservations, pricing snapshots, payment workflow, and eventual consistency of search indexes.

Problem brief

Connect riders with nearby drivers.

Core requirements

• Request and dispatch rides.
• Track trips and calculate fares.

Design points to discuss

Discuss location ingestion, spatial matching, race-free driver assignment, trip state transitions, and region-based scaling.

Problem brief

Build a short-stay accommodation marketplace.

Core requirements

• Search listings and date availability.
• Reserve stays and coordinate payment.

Design points to discuss

Discuss calendar consistency, search indexing, host updates, booking holds, cancellations, and cross-service failure recovery.

Problem brief

Process payments through external providers.

Core requirements

• Create payment intents and track outcomes.
• Handle callbacks, refunds, and reconciliation.

Design points to discuss

Discuss idempotency keys, durable state transitions, uncertain provider outcomes, ledger separation, and retry-safe processing.

Problem brief

Track product stock across warehouses and sales channels.

Core requirements

• Receive inventory changes.
• Reserve, release, and transfer quantities.

Design points to discuss

Discuss authoritative stock ownership, duplicate events, concurrent reservations, reconciliation, and delayed downstream updates.

Problem brief

Store and display security-camera footage.

Core requirements

• View live streams.
• Retrieve recordings by camera and time.

Design points to discuss

Discuss stream ingestion, chunked object storage, retention, bandwidth, access control, and graceful recovery from camera outages.

Problem brief

Keep playback consistent across a user's devices.

Core requirements

• Publish active device and playback position.
• Transfer playback and apply remote controls.

Design points to discuss

Discuss session ownership, ordering, clock drift, stale devices, reconnect reconciliation, and conflicts between simultaneous commands.

Problem brief

Stream comments to viewers of a live broadcast.

Core requirements

• Accept comments and moderation actions.
• Deliver ordered updates to many viewers.

Design points to discuss

Discuss pub-sub fan-out, hot streams, backpressure, reconnect cursors, duplicate messages, and removal propagation.

Problem brief

Find the most popular videos within rolling time windows.

Core requirements

• Ingest view events.
• Query top items by time range.

Design points to discuss

Discuss stream aggregation, approximate versus exact ranking, late events, deduplication, and hot-key partitioning.

Problem brief

Deliver a subscription video catalog on demand.

Core requirements

• Ingest and transcode titles.
• Stream adaptive video to authorized viewers.

Design points to discuss

Discuss encoding pipelines, CDN placement, playback authorization, regional rights, and resilience to traffic spikes.

Problem brief

Serve user-uploaded video at large scale.

Core requirements

• Upload and process videos.
• Stream playback and expose video metadata.

Design points to discuss

Discuss resumable uploads, transcoding queues, object storage, CDN caching, moderation, and popularity skew.

Problem brief

Build a music streaming service.

Core requirements

• Search tracks and manage playlists.
• Stream audio and record listening activity.

Design points to discuss

Discuss catalog metadata, rights checks, CDN delivery, offline access, playlist consistency, and telemetry ingestion.

Problem brief

Provide real-time multi-party audio and video meetings.

Core requirements

• Join and leave rooms.
• Exchange media and meeting controls.

Design points to discuss

Compare peer-to-peer, SFU, and MCU designs; discuss latency, NAT traversal, bandwidth adaptation, and regional routing.

Problem brief

Build durable object storage accessed through bucket and object APIs.

Core requirements

• Upload and retrieve large objects.
• Manage versions, access policies, and deletion.

Design points to discuss

Discuss metadata versus blob storage, multipart uploads, checksums, replication or erasure coding, and consistency guarantees.

Problem brief

Store key-value records across multiple machines.

Core requirements

• Read, write, and delete durable values.
• Rebalance as nodes join or fail.

Design points to discuss

Discuss partitioning, replication, consistency, write-ahead logs, compaction, large values, and conflict resolution.

Problem brief

Separate warehouse storage from elastic query execution.

Core requirements

• Load large analytical datasets.
• Run concurrent SQL workloads.

Design points to discuss

Discuss columnar files, metadata catalogs, compute isolation, pruning, autoscaling, and recovery of failed query stages.

Problem brief

Run a managed low-latency analytical database.

Core requirements

• Ingest event streams.
• Execute aggregations over large tables.

Design points to discuss

Discuss sharding, replicas, columnar storage, metadata coordination, tenant isolation, and safe rolling upgrades.

Problem brief

Serve frequently accessed values with low latency across nodes.

Core requirements

• Get and set expiring entries.
• Add or remove cache capacity.

Design points to discuss

Discuss consistent hashing, replication, eviction, hot keys, cache stampedes, and behavior when a cache node disappears.

Problem brief

Store and organize user files at scale.

Core requirements

• Upload, download, and list files.
• Control sharing and deletion.

Design points to discuss

Discuss metadata indexing, blob storage, multipart transfers, quotas, authorization, and garbage collection of orphaned blobs.

Problem brief

Design a database around a declared query and transaction workload.

Core requirements

• Persist records and maintain indexes.
• Support reads, writes, and recovery.

Design points to discuss

Choose an execution and storage model; discuss isolation, logging, replication, failover, and how indexes affect write cost.

Problem brief

Deliver cached content from edge locations.

Core requirements

• Route users to nearby caches.
• Fetch origin content and invalidate stale copies.

Design points to discuss

Discuss cache keys, TTLs, eviction, request coalescing, origin protection, and regional outages.

Problem brief

Deliver event notifications to customer-owned HTTP endpoints.

Core requirements

• Register endpoint subscriptions.
• Send signed callbacks and expose delivery history.

Design points to discuss

Discuss retry schedules, idempotent consumers, endpoint failures, dead-letter handling, ordering, and tenant rate limits.

Problem brief

Publish online and activity status for users or devices.

Core requirements

• Track heartbeats and disconnects.
• Subscribe to presence updates.

Design points to discuss

Discuss leases, expiration, multi-device aggregation, eventual consistency, privacy, and reconnect storms.

Problem brief

Provide real-time conversations with durable history.

Core requirements

• Create conversations and send messages.
• Synchronize offline and connected clients.

Design points to discuss

Discuss persistent connections, sequence numbers, fan-out, delivery acknowledgements, and deduplicating retried sends.

Problem brief

Deliver messages through email, push, and SMS.

Core requirements

• Accept transactional and bulk requests.
• Honor preferences and expose delivery state.

Design points to discuss

Discuss priorities, per-channel queues, provider limits, retries, deduplication, and expiring time-sensitive notifications.

Problem brief

Operate an email service with mailboxes and delivery.

Core requirements

• Send and receive messages.
• Search folders and manage attachments.

Design points to discuss

Discuss message routing, durable queues, spam filtering, mailbox partitioning, attachment storage, and delivery retries.

Problem brief

Build a distributed event publication and subscription service.

Core requirements

• Publish records to topics.
• Let consumers track delivery progress.

Design points to discuss

Discuss partition ordering, durability, acknowledgements, replay, retention, consumer groups, and slow-consumer isolation.

Problem brief

Search social posts while respecting visibility.

Core requirements

• Index new and edited posts.
• Answer keyword and boolean queries.

Design points to discuss

Discuss inverted indexes, shard fan-out, ranking, freshness, deletions, and permission checks on returned documents.

Problem brief

Build a web search engine from crawling through retrieval.

Core requirements

• Discover and index pages.
• Return ranked results for text queries.

Design points to discuss

Discuss crawl scheduling, deduplication, inverted indexes, ranking stages, partitioning, and freshness versus cost.

Problem brief

Build a distributed full-text search and aggregation engine.

Core requirements

• Index documents and updates.
• Execute queries across shards.

Design points to discuss

Discuss analyzers, inverted indexes, shard routing, replicas, refresh lag, and consistency during reindexing.

Problem brief

Recommend relevant items to users.

Core requirements

• Collect interaction signals.
• Retrieve candidates and rank results.

Design points to discuss

Discuss offline versus online computation, cold starts, feedback loops, feature freshness, latency budgets, and evaluation.

Problem brief

Create short aliases that redirect to long URLs.

Core requirements

• Create and resolve aliases.
• Support expiration and optional custom aliases.

Design points to discuss

Discuss ID generation, collisions, read-heavy caching, hot links, abuse controls, and availability of redirects.

Problem brief

Offer an asynchronous service for solving crossword puzzles.

Core requirements

• Accept grids and clues.
• Return progress and a completed or unsatisfiable result.

Design points to discuss

Discuss work queues, bounded search budgets, cancellation, result caching, and isolation of expensive solver jobs.

Problem brief

Host real-time chess matches across devices.

Core requirements

• Match players and validate moves.
• Maintain clocks, reconnect state, and results.

Design points to discuss

Discuss authoritative game servers, per-game ordering, timeout handling, anti-cheat boundaries, and durable move logs.

Problem brief

Provide shared infrastructure for online game sessions.

Core requirements

• Authenticate players and create sessions.
• Manage game servers and persist results.

Design points to discuss

Discuss authoritative state, region placement, session recovery, cheating prevention, and resource allocation during demand spikes.

Problem brief

Maintain ranked scores for a large player population.

Core requirements

• Update scores and return top players.
• Show a player's rank and neighboring entries.

Design points to discuss

Discuss sorted indexes, tie-breaking, seasonal resets, sharding, hot leaderboards, and consistency of score updates.

Problem brief

Group players into suitable multiplayer sessions.

Core requirements

• Queue players by skill and constraints.
• Allocate a server after a match forms.

Design points to discuss

Discuss fairness versus waiting time, expanding search ranges, queue ownership, cancellations, and failed server assignments.

Problem brief

Analyze gameplay and product behavior.

Core requirements

• Collect gameplay events.
• Serve engagement and performance dashboards.

Design points to discuss

Discuss schemas, event deduplication, late data, streaming versus batch processing, retention, and privacy controls.

Problem brief

Change application behavior without redeploying code.

Core requirements

• Manage flags and targeting rules.
• Evaluate flags with low latency.

Design points to discuss

Discuss local SDK caches, deterministic percentage rollout, configuration propagation, fallback defaults, and audit history.

Problem brief

Block requests from disallowed entities across regions.

Core requirements

• Publish versioned blocking rules.
• Evaluate users, addresses, or networks locally.

Design points to discuss

Discuss propagation lag, IPv4/IPv6 ranges, lookup indexes, regional rules, signed updates, and fail-open versus fail-closed policy.

Problem brief

Collect host telemetry without disrupting applications.

Core requirements

• Sample resource metrics periodically.
• Buffer and transmit batches.

Design points to discuss

Discuss bounded CPU and memory, collection failures, backpressure, offline buffering, upgrades, and fleet configuration.

Problem brief

Assign ready virtual machines quickly despite slow provisioning.

Core requirements

• Maintain warm capacity pools.
• Allocate and release VM groups.

Design points to discuss

Discuss leases, inventory reconciliation, autoscaling, noisy tenants, placement constraints, and leaked resources after failures.

Problem brief

Provide isolated cloud development workspaces.

Core requirements

• Create environments from templates.
• Persist work and reconnect sessions.

Design points to discuss

Discuss container or VM isolation, secrets, storage, startup latency, idle shutdown, quotas, and region placement.

Problem brief

Move existing infrastructure to the cloud with controlled cutover.

Core requirements

• Inventory dependencies and migrate workloads.
• Validate and switch production traffic.

Design points to discuss

Discuss migration waves, network connectivity, data synchronization, rollback checkpoints, and verification before decommissioning.

Problem brief

Run submitted code safely and score it.

Core requirements

• Accept language-specific submissions.
• Execute test cases and update contest rankings.

Design points to discuss

Discuss sandboxes, resource limits, job queues, deterministic environments, abuse prevention, and duplicate judging requests.

Problem brief

Execute repository workflows triggered by events.

Core requirements

• Parse workflow DAGs and run dependent jobs.
• Store logs, artifacts, and status.

Design points to discuss

Discuss runner isolation, secrets, caching, cancellation, retries, untrusted pull requests, and fair capacity sharing.

Problem brief

Enforce request quotas across a distributed application.

Core requirements

• Apply per-client and global limits.
• Return admission decisions quickly.

Design points to discuss

Compare centralized counters and local quotas; discuss atomicity, window boundaries, clock issues, and availability trade-offs.

Problem brief

Discover and process web pages starting from seed URLs.

Core requirements

• Fetch pages and extract links.
• Avoid revisiting equivalent URLs.

Design points to discuss

Discuss URL normalization, robots policies, per-host politeness, frontier partitioning, retries, and crawl traps.

Problem brief

Execute scheduled and immediate jobs reliably.

Core requirements

• Register schedules and dispatch due jobs.
• Retry failures and retain execution history.

Design points to discuss

Discuss durable scheduling, worker leases, duplicate execution, idempotent jobs, timing precision, and partitioning hot queues.

Problem brief

Route and protect requests at a common entry point.

Core requirements

• Authenticate and route requests.
• Apply throttling and observability.

Design points to discuss

Discuss routing updates, load balancing, timeouts, retries, circuit breakers, and avoiding a single point of failure.

Problem brief

Collect searchable logs from many services.

Core requirements

• Ingest structured records.
• Search by service, time, and correlation ID.

Design points to discuss

Discuss buffering, partitioning, indexing cost, retention tiers, backpressure, and ingestion failures.

Problem brief

Observe system health and notify operators.

Core requirements

• Collect metrics and query dashboards.
• Evaluate alert rules continuously.

Design points to discuss

Discuss time-series storage, label cardinality, aggregation, late samples, missing data, and alert deduplication.

Problem brief

Generate unique identifiers across independent servers.

Core requirements

• Issue IDs at high throughput.
• Operate through node failures.

Design points to discuss

Compare random, coordinated, and time-based IDs; discuss ordering guarantees, clock rollback, node identity, and collision risk.

Problem brief

Build shared calendars across users and devices.

Core requirements

• Create recurring events and invitations.
• Synchronize edits and send reminders.

Design points to discuss

Discuss time zones, recurrence expansion, conflict handling, notification scheduling, and offline synchronization.

Problem brief

Route and resolve support requests across channels.

Core requirements

• Create tickets from email or chat.
• Assign agents and track SLA deadlines.

Design points to discuss

Discuss durable intake, duplicate conversations, assignment ownership, priority queues, search, and live-chat latency.

Problem brief

Allow multiple users to edit the same document simultaneously.

Core requirements

• Synchronize edits and presence.
• Persist history and share documents.

Design points to discuss

Compare operational transformation and CRDTs; discuss ordering, offline edits, snapshots, permissions, and large documents.

Problem brief

Synchronize files across devices through cloud storage.

Core requirements

• Upload deltas and download changes.
• Share files and recover versions.

Design points to discuss

Discuss chunking, content hashes, metadata consistency, change feeds, conflict resolution, and resumable transfers.

Problem brief

Provide workspace messaging for organizations.

Core requirements

• Create channels and threads.
• Search history and deliver notifications.

Design points to discuss

Discuss tenant isolation, channel fan-out, message ordering, persistent connections, search lag, and access revocation.

Problem brief

Coordinate shared boards with cards and task lists.

Core requirements

• Move and edit cards.
• Assign users and synchronize updates.

Design points to discuss

Discuss ordering keys, optimistic concurrency, activity logs, permissions, and reconnecting clients after missed events.

Problem brief

Find eligible healthcare providers and available appointments.

Core requirements

• Filter by specialty and licensing region.
• Show availability and reserve a slot.

Design points to discuss

Discuss sensitive data boundaries, index freshness, external calendars, timezone handling, and avoiding double bookings.

Problem brief

Manage a fleet of rentable bicycles.

Core requirements

• Find and unlock a bike.
• Track a trip and process its return.

Design points to discuss

Discuss device connectivity, ride leases, GPS ingestion, billing, station inventory, and recovery from offline locks.

Problem brief

Visualize where drivers are concentrated in near real time.

Core requirements

• Ingest driver locations.
• Aggregate counts into map cells.

Design points to discuss

Discuss geospatial tiling, window expiry, stale drivers, zoom levels, privacy, and hot-city partitions.

Problem brief

Find suitable parking garages near a driver.

Core requirements

• Search by proximity and constraints.
• Show current capacity and ratings.

Design points to discuss

Discuss sensor update freshness, geospatial indexes, stale availability, cache invalidation, and optional reservations.

Problem brief

Review individual food items after a purchase.

Core requirements

• Create reviews and votes.
• Compute rewards under a defined policy.

Design points to discuss

Discuss order verification, duplicate votes, abuse detection, media storage, ranking, and auditable reward calculations.

Problem brief

Provide maps, routing, and traffic-aware navigation.

Core requirements

• Search places and calculate routes.
• Incorporate road and traffic updates.

Design points to discuss

Discuss map tiles, graph partitioning, preprocessing, live traffic overlays, geospatial search, and offline clients.

Problem brief

Find nearby businesses that match user filters.

Core requirements

• Index business locations.
• Return ranked results within a radius.

Design points to discuss

Discuss geohashes or spatial trees, dense regions, query expansion, ranking, and freshness of business information.

Problem brief

Track moving vehicles for riders and dispatchers.

Core requirements

• Ingest location updates.
• Stream the latest position to authorized viewers.

Design points to discuss

Discuss sampling, spatial partitioning, out-of-order updates, stale data, connection fan-out, and retention of trip history.

Problem brief

Process disputed card transactions through external networks.

Core requirements

• Accept disputes and collect evidence.
• Build and transmit network-specific batches.

Design points to discuss

Discuss deduplication, filing deadlines, durable workflow state, batch size limits, acknowledgements, and reconciliation.

Problem brief

Maintain an auditable record of monetary movements.

Core requirements

• Append balanced transaction entries.
• Query balances and transaction history.

Design points to discuss

Discuss double-entry invariants, immutable records, idempotency, concurrent updates, reconciliation, and derived balance views.

Problem brief

Operate a digital-asset trading exchange.

Core requirements

• Accept and match orders.
• Manage account balances and market data.

Design points to discuss

Discuss matching-engine partitioning, deterministic order sequencing, custody boundaries, ledger consistency, and recovery logs.

Problem brief

Alert users when market prices cross thresholds.

Core requirements

• Ingest a price feed.
• Evaluate subscriptions and send alerts.

Design points to discuss

Discuss indexing subscriptions by symbol and threshold, hot symbols, duplicate ticks, stale feeds, and repeated crossing rules.

Problem brief

Serve accounts and banking transactions reliably.

Core requirements

• Manage accounts and transfers.
• Expose balances and transaction history.

Design points to discuss

Discuss ledger ownership, strong invariants, authentication, idempotency, reconciliation, and availability during peak transaction periods.

Problem brief

Provide travel-triggered insurance coverage.

Core requirements

• Manage policies and detect eligible travel.
• Activate coverage and process claims.

Design points to discuss

Discuss uncertain location signals, policy versioning, event ordering, durable workflows, and auditable decisions.

Problem brief

Transfer funds at a future time.

Core requirements

• Create or cancel a scheduled transfer.
• Execute eligible transfers once due.

Design points to discuss

Discuss reservation versus balance-at-execution checks, idempotent ledger operations, overdue jobs, retries, and cancellation races.

Problem brief

Choose an advertisement through a time-bounded auction.

Core requirements

• Request bids from advertisers.
• Select and serve an eligible winning ad.

Design points to discuss

Discuss strict latency budgets, partial bidder failures, targeting caches, budget enforcement, and impression/click attribution.

Problem brief

Manage creative assets for advertising campaigns.

Core requirements

• Upload assets individually or in bulk.
• Validate and publish usable versions.

Design points to discuss

Discuss asynchronous scanning, object storage, job status, quotas, invalid assets, and safe activation of updated creatives.

Problem brief

Generate official and custom financial statements.

Core requirements

• Build monthly statements.
• Serve user-selected date ranges and categories.

Design points to discuss

Discuss immutable billing snapshots, asynchronous document generation, secure storage, access control, and reproducible totals.

Problem brief

Keep advertising spend within campaign budgets.

Core requirements

• Allocate budgets and record billable events.
• Pause or limit campaigns as funds run low.

Design points to discuss

Discuss reservation versus final charging, duplicate events, regional allocation, overspend tolerance, and reconciliation.

Problem brief

Accept check deposits from mobile photographs.

Core requirements

• Upload images and extract fields.
• Validate externally and update deposit status.

Design points to discuss

Discuss duplicate-check detection, asynchronous processing, provisional credit, durable workflows, image retention, and external failures.

Problem brief

Bill customers for recurring products.

Core requirements

• Track subscriptions and usage.
• Issue invoices and process renewals.

Design points to discuss

Discuss plan versioning, proration, billing periods, failed payments, idempotency, and immutable invoice totals.

Problem brief

Coordinate banking operations from a fleet of ATMs.

Core requirements

• Authorize withdrawals and deposits.
• Track terminal cash and transaction outcomes.

Design points to discuss

Discuss disconnected terminals, dispense-before-confirm failures, reversals, reconciliation, authentication, and cash replenishment.

Problem brief

Convert GPU usage events into defensible charges.

Core requirements

• Meter usage by customer and resource.
• Show spend and issue invoices.

Design points to discuss

Discuss event-time aggregation, late records, pricing versions, deduplication, corrections, and reconciling usage with resource allocation.

Problem brief

Provide brokerage accounts backed by an external exchange.

Core requirements

• Validate and submit orders.
• Track executions, positions, and available funds.

Design points to discuss

Discuss order state machines, partial fills, buying-power reservations, market data, cancellation races, and reconciliation.

Problem brief

Collect donations during a short high-traffic campaign.

Core requirements

• Accept donations to approved charities.
• Track payment outcomes and receipts.

Design points to discuss

Discuss payment-provider outages, retries, duplicate charges, campaign deadlines, reconciliation, and burst capacity.

Problem brief

Match buy and sell orders on an exchange.

Core requirements

• Accept and cancel orders.
• Execute trades according to price-time priority.

Design points to discuss

Discuss deterministic sequencing, order books, durable journals, per-symbol partitioning, market data, and failover without duplicate trades.

Problem brief

Count advertising events for reporting and billing.

Core requirements

• Ingest clicks and impressions.
• Query aggregates by campaign and time.

Design points to discuss

Discuss deduplication, event-time windows, late arrivals, stream checkpoints, exact billing totals, and historical retention.

Problem brief

Assess potentially fraudulent activity in time to act.

Core requirements

• Collect transaction and behavior signals.
• Return a risk decision and record outcomes.

Design points to discuss

Discuss feature freshness, latency, rules versus models, false positives, fallback behavior, and feedback from investigations.

Problem brief

Maintain user wallets and money transfers.

Core requirements

• Add funds, pay, and transfer.
• Show balances and history.

Design points to discuss

Discuss ledger entries, atomic debits and credits, idempotency, concurrent spending, payment-provider reconciliation, and reversals.

Problem brief

Aggregate articles into personalized news feeds.

Core requirements

• Collect and normalize sources.
• Group related stories and serve subscriptions.

Design points to discuss

Discuss deduplication, ingestion scheduling, ranking, publication freshness, source failures, and read-heavy caching.

Problem brief

Assemble a personalized stream of social updates.

Core requirements

• Record posts and relationships.
• Retrieve a paginated feed.

Design points to discuss

Discuss fan-out strategies, ranking, celebrity accounts, stable pagination, and propagation of deleted or restricted content.

Problem brief

Return suggestions as a user types.

Core requirements

• Match prefixes with low latency.
• Rank and refresh popular suggestions.

Design points to discuss

Discuss prefix indexes, caching, personalization, stale rankings, language normalization, and suppression of unsafe or private terms.

Problem brief

Sell event tickets under concentrated demand.

Core requirements

• Browse events and select inventory.
• Hold seats and confirm payment.

Design points to discuss

Discuss admission queues, per-event partitioning, atomic seat claims, expiring holds, payment retries, and bot resistance.

Problem brief

Generate videos asynchronously from user prompts.

Core requirements

• Submit generation jobs and expose progress.
• Store outputs and notify clients.

Design points to discuss

Discuss GPU scheduling, quotas, long-running jobs, cancellation, retries, content checks, and large output delivery.

Problem brief

Batch inference requests to improve compute utilization.

Core requirements

• Queue individual requests.
• Build compatible batches and route results to callers.

Design points to discuss

Discuss batch size versus latency, deadlines, fairness, cancellation, model compatibility, and handling partial failures.

Problem brief

Distribute very large model artifacts to many servers.

Core requirements

• Publish versioned artifacts.
• Transfer and verify each replica.

Design points to discuss

Compare direct downloads, peer distribution, and hierarchical fan-out; discuss checksums, resumable chunks, bandwidth limits, and rollout control.

Problem brief

Run autonomous agents that execute multi-step workflows.

Core requirements

• Create versioned agent definitions.
• Schedule tool calls and expose execution state.

Design points to discuss

Discuss durable checkpoints, tool permissions, sandboxing, retries, budgets, human approval points, and preventing repeated side effects.

Problem brief

Turn natural-language requests into music playlists.

Core requirements

• Interpret user preferences.
• Retrieve eligible tracks and return an ordered playlist.

Design points to discuss

Discuss model orchestration, catalog grounding, personalization, rights filtering, latency, and handling ambiguous or unavailable requests.

Problem brief

Route inference calls across model providers.

Core requirements

• Enforce organization policies.
• Track usage, latency, and quality signals.

Design points to discuss

Discuss provider selection, timeouts, streaming, fallback compatibility, cost limits, sensitive data routing, and duplicate requests.

Problem brief

Let users experiment with prompts and models.

Core requirements

• Version prompts and parameters.
• Run comparisons and save outputs.

Design points to discuss

Discuss execution isolation, provider adapters, streaming, quotas, reproducibility, secrets, and access to shared experiments.

Problem brief

Measure an AI chat application's behavior and reliability.

Core requirements

• Collect usage and operational events.
• Serve product and support dashboards.

Design points to discuss

Discuss event schemas, tenant isolation, near-real-time aggregation, sensitive prompt handling, retention, and consistent metric definitions.

Problem brief

Build a conversational interface backed by language models.

Core requirements

• Manage chat threads and stream responses.
• Persist history and enforce usage limits.

Design points to discuss

Discuss inference routing, token budgets, cancellation, retries after partial output, context management, and model capacity.

Problem brief

Ingest large files and turn them into usable data.

Core requirements

• Accept uploads and validate content.
• Process asynchronously with visible status.

Design points to discuss

Discuss resumable transfer, checksums, schema validation, idempotent stages, poisoned files, and backpressure.

Problem brief

Process meeting recordings into downstream artifacts.

Core requirements

• Fetch recordings and run processing stages.
• Publish outputs with traceable status.

Design points to discuss

Discuss external API limits, large blobs, DAG scheduling, retries, duplicate notifications, and authorization of recordings and outputs.

Problem brief

Move a live application from SQL to NoSQL storage.

Core requirements

• Backfill historical data.
• Replicate ongoing changes and cut over reads.

Design points to discuss

Discuss schema mapping, change capture, ordering, verification, rollback, and keeping service available during migration.

Problem brief

Move large datasets into cloud storage or databases.

Core requirements

• Plan transfer jobs and execute chunks.
• Track progress and validate results.

Design points to discuss

Discuss incremental sync, resumability, bandwidth limits, checksums, credentials, and partial-transfer recovery.

Problem brief

Preserve the provenance of digital evidence.

Core requirements

• Record every evidence action.
• Verify integrity and retrieve a complete audit trail.

Design points to discuss

Discuss append-only storage, signatures or hashes, reliable event capture, access controls, time ordering, and retention policies.

Problem brief

Compare flight offers from external providers.

Core requirements

• Search itineraries and prices.
• Return results within a bounded response time.

Design points to discuss

Discuss expensive vendor APIs, cache freshness, request coalescing, partial responses, quote expiry, and supplier failure isolation.

Problem brief

Expose flight pricing to multiple external vendors.

Core requirements

• Serve current fare quotes.
• Apply access limits and pricing policies.

Design points to discuss

Discuss consistent price versions, quote validity, caching, fairness across clients, security, and separation of quotation from booking.