Event-Driven Architecture with Kafka: Drop Sync Calls

In this chapter

Stop calling another service on every request

What breaks

Checkout calls CustomerService for the address on every order. When that service is down, checkout fails too.

Three ways to respond

• More retries, longer timeout: Checkout still waits on the other service.
• Publish changes, keep a local copy: Checkout reads its own copy. No live call. (the fix)
• Share one database table: Now both services are tied together.

The fix: Publish changes, keep a local copy

Events let services run independently. The trade-off: data can be a few moments stale (eventual consistency).

Remember: Publish facts. Keep what you need locally.

More on Basics problems

• Kafka vs a Message Queue: Why Events Stay After Reading
• Kafka Topics vs Partitions and Message Keys Explained
• Kafka Producer Batching: Async Send, linger.ms, batch.size
• Kafka Fan-Out: One Event, Many Consumer Groups

Keep learning

• Previous: Kafka Producer Batching: Async Send, linger.ms, batch.size
• Next: Kafka Fan-Out: One Event, Many Consumer Groups
• All Kafka tutorial chapters

More courses

• Jobs, linked to lessons — Browse jobs where every requirement links to the chapter that teaches it. See how ready you are, how long the gap takes to close, and which listings look stale.
• Match a job post to courses — Paste a job post. Each skill is matched to a track here and put in learning order, foundations first.
• React from open source with patterns — Patterns extracted from Material UI, Radix, React Aria, React Hook Form, Redux Toolkit, TanStack, and Next.js — not slides about hooks.
• Database in depth — How a query becomes work. Indexes, isolation, locks, and the plans that explain why a page is slow — not an ORM tour.
• System Design — Core concepts first (SQL vs NoSQL, CAP, indexing, replication, sharding), then designs grouped by what carries them: the database, Redis, Kafka, or many services.
• Microservices — Microservice patterns one diagram at a time: how to split a monolith, how services talk, and how data stays consistent without distributed transactions.
• Frontend system design — How a UI is sliced when it is a product, not a page: ownership of state, cache, routes, and what happens when the network lies.
• TypeScript in depth — The type system as a design tool. Inference, narrowing, generics, and the errors that mean the model is wrong — not a catalog of utility types.
• CSS in depth — See the box, then the page. Visual chapters from the box model through Flexbox surprises, Grid, selectors, and units, then backgrounds, shapes, and visual effects, each with a playground.
• Accessibility — Foundations first (WCAG in plain words, semantic HTML, lists, alt text), then hands-on HTML labs, a full pass of WAI-ARIA 1.3, and a final fix-the-page challenge.
• Docker — What an image is, why layers cache, and how containers find each other on a network.
• Redis — Fifteen Redis patterns, one picture each: cache, session, lock, counter, rate limiter, queue, and when Redis is the wrong tool.