AWS Serverless EDA

Serverless architecture and event-driven design patterns for building scalable, event-driven applications on AWS.

Download this Skill

npx degit LangbaseInc/agent-skills/aws-serverless-eda my-aws-serverless-eda

Overview

Build event-driven architectures using AWS serverless services for scalable, loosely-coupled systems.

Core Services

Event Sources

EventBridge - Event bus for application events
SNS - Pub/Sub messaging
SQS - Message queuing
S3 Events - Object notifications
DynamoDB Streams - Data change capture
Kinesis - Real-time streaming

Compute

Lambda - Serverless functions
Step Functions - Workflow orchestration
ECS Fargate - Containerized compute

Storage & Data

DynamoDB - NoSQL database
S3 - Object storage
Aurora Serverless - Relational database

Event-Driven Patterns

Event Bus Pattern

Producer → EventBridge → Multiple Consumers

Queue Pattern

Producer → SQS → Lambda (with retry & DLQ)

Stream Processing

Source → Kinesis → Lambda → Destination

Pub/Sub

Publisher → SNS Topic → Multiple Subscribers

Architecture Example

Order Processing System

API Gateway → Lambda (Create Order)
              ↓
         EventBridge
              ↓
    ┌─────────┼─────────┐
    ↓         ↓         ↓
Inventory  Payment  Notification
 Lambda    Lambda     Lambda

CDK Implementation

EventBridge Rule

const rule = new events.Rule(this, 'OrderRule', {
  eventPattern: {
    source: ['order.service'],
    detailType: ['OrderCreated'],
  },
});

rule.addTarget(new targets.LambdaFunction(processOrder));

SQS with Lambda

const queue = new sqs.Queue(this, 'Queue', {
  deadLetterQueue: {
    queue: dlq,
    maxReceiveCount: 3,
  },
});

const fn = new lambda.Function(this, 'Processor', {
  runtime: lambda.Runtime.NODEJS_18_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('lambda'),
});

fn.addEventSource(new SqsEventSource(queue));

Best Practices

Event Design

Use descriptive event types
Include metadata
Version your events
Keep events immutable
Document event schemas

Error Handling

Implement retry logic
Use dead letter queues
Add circuit breakers
Log failures
Monitor error rates

Performance

Batch processing
Optimize Lambda memory
Use provisioned concurrency
Enable caching
Minimize cold starts

Security

Least privilege IAM
Encrypt at rest/transit
Validate inputs
Use secrets manager
Enable logging

Common Patterns

Saga Pattern

Distributed transactions across services

CQRS

Separate read and write models

Event Sourcing

Store events as source of truth

Fan-Out

One event triggers multiple functions

Choreography

Services react to events independently

Orchestration

Central coordinator manages workflow

Monitoring

CloudWatch Metrics

Event delivery
Lambda invocations
Queue depth
Error rates
Latency

X-Ray Tracing

End-to-end tracing
Performance bottlenecks
Error analysis
Service map

Testing

Unit Tests

Test Lambda functions in isolation

Integration Tests

Test event flow between services

End-to-End Tests

Test complete workflows

Cost Optimization

Right-size Lambda memory
Use SQS batch processing
Implement caching
EventBridge Archive for replay
Monitor and optimize

Skills