roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Celery interviews on how a task travels from the call to a worker and what happens when it fails. Covers brokers and routing, worker pools, retries and acks, canvas and beat.
115 of 115 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 115 new. 0 cut, outside your plan.
Celery rarely gets a round of its own. It surfaces in Python backend loops, most often when a technical conversation reaches the work a request should not do inline, such as sending an email, rendering a report or calling a slow partner API, and again in system design, once the answer puts a queue between the web tier and the workers. Teams that run large worker fleets for data or platform work may give it a whole conversation.
The early questions check the basic path: what delay() hands back to the caller, why a task that receives a model instance fails under the default JSON serializer, why a worker logs a task as unregistered. The harder ones are about duplicates and stalls. A task that charges a card is switched to late acknowledgement and then runs twice after a worker crash; a countdown longer than the Redis broker's visibility timeout fires a second copy; three containers that each embed beat in their worker bill every customer three times a night; a short task waits behind a long one because the busy worker had already reserved it. Naming the setting involved is the entry-level answer. What moves a candidate up is saying which delivery guarantee the configuration really gives, why the task has to be idempotent whatever the settings say, and what the fix costs in throughput or latency.
Before any Celery API, the plan sets out what a queue promises. Delivery guarantees frame the trade between losing a task and running it twice, idempotent consumers are how a handler survives running twice, several workers sharing one queue is the usual shape of a Celery deployment, and a dead-letter queue is where a message can be parked once its retries run out. Then comes the Python under the default worker: the GIL explains why CPU-bound tasks need separate processes, and multiprocessing explains what those processes cost, from pickled arguments to a child that dies mid-task.
Celery itself is taken in the order a task lives through it. Defining and calling tasks comes first, then the broker and result backend the message travels through and the queues it is routed to. Pools and prefetch describe what a worker does when the message arrives, and only with that picture in place do retries and acknowledgement make sense, because whether a crashed task runs again depends on when its message was acknowledged and how the broker redelivers it. Canvas and beat build on single tasks: one composes them into chains, groups and chords, the other starts them on a clock. Monitoring and shutdown follow, for watching, limiting and stopping a fleet that is already running.
The last two stretches step outside Celery's own API. The Django pair covers wiring a Celery app into a project and the commit hooks that hold a task back until the transaction that wrote its row has committed. The plan closes on job scheduling as a design problem, where missed runs, duplicate runs and dead workers return at the scale of a whole fleet.
Celery questions assume working Python, so a candidate still shaky on the language gains more from the [Python roadmap](/roadmaps/python) first. Preparing for a Django or FastAPI role that lists Celery among its requirements? Narrow level to the seniority on the posting and importance to must know; study order already opens on by frequency, so the questions asked most come first. Running workers in production, or aiming at a senior backend or platform role, calls for study by topics from the top instead: the senior questions on late acknowledgement, visibility timeouts and pool sizing are the opening module's ideas under Celery's setting names. What happens inside the broker is out of scope. The plan explains how Celery connects to RabbitMQ, Redis and SQS and what each transport trades away, but not how RabbitMQ routes a message through its exchange types or how Redis keeps data on disk. For the Redis side, the [Redis roadmap](/roadmaps/redis) picks up where this one ends.
Celery questions assume working Python, so a candidate still shaky on the language gains more from the Python roadmap first. Preparing for a Django or FastAPI role that lists Celery among its requirements? Narrow level to the seniority on the posting and importance to must know; study order already opens on by frequency, so the questions asked most come first. Running workers in production, or aiming at a senior backend or platform role, calls for study by topics from the top instead: the senior questions on late acknowledgement, visibility timeouts and pool sizing are the opening module's ideas under Celery's setting names.
What happens inside the broker is out of scope. The plan explains how Celery connects to RabbitMQ, Redis and SQS and what each transport trades away, but not how RabbitMQ routes a message through its exchange types or how Redis keeps data on disk. For the Redis side, the Redis roadmap picks up where this one ends.