Design async job orchestration and notification service

Quick Overview

Design async job orchestration and notification service evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

Design async job orchestration and notification service

Company: Amazon

Role: Applied Scientist

Category: System Design

Difficulty: hard

Interview Round: Technical Screen

Design a service that accepts a list of parameters, uses an external asynchronous cluster API submit_job(params) -> job_uuid and check_job_status(job_uuid) -> ['SUBMITTED','RUNNING','SUCCEEDED','FAILED'], executes the jobs, and notifies the user when all jobs in the list have completed. Specify the architecture and components (ingest API, scheduler, worker pool, status tracker, persistent store, notification service). Detail the execution flow for fan-out submission, concurrency and rate limiting, retry/backoff and idempotency for submissions and status checks, persistence for crash recovery, handling of partial failures and retries for FAILED jobs, timeouts and detection of stuck jobs, deduplication, and cancellation. Explain how you would scale to millions of jobs and choose between polling versus event-driven callbacks if available. Define client- and server-side APIs, notification semantics (exactly-once vs at-least-once), and monitoring/alerting and observability.

Overview: Design async job orchestration and notification service evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

|Home/System Design/Amazon
Amazon logo
Amazon
Jul 15, 2025
hardApplied ScientistTechnical ScreenSystem Design
3
0

Design async job orchestration and notification service

System Design: Batch Orchestration Over an External Asynchronous Cluster

Context

You are designing a backend service that accepts a list of job parameters from clients, submits each job to an external asynchronous compute cluster, and notifies the client when all jobs complete. The external cluster exposes two APIs:

  • submit_job(params) -> job_uuid
  • check_job_status(job_uuid) -> one of ['SUBMITTED', 'RUNNING', 'SUCCEEDED', 'FAILED']

Assume the external API is eventually consistent, has rate limits, may transiently fail, and does not guarantee idempotency unless you add your own keys. The cluster may optionally support callbacks/webhooks on job completion; otherwise, you must poll.

Requirements

Design the service with the following components and details:

  1. Architecture and components
  • Ingest API
  • Scheduler
  • Worker pool (submitters and status pollers)
  • Status tracker and aggregator
  • Persistent store
  • Notification service
  1. Execution flow
  • Fan-out submission from a list of parameters
  • Concurrency control and rate limiting (per-tenant and global)
  • Retry, backoff with jitter, and idempotency for both submissions and status checks
  • Persistence for crash recovery and exactly-once-orchestrator semantics
  • Handling partial failures, including automatic retries for FAILED jobs based on policy
  • Timeouts and detection of stuck jobs (SUBMITTED/RUNNING too long)
  • Deduplication (same input re-sent by client or internally retried)
  • Cancellation (single job or entire batch)
  1. Scale and strategy
  • How to scale to millions of jobs and high QPS
  • Polling vs event-driven callbacks (if available): trade-offs and hybrid approach
  1. APIs and semantics
  • Define client-facing APIs and server-to-server APIs if applicable
  • Notification semantics (exactly-once vs at-least-once); integrity and dedup
  1. Operations
  • Monitoring, alerting, and observability (metrics, logs, traces; SLOs)

Keep the design practical and production-ready, with clear assumptions and trade-offs.

Clarifying Questions to Ask Guidance

  • Clarify users, core use cases, read/write patterns, scale, latency, availability, and data retention.
  • State explicit assumptions before making sizing or architecture decisions.
  • Prioritize the functional path first, then address reliability, security, observability, and rollout.

What a Strong Answer Covers Guidance

  • A scoped requirements summary with concrete non-goals and success metrics.
  • API, data model, architecture, consistency, capacity, and operations.
  • Reasoned trade-offs among simple and scalable designs, including bottlenecks and failure modes.
  • A validation, monitoring, migration, and launch plan appropriate for the risk level.

Follow-up Questions Guidance

  • What breaks first at 10x traffic or data volume?
  • How would you degrade gracefully during dependency failures?
  • What metrics and alerts would prove the design is healthy after launch?

Submit Your Answer to Earn 20XP

Sign in to leave a comment

Loading comments...