# Message queues in plain words

> A queue lets one part of a system hand work to another without waiting for it. What that buys you, what it costs, and the words that come with it: worker, acknowledge, dead letter.

Source: https://hintvo.com/blog/message-queues-in-plain-words | Last updated: November 20, 2026 | Reviewed: 2026-11-20

A message queue is a list of jobs that one part of a system writes to and another part works through. The part that adds a job does not wait for it to be done. That is the whole idea, and both the benefits and the problems follow from it.

## Why hand work to a queue

- **The user does not wait.** Checkout returns at once, and the receipt email is sent a second later.
- **A slow or broken dependency does not block you.** If the email service is down, the jobs wait in the queue.
- **Bursts get smoothed out.** A thousand orders in a minute become a steady stream the workers can handle.
- **Failed work can be tried again** without the user doing anything.

## The words

| Word | Meaning |
| --- | --- |
| Producer | The code that adds a job to the queue |
| Consumer or worker | The code that takes a job and does it |
| Acknowledge | The worker telling the queue that the job is done and can be removed |
| Retry | Putting a failed job back to be tried again |
| Dead letter queue | Where jobs go after they have failed too many times |

## What it costs

- **The answer comes later.** The user is told the order was received, not that it succeeded. The product has to deal with that.
- **Jobs can run twice.** Most queues promise that a job is delivered at least once, not exactly once. Workers have to be safe to repeat. See [idempotency](https://hintvo.com/blog/idempotency-in-plain-words).
- **Order is not kept** unless you ask for it and pay the price in speed.
- **Failures are quiet.** A job that keeps failing shows an error page to nobody. Someone has to watch the failed jobs.

## When you do not need one

If the work is fast and the user needs the result now, call the function. A queue adds a moving part, a place for jobs to get stuck, and a delay. It earns its place when the work is slow, unreliable or arrives in bursts.

## Questions you will hear in a meeting

- What happens to a job that fails?
- How many times is it retried, and where does it go after that?
- Is the worker safe to run twice on the same job?
- How would we notice that the queue is growing?

## In an interview

Put a queue between two parts of a design and you will be asked what happens when the worker crashes in the middle of a job. The answer: the job was not acknowledged, so it is delivered again, which is why the work has to be idempotent.

> **Where Hintvo fits:** when a term like this comes up in a call, the In plain words card explains it in one sentence, in the context of your project. When someone asks how your own code handles it, the answer names the file and line. The sample meeting on the [home page](https://hintvo.com/#replay) reads the queue consumer of a small demo project and finds that a failed job is never retried.

## Related

- [Retries and backoff in plain words](https://hintvo.com/blog/retries-and-backoff-in-plain-words.md): What are retries and exponential backoff, in plain words?
- [Idempotency in plain words: why a retry must not charge twice](https://hintvo.com/blog/idempotency-in-plain-words.md): What does idempotency mean, in plain words?
- [System design interviews: a structure that holds when you are nervous](https://hintvo.com/blog/system-design-interview-structure.md): How do I structure a system design interview?
