AWS Lambda Patterns for Production

Lambda functions need production patterns different from traditional servers. Here's how to build reliable, performant Lambda applications.

Basic Handler Pattern#

import { APIGatewayProxyHandler, APIGatewayProxyResult } from 'aws-lambda';

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

    const result = await processRequest(body);

    return {
      statusCode: 200,
      headers: {
        'Content-Type': 'application/json',
        'Access-Control-Allow-Origin': '*',
      },
      body: JSON.stringify(result),
    };
  } catch (error) {
    console.error('Handler error:', error);

    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Internal server error' }),
    };
  }
};

// Typed handler factory
function createHandler<T, R>(
  handler: (body: T, event: APIGatewayProxyEvent) => Promise<R>,
  options: { statusCode?: number } = {}
): APIGatewayProxyHandler {
  return async (event) => {
    try {
      const body = JSON.parse(event.body || '{}') as T;
      const result = await handler(body, event);

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

Cold Start Optimization#

// Initialize outside handler - reused across invocations
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';

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

// Lazy initialization
let dbConnection: DatabaseConnection | null = null;

async function getDbConnection(): Promise<DatabaseConnection> {
  if (!dbConnection) {
    dbConnection = await createConnection({
      host: process.env.DB_HOST,
      // ... config
    });
  }
  return dbConnection;
}

export const handler: APIGatewayProxyHandler = async (event) => {
  const db = await getDbConnection();
  // Use db...
};

// Provisioned concurrency for critical functions
// In serverless.yml:
// functions:
//   api:
//     handler: handler.main
//     provisionedConcurrency: 5

Error Handling#

// Custom error classes
class AppError extends Error {
  constructor(
    message: string,
    public statusCode: number,
    public code: string
  ) {
    super(message);
    this.name = 'AppError';
  }
}

class ValidationError extends AppError {
  constructor(message: string, public details?: any) {
    super(message, 400, 'VALIDATION_ERROR');
  }
}

class NotFoundError extends AppError {
  constructor(resource: string) {
    super(`${resource} not found`, 404, 'NOT_FOUND');
  }
}

// Error handler
function handleError(error: unknown): APIGatewayProxyResult {
  console.error('Error:', error);

  if (error instanceof AppError) {
    return {
      statusCode: error.statusCode,
      body: JSON.stringify({
        error: error.message,
        code: error.code,
      }),
    };
  }

  // Don't expose internal errors
  return {
    statusCode: 500,
    body: JSON.stringify({
      error: 'Internal server error',
      code: 'INTERNAL_ERROR',
    }),
  };
}

// Middleware pattern
const withErrorHandling = (
  handler: APIGatewayProxyHandler
): APIGatewayProxyHandler => {
  return async (event, context) => {
    try {
      return await handler(event, context, () => {});
    } catch (error) {
      return handleError(error);
    }
  };
};

Request Validation#

import { z } from 'zod';

const createUserSchema = z.object({
  email: z.string().email(),
  name: z.string().min(1).max(100),
  age: z.number().min(18).optional(),
});

function validate<T>(schema: z.ZodSchema<T>, data: unknown): T {
  const result = schema.safeParse(data);

  if (!result.success) {
    throw new ValidationError('Validation failed', result.error.flatten());
  }

  return result.data;
}

export const createUser = createHandler(async (body) => {
  const data = validate(createUserSchema, body);
  return userService.create(data);
}, { statusCode: 201 });

Middleware Chain#

type Middleware = (
  handler: APIGatewayProxyHandler
) => APIGatewayProxyHandler;

// Auth middleware
const withAuth: Middleware = (handler) => async (event, context, callback) => {
  const token = event.headers.Authorization?.replace('Bearer ', '');

  if (!token) {
    return {
      statusCode: 401,
      body: JSON.stringify({ error: 'Unauthorized' }),
    };
  }

  try {
    const user = await verifyToken(token);
    (event as any).user = user;
    return handler(event, context, callback);
  } catch {
    return {
      statusCode: 401,
      body: JSON.stringify({ error: 'Invalid token' }),
    };
  }
};

// Logging middleware
const withLogging: Middleware = (handler) => async (event, context, callback) => {
  const start = Date.now();
  const requestId = context.awsRequestId;

  console.log({
    type: 'REQUEST',
    requestId,
    path: event.path,
    method: event.httpMethod,
  });

  const result = await handler(event, context, callback);

  console.log({
    type: 'RESPONSE',
    requestId,
    statusCode: result.statusCode,
    duration: Date.now() - start,
  });

  return result;
};

// Compose middlewares
const compose = (...middlewares: Middleware[]): Middleware => {
  return (handler) =>
    middlewares.reduceRight((h, middleware) => middleware(h), handler);
};

// Usage
const enhance = compose(withErrorHandling, withLogging, withAuth);

export const handler = enhance(async (event) => {
  const user = (event as any).user;
  return {
    statusCode: 200,
    body: JSON.stringify({ message: `Hello ${user.name}` }),
  };
});

Async Processing#

import { SQSHandler, SQSEvent } from 'aws-lambda';

// SQS handler with batch processing
export const sqsHandler: SQSHandler = async (event: SQSEvent) => {
  const results = await Promise.allSettled(
    event.Records.map(async (record) => {
      const body = JSON.parse(record.body);
      await processMessage(body);
    })
  );

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

  return {
    batchItemFailures: failures,
  };
};

// Invoke async function
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';

const lambda = new LambdaClient({});

async function invokeAsync(functionName: string, payload: any): Promise<void> {
  await lambda.send(
    new InvokeCommand({
      FunctionName: functionName,
      InvocationType: 'Event', // Async
      Payload: JSON.stringify(payload),
    })
  );
}

Observability#

// Structured logging
const logger = {
  info: (message: string, data?: object) => {
    console.log(JSON.stringify({ level: 'INFO', message, ...data }));
  },
  error: (message: string, error: Error, data?: object) => {
    console.error(
      JSON.stringify({
        level: 'ERROR',
        message,
        error: error.message,
        stack: error.stack,
        ...data,
      })
    );
  },
};

// X-Ray tracing
import AWSXRay from 'aws-xray-sdk-core';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';

const client = AWSXRay.captureAWSv3Client(new DynamoDBClient({}));

// Custom metrics
import { MetricUnits, Metrics } from '@aws-lambda-powertools/metrics';

const metrics = new Metrics({ namespace: 'MyApp' });

export const handler = async (event) => {
  metrics.addMetric('RequestCount', MetricUnits.Count, 1);

  try {
    const result = await processRequest(event);
    metrics.addMetric('SuccessCount', MetricUnits.Count, 1);
    return result;
  } catch (error) {
    metrics.addMetric('ErrorCount', MetricUnits.Count, 1);
    throw error;
  } finally {
    metrics.publishStoredMetrics();
  }
};

Configuration#

// Use Parameter Store or Secrets Manager
import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';

const ssm = new SSMClient({});
const configCache: Record<string, string> = {};

async function getConfig(name: string): Promise<string> {
  if (configCache[name]) {
    return configCache[name];
  }

  const result = await ssm.send(
    new GetParameterCommand({
      Name: name,
      WithDecryption: true,
    })
  );

  const value = result.Parameter?.Value || '';
  configCache[name] = value;
  return value;
}

// Environment-specific config
const config = {
  tableName: process.env.TABLE_NAME!,
  region: process.env.AWS_REGION!,
  stage: process.env.STAGE || 'dev',
};

Best Practices#

Cold Starts:
✓ Initialize outside handler
✓ Use provisioned concurrency for critical paths
✓ Keep deployment packages small
✓ Avoid VPC when not needed

Reliability:
✓ Implement proper error handling
✓ Use dead letter queues
✓ Set appropriate timeouts
✓ Implement retries with backoff

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

Security:
✓ Least privilege IAM
✓ Encrypt environment variables
✓ Validate all inputs
✓ Use secrets manager

Production Lambda requires patterns for cold starts, error handling, and observability. Initialize connections outside handlers, implement proper middleware chains, and use structured logging. Monitor cold start times and consider provisioned concurrency for latency-sensitive functions.