Serverless Architecture Patterns

Serverless changes how we design applications. Here are patterns that work well in serverless environments.

Function Composition#

// Single-purpose functions
export const validateOrder = async (event: APIGatewayEvent) => {
  const order = JSON.parse(event.body!);

  const errors = validateOrderSchema(order);
  if (errors.length > 0) {
    return { statusCode: 400, body: JSON.stringify({ errors }) };
  }

  // Pass to next function via Step Functions or EventBridge
  await eventBridge.putEvents({
    Entries: [{
      Source: 'orders',
      DetailType: 'OrderValidated',
      Detail: JSON.stringify(order),
    }],
  });

  return { statusCode: 202, body: JSON.stringify({ status: 'processing' }) };
};

export const processPayment = async (event: EventBridgeEvent) => {
  const order = event.detail;

  const payment = await stripe.charges.create({
    amount: order.total,
    currency: 'usd',
    source: order.paymentToken,
  });

  await eventBridge.putEvents({
    Entries: [{
      Source: 'payments',
      DetailType: 'PaymentProcessed',
      Detail: JSON.stringify({ orderId: order.id, paymentId: payment.id }),
    }],
  });
};

export const fulfillOrder = async (event: EventBridgeEvent) => {
  const { orderId, paymentId } = event.detail;

  await db.order.update({
    where: { id: orderId },
    data: { status: 'fulfilled', paymentId },
  });

  await sendConfirmationEmail(orderId);
};

Event-Driven Architecture#

# serverless.yml
functions:
  orderCreated:
    handler: handlers/orders.created
    events:
      - eventBridge:
          pattern:
            source:
              - orders
            detail-type:
              - OrderCreated

  inventoryReserved:
    handler: handlers/inventory.reserved
    events:
      - eventBridge:
          pattern:
            source:
              - inventory
            detail-type:
              - InventoryReserved

  sendNotification:
    handler: handlers/notifications.send
    events:
      - eventBridge:
          pattern:
            source:
              - orders
              - payments
            detail-type:
              - OrderFulfilled
              - PaymentFailed

// Event publisher
import { EventBridgeClient, PutEventsCommand } from '@aws-sdk/client-eventbridge';

const eventBridge = new EventBridgeClient({});

async function publishEvent(
  source: string,
  detailType: string,
  detail: object
): Promise<void> {
  await eventBridge.send(new PutEventsCommand({
    Entries: [{
      Source: source,
      DetailType: detailType,
      Detail: JSON.stringify(detail),
      EventBusName: process.env.EVENT_BUS_NAME,
    }],
  }));
}

// Usage
await publishEvent('orders', 'OrderCreated', {
  orderId: '123',
  userId: 'user_456',
  items: [{ productId: 'prod_789', quantity: 2 }],
});

Step Functions Orchestration#

{
  "Comment": "Order processing workflow",
  "StartAt": "ValidateOrder",
  "States": {
    "ValidateOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:validateOrder",
      "Next": "CheckInventory",
      "Catch": [{
        "ErrorEquals": ["ValidationError"],
        "Next": "OrderFailed"
      }]
    },
    "CheckInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:checkInventory",
      "Next": "ProcessPayment",
      "Catch": [{
        "ErrorEquals": ["OutOfStockError"],
        "Next": "OrderFailed"
      }]
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:processPayment",
      "Next": "FulfillOrder",
      "Retry": [{
        "ErrorEquals": ["PaymentRetryableError"],
        "IntervalSeconds": 2,
        "MaxAttempts": 3,
        "BackoffRate": 2
      }],
      "Catch": [{
        "ErrorEquals": ["PaymentError"],
        "Next": "RefundAndFail"
      }]
    },
    "FulfillOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:fulfillOrder",
      "End": true
    },
    "OrderFailed": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:notifyFailure",
      "End": true
    },
    "RefundAndFail": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:account:function:refund",
      "Next": "OrderFailed"
    }
  }
}

Fan-Out Pattern#

// Process items in parallel
export const processOrder = async (event: SQSEvent) => {
  const order = JSON.parse(event.Records[0].body);

  // Fan out to process each item
  await Promise.all(
    order.items.map(item =>
      sqs.sendMessage({
        QueueUrl: process.env.ITEM_PROCESSING_QUEUE,
        MessageBody: JSON.stringify({
          orderId: order.id,
          item,
        }),
      })
    )
  );
};

