serverless

name	serverless
description	| Use when this capability is needed.

Serverless Computing

AWS Lambda (Node.js)

import { APIGatewayProxyHandlerV2 } from 'aws-lambda';

export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  const body = JSON.parse(event.body || '{}');

  // Initialize clients OUTSIDE handler (reused across warm invocations)
  const result = await processRequest(body);

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(result),
  };
};

// DB connections, SDK clients — init outside handler
import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
const ddb = DynamoDBDocumentClient.from(new DynamoDBClient({}));

Common Event Sources

// SQS handler
import { SQSHandler } from 'aws-lambda';
export const sqsHandler: SQSHandler = async (event) => {
  for (const record of event.Records) {
    const body = JSON.parse(record.body);
    await processMessage(body);
  }
  // Failed messages: use partial batch response
};

// Scheduled (cron)
import { ScheduledHandler } from 'aws-lambda';
export const cronHandler: ScheduledHandler = async () => {
  await dailyCleanup();
};

SST (recommended framework for AWS)

// sst.config.ts
export default $config({
  app(input) { return { name: 'my-app', home: 'aws' }; },
  async run() {
    const api = new sst.aws.ApiGatewayV2('Api');
    api.route('POST /orders', 'src/functions/orders.handler');

    const table = new sst.aws.Dynamo('Orders', {
      fields: { pk: 'string', sk: 'string' },
      primaryIndex: { hashKey: 'pk', rangeKey: 'sk' },
    });

    // Link resources (auto-grants IAM permissions)
    api.route('GET /orders/{id}', {
      handler: 'src/functions/get-order.handler',
      link: [table],
    });
  },
});

Serverless Framework

# serverless.yml
service: my-service
provider:
  name: aws
  runtime: nodejs20.x
  environment:
    TABLE_NAME: !Ref OrdersTable

functions:
  createOrder:
    handler: src/handlers/orders.create
    events:
      - httpApi: 'POST /orders'
  processQueue:
    handler: src/handlers/queue.process
    events:
      - sqs:
          arn: !GetAtt OrderQueue.Arn
          batchSize: 10

resources:
  Resources:
    OrdersTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: ${self:service}-orders
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - { AttributeName: pk, AttributeType: S }
        KeySchema:
          - { AttributeName: pk, KeyType: HASH }

Cold Start Optimization

Technique	Impact
Minimize bundle size (tree-shake, no large SDKs)	High
Initialize clients outside handler	High
Use ARM64 (arm64 architecture)	Medium
Provisioned concurrency for critical paths	High (costs more)
Avoid VPC unless required	Medium

// Bundle optimization: import only what you need
import { DynamoDBClient } from '@aws-sdk/client-dynamodb'; // Not all of aws-sdk

Anti-Patterns

Anti-Pattern	Fix
Init DB/SDK inside handler	Move to module scope (reused across warm calls)
Monolithic function (does everything)	One function per concern
No timeout configuration	Set function timeout (default 3s is often too low)
Large deployment package	Tree-shake, exclude dev deps, use layers
Synchronous chaining (Lambda → Lambda)	Use SQS/SNS/Step Functions
No dead letter queue	Configure DLQ for async invocations

Production Checklist

• Timeout configured per function
• Dead letter queue for async events
• CloudWatch alarms on errors and throttles
• Structured logging (JSON format)
• X-Ray tracing enabled
• Minimum IAM permissions per function
• Environment variables for config (not hardcoded)
• Provisioned concurrency for latency-critical functions

---

Source: claude-dev-suite/claude-dev-suite — distributed by TomeVault.