AWS Lambda Optimization with Claude Code

Accelerating AWS Lambda Development With Claude Code

AWS Lambda is an event-driven serverless compute service. It integrates tightly with AWS services like API Gateway, S3, and DynamoDB to let you build scalable backends. With Claude Code, you can efficiently write Lambda-specific patterns and IaC code.

Basic Lambda Function Design

> Create a Lambda function in TypeScript.
> Set it up to handle requests from API Gateway.

// src/handlers/api.ts
import {
  APIGatewayProxyEvent,
  APIGatewayProxyResult,
  Context,
} from 'aws-lambda';

export const handler = async (
  event: APIGatewayProxyEvent,
  context: Context
): Promise<APIGatewayProxyResult> => {
  const { httpMethod, path, body, queryStringParameters } = event;

  try {
    switch (`${httpMethod} ${path}`) {
      case 'GET /users':
        return await getUsers(queryStringParameters);
      case 'POST /users':
        return await createUser(JSON.parse(body || '{}'));
      case 'GET /users/{id}':
        const id = event.pathParameters?.id;
        return await getUser(id!);
      default:
        return response(404, { error: 'Not Found' });
    }
  } catch (error) {
    console.error('Lambda error:', error);
    return response(500, { error: 'Internal Server Error' });
  }
};

function response(statusCode: number, body: object): APIGatewayProxyResult {
  return {
    statusCode,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
    },
    body: JSON.stringify(body),
  };
}

async function getUsers(params: any) {
  // Fetch the user list from DynamoDB
  return response(200, { users: [] });
}

async function createUser(data: any) {
  return response(201, { id: 'new-user-id', ...data });
}

async function getUser(id: string) {
  return response(200, { id, name: 'User' });
}

Integrating With DynamoDB

> Create CRUD utility functions for DynamoDB.

// src/lib/dynamodb.ts
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import {
  DynamoDBDocumentClient,
  GetCommand,
  PutCommand,
  QueryCommand,
  DeleteCommand,
} from '@aws-sdk/lib-dynamodb';

const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);

const TABLE_NAME = process.env.TABLE_NAME!;

export async function getItem<T>(pk: string, sk: string): Promise<T | null> {
  const { Item } = await docClient.send(
    new GetCommand({
      TableName: TABLE_NAME,
      Key: { PK: pk, SK: sk },
    })
  );
  return (Item as T) || null;
}

export async function putItem(item: Record<string, any>): Promise<void> {
  await docClient.send(
    new PutCommand({
      TableName: TABLE_NAME,
      Item: {
        ...item,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      },
    })
  );
}

export async function queryItems<T>(
  pk: string,
  skPrefix?: string
): Promise<T[]> {
  const params: any = {
    TableName: TABLE_NAME,
    KeyConditionExpression: skPrefix
      ? 'PK = :pk AND begins_with(SK, :sk)'
      : 'PK = :pk',
    ExpressionAttributeValues: { ':pk': pk },
  };

  if (skPrefix) {
    params.ExpressionAttributeValues[':sk'] = skPrefix;
  }

  const { Items } = await docClient.send(new QueryCommand(params));
  return (Items as T[]) || [];
}

Defining Infrastructure With AWS CDK

> Use CDK to define a stack with Lambda + API Gateway + DynamoDB.

// lib/api-stack.ts
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs';
import { Construct } from 'constructs';

export class ApiStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    // DynamoDB table
    const table = new dynamodb.Table(this, 'MainTable', {
      partitionKey: { name: 'PK', type: dynamodb.AttributeType.STRING },
      sortKey: { name: 'SK', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: cdk.RemovalPolicy.RETAIN,
    });

    // Lambda function
    const apiHandler = new NodejsFunction(this, 'ApiHandler', {
      entry: 'src/handlers/api.ts',
      handler: 'handler',
      runtime: lambda.Runtime.NODEJS_20_X,
      architecture: lambda.Architecture.ARM_64,
      memorySize: 256,
      timeout: cdk.Duration.seconds(30),
      environment: {
        TABLE_NAME: table.tableName,
        NODE_OPTIONS: '--enable-source-maps',
      },
      bundling: {
        minify: true,
        sourceMap: true,
      },
    });

    table.grantReadWriteData(apiHandler);

    // API Gateway
    const api = new apigateway.RestApi(this, 'Api', {
      restApiName: 'My API',
      deployOptions: { stageName: 'v1' },
    });

    const users = api.root.addResource('users');
    users.addMethod('GET', new apigateway.LambdaIntegration(apiHandler));
    users.addMethod('POST', new apigateway.LambdaIntegration(apiHandler));
  }
}

Local Development and Testing

# Run locally with SAM
sam local start-api

# Test a specific function
sam local invoke ApiHandler -e events/get-users.json

# Deploy with CDK
cdk deploy --require-approval never

Summary

Combining AWS Lambda with Claude Code lets you efficiently go from serverless architecture design to writing IaC. Also see the AWS deploy guide and serverless functions guide.

For more on AWS Lambda, see the official AWS Lambda documentation.