Performance tuning and optimization techniques

Serverless Applications with AWS Lambda

Claudio Canales

Senior DevOps Engineer

Performance = latency + cost

• You pay for time.
• Performance tuning is also cost optimization.
• Measure before you tune.
• Change one thing at a time.

Where time goes

• Initialization.
• Handler execution.
• Time waiting on external calls.

Cold start vs warm start

Cold start

• Lambda needs a new environment.

Warm start

• Reuses an existing environment.
• Handler runs with less overhead.

Init work vs handler work

• Imports and global setup run in init.
• Heavy init means slower cold starts.
• Init duration shows in metrics.

Reuse clients across warm invocations

• Creating a client every invocation repeats the cost.
• Reuse it when the environment is warm.

Code pattern: client outside the handler

import boto3
sts = boto3.client("sts")
def handler(event, context):
    return sts.get_caller_identity()

Cache what you can

• Keep data in memory.
• Use /tmp for small temporary files.
• Cache carefully and invalidate when needed.

Keep dependencies lean

• Large packages take longer to load.
• Prune what you don't use.
• Keep dependencies as small as possible.

Log wisely

• Too much logging adds cost and noise.
• Aim for small, structured messages.
• Stay searchable; help trace and debug.

Reduce external call overhead

• Calls to other services are the slowest part.
• Reduce calls; batch work when possible.
• Set timeouts so failures don't hang.

Memory also affects CPU

• CPU scales with memory.
• CPU-bound code can finish faster.
• More memory can cut duration or cost.
• Test to find the best value.

Find the cost sweet spot

• The best memory setting minimizes total cost.
• The curve drops, then flattens or rises.
• Re-test after changes.

Measure with CloudWatch

• Track Duration and Init duration.
• Track errors and throttles.
• Watch tail latencies (p95, p99).

Reducing cold starts

• Shrink what runs in init.
• Keep your package lean.
• Reuse expensive setup.
• Consider provisioned environments.

Key takeaways

• Know where time goes.
• Reuse clients and cache carefully.
• Memory changes CPU and duration.
• Measure every change.

Let's practice!

Serverless Applications with AWS Lambda