Event-Driven Architecture Explained
Instead of calling services directly, you publish facts and let interested parties react. This video explains the machinery that makes that work: events as immutable records, topics and partitions as the storage model, consumer groups as the processing model, and the broker as the thing that turns "publish once" into "deliver to many."
Topics covered:
- Events vs. commands: describing what happened vs. asking for something
- The broker's role: durable storage, ordering, and fan-out to multiple consumers
- Topics and partitions: how Kafka scales and what ordering guarantees exist
- Consumer groups: dividing partitions among workers and rebalancing on join
- At-least-once vs. at-most-once vs. exactly-once: what each guarantee costs
- Idempotency: why consumers must tolerate redelivery and design for it
- Event sourcing and CQRS as event-driven endgames
- When events are the wrong tool: request/reply flows and tight consistency needs
Related articles
Testing Strategies for Architecture: Pyramid, Trophy, and Contract Tests
Architecture decides test cost — the test pyramid vs the testing trophy, where contract tests fit between services, and why dependency structure determines how fast your suite runs.
Microservices Are a Cost, Not a Benefit
Every microservice multiplies pipelines, on-call surfaces, and coordination edges. Here is the operational cost math, when a monolith beats it, and how the strangler fig splits one.
Monolith First: Why Simple Beats Distributed
Before microservices made sense for anyone, they were a cost center pretending to be scale. A review of when a monolith is the right architecture — and when the call for services is actually a cry for discipline.
More in Software Architecture
The Strangler Fig Pattern
How to replace a legacy system without a rewrite — routing by path, strangling features incrementally, and keeping both systems honest.
DetailsDomain-Driven Design Basics
The core of DDD without the ceremony — ubiquitous language, bounded contexts, aggregates, and where the model boundary actually goes.
DetailsService Mesh Explained
What a service mesh actually does — sidecars, mTLS, traffic routing, and observability — and the network plumbing it takes off your plate.
DetailsFeature Flags in Practice
How feature flags work end to end — evaluation at runtime, kill switches, and canary rollouts — plus the operational discipline they demand.
DetailsThe Saga Pattern Explained
How distributed transactions work without distributed locks — saga steps, compensating actions, and the orchestration vs. choreography split.
DetailsCQRS Explained
Command query responsibility segregation — separate read and write models, why they diverge, and what you actually gain from the split.
DetailsAPI Gateway Patterns
What an API gateway actually does — routing, auth, rate limiting, and aggregation — and which patterns matter for your traffic.
DetailsHexagonal Architecture, Visualized
Ports and adapters in one diagram — how hexagonal architecture keeps business logic independent of databases, HTTP, and everything external.
DetailsMicroservices vs. Monolith
The honest engineering comparison — deployment boundaries, data ownership, failure domains, and the real costs of splitting a system.
DetailsDepth, delivered weekly
One technical dispatch a week — articles and episode notes before they go public.
One technical dispatch per week. No noise.