export const processItem = async (event: SQSEvent) => {
  const { orderId, item } = JSON.parse(event.Records[0].body);

  // Process individual item
  await reserveInventory(item.productId, item.quantity);

  // Check if all items processed
  const remaining = await db.orderItem.count({
    where: { orderId, status: 'pending' },
  });

  if (remaining === 0) {
    await publishEvent('orders', 'AllItemsProcessed', { orderId });
  }
};

CQRS with DynamoDB Streams#

// Write model
export const createOrder = async (event: APIGatewayEvent) => {
  const order = JSON.parse(event.body!);

  await dynamodb.put({
    TableName: 'Orders',
    Item: {
      PK: `ORDER#${order.id}`,
      SK: `ORDER#${order.id}`,
      ...order,
      createdAt: new Date().toISOString(),
    },
  });

  return { statusCode: 201, body: JSON.stringify(order) };
};

// Stream processor - updates read model
export const updateReadModel = async (event: DynamoDBStreamEvent) => {
  for (const record of event.Records) {
    if (record.eventName === 'INSERT' || record.eventName === 'MODIFY') {
      const order = unmarshall(record.dynamodb!.NewImage!);

      // Update Elasticsearch for search
      await elasticsearch.index({
        index: 'orders',
        id: order.id,
        body: order,
      });

      // Update aggregation table
      await dynamodb.update({
        TableName: 'UserOrderStats',
        Key: { userId: order.userId },
        UpdateExpression: 'ADD orderCount :one SET lastOrderDate = :date',
        ExpressionAttributeValues: {
          ':one': 1,
          ':date': order.createdAt,
        },
      });
    }
  }
};

Saga Pattern#

// Saga coordinator
interface SagaStep {
  execute: () => Promise<void>;
  compensate: () => Promise<void>;
}

async function executeSaga(steps: SagaStep[]): Promise<void> {
  const completedSteps: SagaStep[] = [];

  try {
    for (const step of steps) {
      await step.execute();
      completedSteps.push(step);
    }
  } catch (error) {
    // Compensate in reverse order
    for (const step of completedSteps.reverse()) {
      try {
        await step.compensate();
      } catch (compensateError) {
        console.error('Compensation failed:', compensateError);
        // Log to dead letter queue for manual intervention
      }
    }
    throw error;
  }
}

// Usage
const orderSaga: SagaStep[] = [
  {
    execute: () => reserveInventory(orderId),
    compensate: () => releaseInventory(orderId),
  },
  {
    execute: () => chargePayment(orderId),
    compensate: () => refundPayment(orderId),
  },
  {
    execute: () => createShipment(orderId),
    compensate: () => cancelShipment(orderId),
  },
];

await executeSaga(orderSaga);

Cost Optimization#

// Batch processing to reduce invocations
export const processBatch = async (event: SQSEvent) => {
  // Process up to 10 messages per invocation
  const results = await Promise.allSettled(
    event.Records.map(record => processMessage(JSON.parse(record.body)))
  );

  // Return failures for retry
  const failures = results
    .map((result, index) => ({ result, record: event.Records[index] }))
    .filter(({ result }) => result.status === 'rejected');

  return {
    batchItemFailures: failures.map(({ record }) => ({
      itemIdentifier: record.messageId,
    })),
  };
};

// Use reserved concurrency to control costs
// serverless.yml
// functions:
//   expensive:
//     handler: handlers.expensive
//     reservedConcurrency: 5  # Max 5 concurrent executions

# Right-size memory allocation
functions:
  lightweight:
    handler: handlers.lightweight
    memorySize: 128  # MB

  cpuIntensive:
    handler: handlers.cpuIntensive
    memorySize: 1024  # More CPU allocated with more memory

  heavyProcessing:
    handler: handlers.heavy
    memorySize: 3008  # Max before ARM pricing changes
    architecture: arm64  # 20% cheaper on ARM

Best Practices#

Design:
✓ Single responsibility per function
✓ Use events for async communication
✓ Implement idempotency
✓ Design for failure and retries

Performance:
✓ Minimize cold starts
✓ Keep functions small
✓ Use connection pooling
✓ Cache when possible

Cost:
✓ Right-size memory allocation
✓ Use ARM architecture
✓ Batch process where possible
✓ Set reserved concurrency limits

Observability:
✓ Structured logging
✓ Distributed tracing
✓ Custom metrics
✓ Alert on errors

Serverless architecture requires different patterns than traditional applications. Embrace event-driven design, use orchestration for complex workflows, and always consider idempotency. Good serverless design leads to scalable, cost-effective applications.