Writing clean, observable, and maintainable Lambda functions can be challenging — especially at scale.

That’s where AWS Lambda Powertools for TypeScript comes in. It offers a suite of utilities to help with:

  • Structured logging
  • Distributed tracing
  • Custom metrics
  • Parameter and secret fetching
  • Reusable data providers (like DynamoDB)

In today’s post, we’ll walk through how to use some of the most useful features in a real-world Lambda function.

🧰 Installation

First, install Powertools packages:

npm install @aws-lambda-powertools/logger @aws-lambda-powertools/tracer @aws-lambda-powertools/metrics @aws-lambda-powertools/parameters

Optional (for DynamoDB provider):

npm install @aws-sdk/client-dynamodb

📝 Structured Logging with Logger 

import { Logger } from '@aws-lambda-powertools/logger';

const logger = new Logger({ serviceName: 'UserService' });

export const handler = async (event) => {
  logger.info('Handling event', { event });

  return {
    statusCode: 200,
    body: JSON.stringify({ message: 'Hello World!' }),
  };
};

✅ Output is JSON-formatted and ready for CloudWatch, Datadog, or other log aggregators.

📦 Tracing with Tracer 

import { Tracer } from '@aws-lambda-powertools/tracer';

const tracer = new Tracer({ serviceName: 'UserService' });

export const handler = async (event, context) => {
  const segment = tracer.getSegment();
  const subsegment = segment.addNewSubsegment('my-subtask');

  try {
    // your logic here
  } finally {
    subsegment.close();
  }

  return { statusCode: 200 };
};

💡 Tracer integrates with AWS X-Ray automatically if enabled.

📈 Metrics with Metrics 

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

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

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

  return { statusCode: 200 };
};

🎯 Automatically flushes metrics to CloudWatch.

🔑 Fetching Parameters with getParameter 

import { getParameter } from '@aws-lambda-powertools/parameters/ssm';

export const handler = async () => {
  const dbName = await getParameter('/my-app/db-name');

  return {
    statusCode: 200,
    body: JSON.stringify({ dbName }),
  };
};

✅ You can also cache parameters:

await getParameter('/my-app/db-name', { maxAge: 300 }); // cache for 5 mins

🗃 DynamoDB Provider 

import { getDynamoDBProvider } from '@aws-lambda-powertools/parameters/dynamo';

const dynamoDBProvider = getDynamoDBProvider({ tableName: 'Settings' });

export const handler = async () => {
  const setting = await dynamoDBProvider.get('theme'); // get row with PK 'theme'

  return {
    statusCode: 200,
    body: JSON.stringify({ theme: setting?.value }),
  };
};

💡 Great for config-driven apps with DynamoDB as your parameter store.

Conclusion
With Powertools for TypeScript, your Lambdas are:

  • ✅ Easier to debug (thanks to structured logging)
  • ✅ Easier to monitor (custom metrics)
  • ✅ Easier to trace (end-to-end with X-Ray)
  • ✅ Easier to configure (via SSM or DynamoDB)

It’s a must-have for production-grade serverless development.