Design a system that schedules a job to execute X seconds in the future (LLD). Define APIs (e.g., schedule(job, delaySeconds) -> jobId, cancel(jobId)), data structures (e.g., time wheel, min-heap by due time), persistence for durability, worker execution model, handling of restarts and clock drift, idempotency/exactly-once vs at-least-once semantics, concurrency limits, and time complexity. Provide class diagrams and discuss how you would test it.

This question evaluates system design and distributed-systems competencies, including scheduling algorithms, durable persistence and recovery, concurrency control, delivery semantics, and operational concerns, and it belongs to the System Design category.

How do I approach System Design interview questions?

System Design questions require understanding of core concepts and practice. PracHub provides solutions with explanations to help you master system design interviews.

What difficulty level is this interview question?

This is a hard difficulty System Design question, commonly asked during Onsite rounds at Amazon.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Amazon during technical interviews.

Design delayed job scheduler (LLD) | Amazon Interview Question

Design a Delayed Job Scheduler (LLD)

Design a service that schedules a job to execute X seconds in the future with second-level accuracy. Produce a low-level design that covers APIs, data structures, persistence, execution model, and operational concerns.

Assume:

Second-level precision is sufficient.
The system must survive process restarts without losing scheduled jobs.
At-least-once delivery is acceptable by default; discuss options for exactly-once.

Requirements

APIs
- schedule(job, delaySeconds) -> jobId
- scheduleAt(job, epochMillis) -> jobId
- cancel(jobId) -> success/failure
- getStatus(jobId) -> job metadata
- Optional: reschedule(jobId, newDelaySeconds)
Data structures: propose and justify (e.g., min-heap by due time, timing wheel, or hybrid) including time/space complexity.
Persistence and durability: how jobs are durably stored and recovered after restarts/crashes.
Worker execution model: how jobs are dispatched and executed; leasing/ack model.
Restarts and clock drift: recovery logic and timekeeping choices.
Delivery semantics: idempotency, at-least-once vs exactly-once trade-offs.
Concurrency limits: global and per-tenant limits; fairness.
Time complexity: for schedule, cancel, due job retrieval.
Class diagrams: main classes, relationships, and key methods.
Testing: strategy across unit, integration, reliability, and performance.

Design a Delayed Job Scheduler (LLD)

Assume:

Second-level precision is sufficient.

The system must survive process restarts without losing scheduled jobs.

At-least-once delivery is acceptable by default; discuss options for exactly-once.

Requirements

APIs

schedule(job, delaySeconds) -> jobId
scheduleAt(job, epochMillis) -> jobId
cancel(jobId) -> success/failure
getStatus(jobId) -> job metadata
Optional: reschedule(jobId, newDelaySeconds)

Data structures: propose and justify (e.g., min-heap by due time, timing wheel, or hybrid) including time/space complexity.

Persistence and durability: how jobs are durably stored and recovered after restarts/crashes.

Worker execution model: how jobs are dispatched and executed; leasing/ack model.

Restarts and clock drift: recovery logic and timekeeping choices.

Delivery semantics: idempotency, at-least-once vs exactly-once trade-offs.

Concurrency limits: global and per-tenant limits; fairness.

Time complexity: for schedule, cancel, due job retrieval.

Class diagrams: main classes, relationships, and key methods.

Testing: strategy across unit, integration, reliability, and performance.

Design delayed job scheduler (LLD)

Quick Overview

Design a Delayed Job Scheduler (LLD)

Solution

Comments (0)

Design delayed job scheduler (LLD)

Quick Overview

Design a Delayed Job Scheduler (LLD)

Solution

Comments (0)