Automatic

Message brokers promise smooth data flow in distributed systems — but who's really holding the reins? This episode unpacks the control-vs-coordination split that determines whether your architecture scales cleanly or quietly turns into infrastructure spaghetti.

Show Notes

Distributed systems teams often celebrate the moment they wire up a message broker — and then spend months untangling what happened next. This episode of Automatic.co examines the nuanced power dynamic at the center of every brokered architecture: what the broker should own, what your services must own, and why blurring that line is one of the most common ways platforms quietly accrue technical debt. The discussion is grounded in the Automatic.co deep-dive on broker control vs. coordination, translating its frameworks into practical decision-making for engineering teams.

The episode walks through the full lifecycle of a message — from producer to broker to consumer — and surfaces the architectural choices that determine whether your system stays maintainable as it grows. Key topics include:

  • The control-vs-coordination distinction: Why brokers should handle guaranteed delivery and routing semantics, while business logic and decision-making must stay inside your services — and what it looks like when that boundary erodes.
  • Message contracts as a first-class lever: How clearly versioned, schema-backed contracts transform the broker from a liability into a reliable pipe, and why additive changes are the safest path forward.
  • Designing for idempotency over perfect ordering: The case for accepting at-least-once delivery as the practical default, writing create-or-update consumers, and using natural or idempotency keys to collapse duplicates rather than betting on message sequence.
  • Observability as an active control mechanism: Treating lag, throughput, error queues, and correlation identifiers not just as incident tools but as the feedback loop that makes real-time tuning possible.
  • Pattern selection and clean handoffs: When to reach for pub/sub, work queues, or event sourcing — and how each pattern draws a boundary between broker responsibility and service responsibility that keeps teams moving independently.
  • Red flags that your broker is running the show: Long-term business state stored in the broker, business rules encoded in routing keys, and consumers too fragile to handle duplicates or version changes.

The episode closes with a reminder that control in distributed systems isn't about locking down every moving part — it's about designing systems that handle messy reality gracefully, rather than ones that assume messiness never arrives. For more on a related failure mode in resilience planning, check out Why Your Failover Isn't Actually Failing Over.

Automatic.co

What is Automatic?

Agentic AI and automation from the perspective of whoever has to maintain it in six months. Where an agent genuinely belongs in a process, where a plain script is enough, how to design a handoff to a human, and what breaks quietly at scale.

Each episode takes one automation decision and reasons it through end to end — including the maintenance burden, the failure modes and the honest question of whether the process should exist at all. Written for operators and technical leads, deliberately free of hype. Five or six minutes an episode.

Topics include where an agent belongs versus a plain script, designing human handoffs, error handling and observability, maintenance burden, process mapping before automation, measuring what a workflow saves, and knowing when a process should be deleted instead.

Produced by Automatic.co, agentic AI and automation consulting. Full details, services and further reading at https://automatic.co