# Aggregate Tactic

**In short:** The aggregate tactic follows the bulk idea: handle many items in one operation instead of one by one. At service level, the same idea appears as a request bundle. It is unrelated to the DDD aggregate and the Aggregator pattern.

## Explanation

The aggregate tactic belongs to usability work (see the article "Usability Tactic"). It rests on the bulk, or batch, idea: one operation covers many items.

**The same idea at service level.** Services use the Request Bundle pattern for this. It packs several independent requests into one message. The goal is fewer requests and responses, which makes communication more efficient. That efficiency is the performance side of bulk operations.

**Link to the Command pattern.** Each item in a bundle is a command in the sense of the Command pattern. So batch execution can be seen as running a list of commands.

**Neighbors in the same family.** Users need to correct mistakes or backtrack. That is why undo sits next to cancel and aggregate. Cancel should be easy to find and quick to use. This matters most for long-running bulk work, such as a large download.

**Two names to keep apart.**
- A DDD aggregate is a cluster of domain objects treated as one unit. It is a modeling concept, not a user-facing group operation. See the article "Aggregate".
- The Aggregator is an integration pattern. It is a stateful message filter that correlates related messages and combines them into one. It has nothing to do with this tactic.

## Example

A support team wants to close 200 resolved tickets. The interface lets them select all 200 and apply one "close" action. The backend accepts one message that holds 200 close requests instead of 200 separate messages. A progress view shows the run and offers a clear Cancel button.

## Trade-offs

Bundling cuts the number of messages, which helps communication efficiency. Long bulk runs raise the need for a quick, visible cancel. Users also need a way to backtrack after mistakes, so plan undo together with bulk actions.



## Checks

- Where a service offers bulk operations, the API bundles several independent requests into one message to reduce round trips.
- Long-running bulk operations offer a Cancel option that is easy to find and quick to use.
- Bulk operations have an undo or other way to correct mistakes.
- The document does not confuse the user-facing aggregate tactic with the DDD aggregate or the Aggregator integration pattern.

## Related

- [Usability Tactic](https://arc.fuet.ch/concepts/tactics/usability-tactics.md)
- [Usability](https://arc.fuet.ch/concepts/quality-attributes/usability.md)
- [Architectural Tactic](https://arc.fuet.ch/concepts/tactics/architectural-tactic.md)
- [Aggregate](https://arc.fuet.ch/concepts/domain-driven-design/aggregate.md)
- [Patterns for API Design](https://arc.fuet.ch/concepts/integration/patterns-for-api-design.md)
- [Enterprise Integration Patterns](https://arc.fuet.ch/concepts/integration/messaging-pattern-language.md)
- [Performance Tactic](https://arc.fuet.ch/concepts/tactics/performance-tactics.md)

## Sources

- [Request Bundle](https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/RequestBundle.html) — microservice-api-patterns.org, accessed 2026-11-09
- [D D D_ Aggregate](https://martinfowler.com/bliki/DDD_Aggregate.html) — martinfowler.com, accessed 2026-11-09
- [Aggregator - Enterprise Integration Patterns](https://www.enterpriseintegrationpatterns.com/patterns/messaging/Aggregator.html) — enterpriseintegrationpatterns.com, accessed 2026-11-09
- [User Control and Freedom (Usability Heuristic #3) - NN/G](https://www.nngroup.com/articles/user-control-and-freedom/) — nngroup.com, accessed 2026-11-09