AWS Lambda Performance Tuning: How to Reduce Cold Starts

Hey fellow builders! If you've worked with AWS Lambda, you've probably run into cold starts. Yes! those annoying delays when your function spins up after being idle. While AWS is great at handling infrastructure for us, cold starts can slow things down, especially for latency-sensitive apps.

So, how do we reduce them? Let's dive in!

What is a cold start? 🥶

When a Lambda function is invoked after being idle, AWS needs to:

• Spin up a new execution environment
• Load your function’s code
• Initialize dependencies

This whole process takes milliseconds to seconds, which might not seem like much, but it's an eternity from the user's perspective. As customer-obsessed builders, we cannot let that be!

Ok so, cold starts are bad. What can we do about it?

As with any cloud computing challenge, there are multiple approaches, each with its own trade-offs. Let's explore a few ideas, one of them might be the perfect fit for your use case.

1. Provisioned concurrency.

This is the most straightforward solution. AWS introduced Provisioned Concurrency to keep function instances warm. It preloads execution environments so your function is ready to go instantly. It is perfect for low-latency, high traffic workloads. However, it will incur an extra cost, so keep that in mind.

2. Optimize Function Memory & CPU.

Finding the right balance between the allocated resources should be an art form. You can experiment and make adjustments based on observations. Luckily, there are awesome folks out there who have paved the way for us. Checkout this AWS Lambda Power Tuning tool. In this video, Daniel clearly explains how to use it.

3. Keep your deployment package small.

AWS Lambda layers let you package dependencies separately from your function code. Instead of bundling large libraries (like bcrypt or Puppeteer) inside your deployment package, you can put them in a layer and reference them in multiple functions.

✅ Benefits:

• Smaller function size (faster cold starts 🚀)
• Easier updates (update the layer instead of redeploying everything)
• Code reuse (share layers across multiple Lambdas)

Example: A Node.js layer with dependencies

Create a nodejs folder and install packages inside it:

mkdir -p nodejs && cd nodejs
npm install sharp
cd ..
zip -r layer.zip nodejs

Upload layer.zip to AWS Lambda as a new layer and add the layer to your Lambda function in the AWS Console or using AWS CLI.

4. Avoid Heavy Initialization.

A common mistake in Lambda development is initializing database connections or loading heavy dependencies inside the handler. This slows down every invocation! Instead, move initialization outside the handler so that it runs only once per execution environment.

❌ Don't do this! (DB connection inside the handler)

const { MongoClient } = require("mongodb");

exports.handler = async (event) => {
  const client = new MongoClient(process.env.MONGO_URI);
  await client.connect(); // Establishes a new connection on every invocation ❌

  const db = client.db("mydb");
  const collection = db.collection("users");
  const users = await collection.find().toArray();

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

✅ Do this! (Persistent DB connection & Lazy Loading)

const { MongoClient } = require("mongodb");

let client; // Store DB connection outside the handler

async function getDBClient() {
  if (!client) {
    client = new MongoClient(process.env.MONGO_URI);
    await client.connect();
  }
  return client;
}

exports.handler = async (event) => {
  const dbClient = await getDBClient();
  const db = dbClient.db("mydb");
  const collection = db.collection("users");

  return {
    statusCode: 200,
    body: JSON.stringify(await collection.find().toArray()),
  };
};

Why is this better?

• The connection is reused across multiple invocations.
• Lazy loading (getDBClient()) ensures the connection initializes only when needed.

5. Warmers

A warmer is a simple mechanism that sends a request to your Lambda function at regular intervals, preventing it from being idle. It's like giving your lambda a nudge just to keep it awake. You can use CloudWatch Events to run the warmer call every 5 minutes, for example.

Wrapping Up

Cold starts are annoying but manageable with the right strategies. If you need instant response times, Provisioned Concurrency is your best bet. Otherwise, keeping things lightweight, optimizing resources, and using warmers can make a big difference. Your users will thank you.

What tricks have worked for you? Drop your thoughts in the comments! 💬👇