Building Event-Driven Architectures with Serverless

Traditional synchronous APIs block execution until the downstream processes complete. This tightly couples your microservices and creates a single point of failure.

Event-driven architecture (EDA) breaks this coupling by using events to trigger asynchronous actions. In AWS, combining event-driven design with Serverless resources like Lambda, SQS, and EventBridge yields highly scalable, self-healing platforms.

---

The Event Flow

Consider an e-commerce checkout flow:

1. The client sends a POST /order request to Amazon API Gateway.
2. An Order API Lambda handler saves the order to Amazon DynamoDB and publishes an OrderCreated event to Amazon EventBridge.
3. Multiple microservices (e.g., Payment Service, Inventory Service, Email Service) listen for OrderCreated and process their work concurrently.

---

Writing a Lambda Event Publisher

Here is a sample TypeScript AWS Lambda handler using the AWS SDK v3 to publish a custom event payload to Amazon EventBridge:

import { EventBridgeClient, PutEventsCommand } from "@aws-sdk/client-eventbridge";

const eventBridge = new EventBridgeClient({ region: "us-east-1" });

interface OrderPayload {
  orderId: string;
  amount: number;
  customerId: string;
}

export const handler = async (event: any): Promise<any> => {
  const order: OrderPayload = JSON.parse(event.body);

  const command = new PutEventsCommand({
    Entries: [
      {
        Source: "awslearn.order-service",
        DetailType: "OrderCreated",
        Detail: JSON.stringify(order),
        EventBusName: "default",
      },
    ],
  });

  try {
    const response = await eventBridge.send(command);
    return {
      statusCode: 201,
      body: JSON.stringify({
        message: "Order placed and event published!",
        eventId: response.Entries?.[0]?.EventId,
      }),
    };
  } catch (error) {
    console.error("Failed to publish event:", error);
    return {
      statusCode: 500,
      body: JSON.stringify({ message: "Failed to place order" }),
    };
  }
};

By processing payments, invoices, and emails asynchronously, the front-end API returns immediately to the client, improving user experience and resilience.