Event-Driven Architecture in Software Development: From Doorbells to Distributed Systems

🛎 A Real-World Analogy: Ring My Bell

Let’s start with something familiar.

Imagine someone walks up to your house and rings your smart doorbell. Here's what happens:

You get a notification on your phone.
Your security camera starts recording.
Your dog barks.
Maybe your smart lights turn on at night.

All these actions happen because of the doorbell event, but they don’t depend on each other. They simply react to the event.

This is event-driven architecture: independent systems reacting to a central event.

🧠 What Is Event-Driven Architecture?

Event-Driven Architecture (EDA) is a software design pattern where components communicate by emitting and listening for events instead of calling each other directly.

In EDA:

Components are loosely coupled
Events are central
Communication is asynchronous

“An event is a significant change in state.”
– Like Order Placed, Payment Received, User Signed Up

Component	Description
Event Producer	Emits events when something happens (e.g., Order Service)
Event Broker	Transports events (e.g., Kafka, RabbitMQ, Redis)
Event Consumer	Event Consumer

You can plug in new consumers anytime without touching the producer. Super flexible.

Implementation with Kafka, Express, and React

Let’s build a basic order processing system using:

Express.js (backend API)
KafkaJS (Kafka client for Node.js)
MongoDB (data store)
React (frontend)

Step 1: Set Up Kafka Locally with Docker

# docker-compose.yml
version: '2'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181

  kafka:
    image: confluentinc/cp-kafka
    ports:
      - "9092:9092"
    environment:
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1

Step 2: Kafka Producer (Order Service)

// kafka.js
import { Kafka } from "kafkajs";

const kafka = new Kafka({
  clientId: "order-service",
  brokers: ["localhost:9092"],
});

export const producer = kafka.producer();
await producer.connect();

// routes/order.js
import express from "express";
import { producer } from "../kafka";

const router = express.Router();

router.post("/orders", async (req, res) => {
  const order = {
    id: Date.now(),
    user: req.body.user,
    items: req.body.items,
    status: "placed",
  };

  await producer.send({
    topic: "order-events",
    messages: [{ key: "order.placed", value: JSON.stringify(order) }],
  });

  res.status(200).json({ success: true, order });
});

Step 3: Kafka Consumer (Inventory Service)

// consumers/inventory.js
import { Kafka } from "kafkajs";

const kafka = new Kafka({ clientId: "inventory", brokers: ["localhost:9092"] });
const consumer = kafka.consumer({ groupId: "inventory-group" });

await consumer.connect();
await consumer.subscribe({ topic: "order-events" });

await consumer.run({
  eachMessage: async ({ message }) => {
    const event = JSON.parse(message.value.toString());

    if (message.key.toString() === "order.placed") {
      console.log("Inventory update triggered for order:", event.id);
      // Deduct stock logic goes here
    }
  },
});

Step 4: Frontend with React

// components/OrderForm.tsx
const OrderForm = () => {
  const handleSubmit = async () => {
    const res = await fetch("/api/orders", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        user: "John Doe",
        items: ["Apples", "Bananas"],
      }),
    });

    const data = await res.json();
    alert(`Order placed with ID: ${data.order.id}`);
  };

  return <button onClick={handleSubmit}>Place Order</button>;
};

🔥 Benefits of Event-Driven Architecture

✅ Loose Coupling: Services evolve independently
✅ Scalable: Easily add new event listeners
✅ Resilient: One service going down won’t break the system
✅ Reactive: Great for real-time apps

🧱 EDA vs. Microservices: Are They the Same?

Not quite.

Microservices = architectural style (how services are structured)
EDA = communication style (how services talk)

You can have monolith + EDA or microservices + REST. But EDA fits microservices beautifully.

🚧 When NOT to Use EDA

For small apps, it might add unnecessary complexity.
Debugging distributed events can be harder.
Eventual consistency requires new thinking (e.g., handling retries or duplicates).

🚀 Final Thoughts

Event-driven architecture allows your systems to be flexible, scalable, and resilient. Like a well-organized orchestra reacting to a conductor’s baton, every service in EDA listens to what it needs, plays its part, and never gets in the way of the others.

Want to build something truly scalable in 2025? Event-driven thinking might just be your secret weapon.

All code in this post can be found here

Confi.dev