AWS, Azure & GCP · Cloud across providers

How do event-driven architectures work?

MediumeventseventbridgepubsubUpdated Oct 2026
Quiz this track

Short answer

Services emit events when something happens, and other services react asynchronously through brokers, streams or rules. This reduces coupling and enables fan-out, but requires idempotency, schema evolution and tracing.

An event describes something that happened, such as an order being created. The producer does not know or care who consumes it. A broker or router delivers it to interested consumers, which may number zero or many.

Patterns

  • Pub/sub for fan-out to multiple consumers, such as SNS or Pub/Sub
  • Event bus with rules and routing, such as EventBridge or Event Grid
  • Streaming log for ordered replay, such as Kafka or Kinesis
  • Choreography where services react to each other, versus orchestration with a central workflow
json
{
  "id": "evt_123",
  "type": "order.created",
  "source": "orders",
  "time": "2026-10-28T10:00:00Z",
  "data": {
    "orderId": "ord_456",
    "total": 2499
  }
}
A small event envelope with an id, type, source, time and payload.

Because delivery is asynchronous, consumers must tolerate duplicates and out-of-order events. Include an event id for deduplication and a version in the schema. Prefer additive changes, and keep a contract test so producers do not break consumers silently.

Event-driven does not mean no ownership. Someone must own the schema, the broker, retry policy, dead-letter handling and end-to-end tracing across services.

Follow-ups you should expect

Interviewers use these to check whether the first answer was understanding or memorisation.

  1. 1What is the difference between an event and a command?
  2. 2How do you handle duplicate or out-of-order events?
  3. 3When would you use orchestration instead of choreography?
  4. 4How do you evolve an event schema safely?

Say it in the interview

In an event-driven architecture, a service publishes an event describing what happened, and consumers react asynchronously through a broker or stream. That reduces coupling and allows fan-out, but I have to design for duplicate delivery, ordering and schema evolution. I include an event id and version, make consumers idempotent, and trace the whole flow because debugging is harder than a synchronous call.

Use this as a model, not a script. Saying it in your own words is what makes it survive follow-up pressure.

Related questions

Reading is step one

Now say it out loud.

Understanding an answer and delivering it under pressure are different skills. Rehearse this topic in a live AWS, Azure & GCP mock interview and get scored feedback on depth, clarity and confidence.