What's Included

This chapter covers the core features and capabilities of Serverless Patterns Collection.

What's Included

CloudFormation Templates (5)

Lambda Functions (4)

Documentation (5)

Scripts (2)

Examples (3)

Quick Start

1. Choose Your Pattern

# Run the interactive pattern selector
python3 scripts/pattern_selector.py

# Or see all patterns at a glance
python3 scripts/pattern_selector.py --all

2. Estimate Costs

# Compare all patterns at 1M requests/month
python3 scripts/cost_calculator.py --requests 1000000

# Full comparison across traffic levels
python3 scripts/cost_calculator.py --compare

3. Deploy

# Package Lambda functions
cd functions/
zip -r ../lambda-package.zip *.py
aws s3 cp ../lambda-package.zip s3://your-bucket/lambda-package.zip

# Deploy the REST API pattern (example)
aws cloudformation deploy \
  --template-file cloudformation/api-gateway-lambda.yaml \
  --stack-name my-api-dev \
  --parameter-overrides Environment=dev ApiName=my-api \
  --capabilities CAPABILITY_NAMED_IAM

# Get the API URL
aws cloudformation describe-stacks \
  --stack-name my-api-dev \
  --query "Stacks[0].Outputs[?OutputKey=='ApiUrl'].OutputValue" \
  --output text

4. Test Locally

All Lambda functions include if __name__ == "__main__": blocks for local testing:

# Test the API handler
python3 functions/api_handler.py

# Test the event processor
python3 functions/event_processor.py

# Test the saga coordinator
python3 functions/saga_coordinator.py

# Test the stream processor
python3 functions/stream_processor.py

Pattern Selection Guide

Architecture Overview

Follow this guide to get Serverless Patterns Collection up and running in your environment.

Architecture Overview

┌──────────────────────────────────────────────────────────────┐
│                     API Layer                                 │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                   │
│  │ REST API │  │ WebSocket│  │ Scheduled│                    │
│  │ (APIGW)  │  │ (APIGW)  │  │ (EventBr)│                   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘                   │
├───────┼──────────────┼─────────────┼─────────────────────────┤
│       │     Compute Layer          │                         │
│  ┌────┴─────┐  ┌────┴─────┐  ┌────┴─────┐                   │
│  │  Lambda  │  │  Lambda  │  │  Lambda  │                    │
│  │ (Handler)│  │(Processor)│ │  (Cron)  │                    │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘                   │
├───────┼──────────────┼─────────────┼─────────────────────────┤
│       │     Messaging Layer        │                         │
│  ┌────┴─────┐  ┌────┴─────┐  ┌────┴─────┐                   │
│  │EventBridg│  │   SQS    │  │   SNS    │                    │
│  │  (Bus)   │  │ (Queues) │  │ (Topics) │                    │
│  └──────────┘  └──────────┘  └──────────┘                    │
├──────────────────────────────────────────────────────────────┤
│                  Orchestration Layer                          │
│  ┌──────────────────────────────────────────┐                │
│  │          Step Functions (Sagas)           │                │
│  └──────────────────────────────────────────┘                │
├──────────────────────────────────────────────────────────────┤
│                    Storage Layer                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                   │
│  │ DynamoDB │  │ DynamoDB │  │    S3    │                     │
│  │ (Tables) │  │(Streams) │  │ (Objects)│                    │
│  └──────────┘  └──────────┘  └──────────┘                    │
└──────────────────────────────────────────────────────────────┘

File Structure

serverless-patterns-collection/
├── README.md                           # This file
├── LICENSE                             # MIT License
│
├── cloudformation/                     # Infrastructure-as-Code templates
│   ├── api-gateway-lambda.yaml         # Pattern 1: Synchronous REST API
│   ├── event-driven-pipeline.yaml      # Pattern 2: Event-Driven Pipeline
│   ├── fan-out-pattern.yaml            # Pattern 3: Fan-Out (One-to-Many)
│   ├── saga-orchestration.yaml         # Pattern 4: Saga Orchestration
│   └── cqrs-event-sourcing.yaml        # Pattern 5: CQRS + Event Sourcing
│
├── functions/                          # Lambda function implementations
│   ├── api_handler.py                  # REST API handler (CRUD + CQRS)
│   ├── event_processor.py             # SQS event processor (batch + DLQ)
│   ├── saga_coordinator.py            # Saga steps + compensations
│   └── stream_processor.py            # DynamoDB Streams projector
│
├── docs/                               # Deep-dive documentation
│   ├── architecture.md                 # Reference architecture + diagrams
│   ├── patterns-catalog.md             # 36 serverless patterns catalog
│   ├── cost-optimization.md            # Cost optimization strategies
│   ├── security-considerations.md      # Security best practices
│   └── deployment-guide.md             # Deployment instructions
│
├── scripts/                            # Utility tools
│   ├── pattern_selector.py             # Interactive pattern selection tool
│   └── cost_calculator.py              # Serverless cost estimator
│
└── examples/                           # Configuration examples
    ├── api-gateway-config.json         # API Gateway stage settings
    ├── event-bridge-rules.json         # EventBridge rule patterns
    └── step-functions-definition.json  # Extended state machine example

Requirements

• AWS CLI v2 with configured credentials
• Python 3.12+ (for Lambda functions and scripts)
• AWS account with appropriate IAM permissions
• No external Python packages required (stdlib only)