serverless-patterns-advanced

name	serverless-patterns-advanced
description	Advanced Serverless patterns — Lambda idempotency (Lambda Powertools + DynamoDB persistence layer), Lambda cost model (pricing formula, break-even vs containers), and CloudWatch Insights observability queries for cold starts, duration, and errors.

Serverless Patterns — Advanced

This skill extends serverless-patterns with idempotency, cost modeling, and observability. Load serverless-patterns first.

When to Activate

• Lambda receives duplicate events and needs idempotency (at-least-once delivery)
• Calculating whether Lambda or containers are more cost-effective at current request volume
• Writing CloudWatch Insights queries for cold start analysis, duration percentiles, or error rates

---

Idempotency

Lambda can be invoked multiple times for the same event (at-least-once delivery). Always design for idempotency.

import { makeHandlerIdempotent } from '@aws-lambda-powertools/idempotency';
import { DynamoDBPersistenceLayer } from '@aws-lambda-powertools/idempotency/dynamodb';

const persistenceStore = new DynamoDBPersistenceLayer({
  tableName: 'IdempotencyTable',
});

// Wrap handler — duplicate events return cached result
export const handler = makeHandlerIdempotent(
  async (event: OrderEvent) => {
    await chargePayment(event.paymentId, event.amount);
    await createOrder(event);
    return { orderId: event.orderId, status: 'created' };
  },
  { persistenceStore }
);

# Required DynamoDB table
IdempotencyTable:
  Type: AWS::DynamoDB::Table
  Properties:
    AttributeDefinitions:
      - AttributeName: id
        AttributeType: S
    KeySchema:
      - AttributeName: id
        KeyType: HASH
    TimeToLiveSpecification:
      AttributeName: expiration
      Enabled: true
    BillingMode: PAY_PER_REQUEST

---

Cost Model

Lambda pricing (us-east-1):

• Requests: $0.20 per 1M invocations
• Duration: $0.0000166667 per GB-second
• Provisioned Concurrency: $0.0000041667 per GB-second (always-on)

Break-Even: Lambda vs. Container

Lambda cost/month = requests × $0.0000002 + (avg_duration_s × memory_GB × requests × $0.0000166667)

Example: 10M requests/month, 200ms avg, 512MB
= 10M × $0.0000002 + (0.2 × 0.5 × 10M × $0.0000166667)
= $2 + $16.67
= ~$18.67/month

ECS Fargate (0.25 vCPU, 0.5GB) = ~$12/month (continuous)

Rule of thumb: Lambda wins below ~5M requests/month or spiky traffic.
Containers win with constant high-volume predictable load.

---

Observability

# CloudWatch Insights — Lambda performance
fields @timestamp, @duration, @billedDuration, @memorySize, @maxMemoryUsed, @initDuration
| filter @type = "REPORT"
| stats avg(@duration), max(@duration), avg(@initDuration) by bin(5m)

# Cold starts only
fields @timestamp, @initDuration
| filter @type = "REPORT" and ispresent(@initDuration)
| stats count(), avg(@initDuration) by bin(1h)

# Errors
fields @timestamp, @message
| filter @message like /ERROR/
| sort @timestamp desc
| limit 50

Reference

• serverless-patterns — cold starts, Step Functions, Lambda Powertools (Logger, Metrics, Tracer)
• edge-patterns — Cloudflare Workers, Vercel Edge Middleware
• observability — OpenTelemetry, Grafana, distributed tracing
• chaos-engineering — Testing Lambda failure modes (throttling, DLQ exhaustion)