At-least-once delivery
At-least-once delivery is a messaging or processing guarantee that each message or record is delivered or processed one or more times, so duplicates may occur.
Kafka Streams in Action, Second Edition
At-least-once delivery is a processing guarantee that prevents loss of records but permits a record to be processed more than once.
- How it is used
- Uses Kafka producer retries and consumer offset commits to prevent record loss during failures.
- How deep it goes
- Explains producer and consumer failure paths, commit timing, and Java implementation, but stops short of duplicate-handling strategies.
- Examples
- Uses producer acknowledgment timeouts, consumer restarts, committed offsets, and process-then-commit Java code.
- What you can do after
- Diagnose/debug with it by identifying duplicate processing after failed commits and unsafe commits during asynchronous work.
Read how Kafka Streams in Action, Second Edition explains at-least-once delivery →
Akka in Action, Second Edition
At-least-once delivery is a processing guarantee in which records may be delivered or processed more than once because retries can repeat work.
- How it is used
- Uses committable Kafka sources and sinks to commit offsets only after records are processed, preventing message loss.
- How deep it goes
- Explains offset-carrying messages, batch commit settings, and draining shutdown through concrete stream pipelines.
- Examples
- Uses a Kafka test3-to-test4 forwarding stream and a failed A-to-B-to-C batch to illustrate duplicates.
- What you can do after
- Apply it via Akka Kafka to consume, transform, produce, and commit offsets in an at-least-once stream.
Read how Akka in Action, Second Edition explains at-least-once delivery →
C# Concurrency: Asynchronous and multithreaded programming
At-least-once delivery is a message-delivery guarantee that permits duplicates but ensures a message is delivered one or more times.
- How it is used
- Uses persistent queues to favor retaining important work over preventing duplicate processing after crashes.
- How deep it goes
- Explains removal timing, crash windows, delivery trade-offs, and poison-message loops without detailing queue-provider implementations.
- Examples
- Uses a mail merge, a lost confirmation, and a crash between processing and queue removal as concrete failure scenarios.
- What you can do after
- Operate persistent queues by selecting at-least-once delivery and planning monitoring for messages that repeatedly crash processing.
Apache Kafka in Action
At-least-once delivery is a message delivery guarantee that prevents message loss but permits duplicate delivery.
- How it is used
- Uses replicated acknowledgements to prioritize preventing message loss in Kafka applications.
- How deep it goes
- Explains configuration, acknowledgement loss, retries, and duplicates, then contrasts at-most-once and exactly-once guarantees.
- Examples
- Uses a lost-acknowledgement banking transaction and contrasts it with continuously produced temperature readings.
- What you can do after
- Operate/configure Kafka producers with acks=all and sufficient minimum in-sync replicas when duplicates are preferable to loss.
Read how Apache Kafka in Action explains at-least-once delivery →
Microservices Patterns, Second Edition
A message-delivery guarantee in which every message is delivered one or more times, permitting redelivery after failures.
- How it is used
- Sets a delivery requirement for message channels used in asynchronous service collaboration.
- How deep it goes
- Defines the guarantee as a channel requirement but does not detail its implementation or handling of duplicate deliveries.
- Examples
- Names ActiveMQ, RabbitMQ, Kafka, Kinesis, SQS, and SNS when comparing broker channel implementations.
- What you can do after
- Evaluate message-channel requirements before selecting a broker.
Read how Microservices Patterns, Second Edition explains at-least-once delivery →
Grokking Software Architecture
A messaging guarantee under which a message is delivered one or more times, allowing duplicates.
- How it is used
- Uses broker-level retries as a reliable delivery default for event-driven systems.
- How deep it goes
- Explains redelivery through acknowledgments and crashes, then points to consumer idempotency without detailing its implementation.
- Examples
- Uses a Shipping Service that may print a duplicate label after crashing before acknowledgment.
- What you can do after
- Apply it by acknowledging successful work and making consumers idempotent so retries do not repeat costly effects.
Read how Grokking Software Architecture explains at-least-once delivery →
Also covered in
- Think Distributed Systems
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
What to know first
- topicA topic is a named channel or category that groups messages or records for publication and delivery to interested consumers.
- acknowledgmentAn acknowledgment is a protocol message or signal confirming that transmitted data, a message, request, or operation was received or processed.
- Kafka producerA Kafka producer is an application or client that publishes records to Kafka topics.
- message brokerA message broker is intermediary software that receives, routes, and delivers messages between communicating components or systems.
Related concepts
- at-most-once deliverycontrasts with · At-most-once delivery is a messaging guarantee that each message is delivered no more than once, so messages may be lost but are not duplicated.
- Consumer.committableSourceproduced by · Consumer.committableSource is an Alpakka Kafka source that emits records together with committable offset information for at-least-once processing.
- idempotencyaddresses · Idempotency is the property of an operation whereby repeating it has the same effective result or externally observable effect as performing it once.
- message brokerproduced by · A message broker is intermediary software that receives, routes, and delivers messages between communicating components or systems.
- retryproduced by · A retry is a subsequent attempt to perform an operation after an earlier attempt fails or does not complete successfully.
Questions about at-least-once delivery
What is at-least-once delivery?
At-least-once delivery is a messaging or processing guarantee that each message or record is delivered or processed one or more times, so duplicates may occur.
Which Manning books explain at-least-once delivery?
Kafka Streams in Action, Second Edition, Akka in Action, Second Edition, C# Concurrency: Asynchronous and multithreaded programming, Apache Kafka in Action, Microservices Patterns, Second Edition and Grokking Software Architecture.
What should I know before learning at-least-once delivery?
Manning books that teach at-least-once delivery usually introduce topic, acknowledgment, Kafka producer and message broker first.
What is the difference between at-least-once delivery and at-most-once delivery?
At-least-once delivery is a messaging or processing guarantee that each message or record is delivered or processed one or more times, so duplicates may occur. At-most-once delivery is a messaging guarantee that each message is delivered no more than once, so messages may be lost but are not duplicated.
What is at-least-once delivery a kind of?
At-least-once delivery is a kind of delivery semantics. Delivery semantics are guarantees about whether and how often messages or records are delivered during processing.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.





