Lambda Execution Model: Handlers, Context, Cold Starts, and the Execution Environment

The handler: function entry point

The Lambda handler is the function AWS calls when your function is invoked. You specify it in the function configuration as filename.function_name.

# handler = "lambda_function.handler"
import json
import boto3

# This code runs ONCE during environment initialization (outside handler)
s3_client = boto3.client('s3')
ssm_client = boto3.client('ssm')

# Pre-load configuration on cold start
config = ssm_client.get_parameter(Name='/myapp/config', WithDecryption=True)

def handler(event, context):
    # This code runs on EVERY invocation
    bucket = event.get('bucket')
    key = event.get('key')

    response = s3_client.get_object(Bucket=bucket, Key=key)
    return {
        'statusCode': 200,
        'body': json.dumps({'size': response['ContentLength']})
    }

The handler receives two arguments:

• event: the triggering event payload. Shape depends on the trigger source (API Gateway, S3, SQS, EventBridge all send different formats).
• context: runtime information about the current invocation.

The context object: invocation metadata

The context object provides information about the current invocation:

def handler(event, context):
    # Time remaining before Lambda times out
    remaining_ms = context.get_remaining_time_in_millis()

    # Unique invocation ID (useful for logging and idempotency)
    invocation_id = context.aws_request_id

    # Function name and version
    function_name = context.function_name
    function_version = context.function_version  # "$LATEST" or version number

    # Memory limit configured for this function
    memory_limit = context.memory_limit_in_mb

    # Log stream name for this invocation
    log_stream = context.log_stream_name

    # Use remaining time to decide whether to start expensive operations
    if remaining_ms < 5000:  # less than 5 seconds left
        return {'statusCode': 408, 'body': 'Not enough time to process'}

get_remaining_time_in_millis() is particularly useful for long-running functions that might time out mid-operation. Check remaining time before starting multi-step processes to avoid partial execution.

Cold starts: what they are and how to reduce them

A cold start happens when Lambda needs to create a new execution environment. Duration:

1. Infrastructure allocation: Lambda finds capacity and allocates a microVM
2. Environment setup: download function code/container, extract, prepare runtime
3. Init phase: run code outside the handler (import libraries, initialize clients)

Cold start duration varies significantly by runtime and function size:

| Runtime | Typical cold start | Memory impact | |---|---|---| | Node.js 20.x | 100–300ms | Higher memory = slightly faster | | Python 3.12 | 100–400ms | Minimal | | Java 21 | 1–3s | Higher memory significantly faster | | .NET 8 | 500ms–2s | Moderate | | Container image | 2–10s | Depends on image size |

Reducing cold start impact:

# 1. Initialize expensive objects once, outside handler
import boto3
from sqlalchemy import create_engine

# These run once per cold start, cached for warm invocations
db_engine = create_engine(
    os.environ['DATABASE_URL'],
    pool_size=1,      # Lambda is single-threaded, 1 connection per env
    max_overflow=0
)
s3 = boto3.client('s3')

def handler(event, context):
    # Reuses the already-initialized engine and s3 client
    with db_engine.connect() as conn:
        result = conn.execute(text("SELECT 1")).fetchone()

# 2. Provisioned Concurrency: pre-warm N environments
resource "aws_lambda_provisioned_concurrency_config" "api" {
  function_name                  = aws_lambda_function.api.function_name
  qualifier                      = aws_lambda_alias.api_live.name
  provisioned_concurrent_executions = 5  # 5 pre-warmed environments
}

Provisioned Concurrency keeps environments warm and eliminates cold start latency. Cost: you pay for the configured concurrency whether it's used or not.

resource "aws_lambda_function" "processor" {
  # ...
  dead_letter_config {
    target_arn = aws_sqs_queue.dlq.arn
  }
}

def handler(event, context):
    batch_item_failures = []
    for record in event['Records']:
        try:
            process(record)
        except Exception as e:
            # Report this specific record as failed
            batch_item_failures.append({
                "itemIdentifier": record['messageId']
            })
    return {"batchItemFailures": batch_item_failures}

Function URLs vs API Gateway

Lambda Function URLs provide a direct HTTPS endpoint without API Gateway:

resource "aws_lambda_function_url" "api" {
  function_name      = aws_lambda_function.api.function_name
  authorization_type = "AWS_IAM"  # or "NONE" for public

  cors {
    allow_credentials = true
    allow_origins     = ["https://app.example.com"]
    allow_methods     = ["GET", "POST"]
    allow_headers     = ["*"]
    max_age           = 86400
  }
}

Function URLs are useful for simple endpoints where API Gateway features (request validation, API keys, usage plans, custom domain mapping) aren't needed. They support Lambda response streaming natively.

Use API Gateway when you need: multiple functions behind one domain, authentication via Cognito/custom authorizers, request/response transformation, WAF integration, or usage-based throttling.