AWS Lambda – Serverless Functions, Event-Driven Architecture, Pricing Model: 20 Interview Questions

Lambda Execution Flow:

Event Source (S3, API Gateway, DynamoDB, etc)
↓
Lambda Runtime Environment
├── Cold Start (new container ~1-3 sec)
└── Warm Execution (reused container <100ms) ↓ Function Code Execution ├── Handler function invoked ├── Context and event processed └── Response returned ↓ Destination (S3, DynamoDB, SNS, etc) Pricing Model: - Requests: $0.20 per 1M requests (First 1M free monthly) - Duration: $0.0000166667 per GB-second (First 400k GB-seconds free monthly) - Provisioned Concurrency: $0.015 per GB-hour - Ephemeral Storage: $0.000000138889 per GB-second Example Cost (1M daily invocations, 512MB, 1 sec): - Requests: (1M/30) * $0.20/1M = $0.007/day - Duration: (1M/30) * 1s * 0.512GB * $0.0000166667 = $0.0089/day - Total: ~$0.02/day = $6/month

import boto3
import json
from PIL import Image
from io import BytesIO

s3_client = boto3.client(‘s3’)
dynamodb = boto3.resource(‘dynamodb’)
sns_client = boto3.client(‘sns’)

def lambda_handler(event, context):
try:
# Parse S3 event
bucket = event[‘Records’][0][‘s3’][‘bucket’][‘name’]
key = event[‘Records’][0][‘s3’][‘object’][‘key’]

# Download image
img_data = s3_client.get_object(Bucket=bucket, Key=key)
img = Image.open(BytesIO(img_data[‘Body’].read()))

# Generate thumbnail
img.thumbnail((150, 150))
thumb_buffer = BytesIO()
img.save(thumb_buffer, format=’PNG’)

# Upload thumbnail
thumb_key = f”thumbnails/{key}”
s3_client.put_object(
Bucket=bucket,
Key=thumb_key,
Body=thumb_buffer.getvalue()
)

# Store metadata in DynamoDB
table = dynamodb.Table(‘ImageMetadata’)
table.put_item(Item={
‘image_id’: key,
‘thumbnail_url’: f”s3://{bucket}/{thumb_key}”,
‘timestamp’: context.aws_request_id
})

# Send SNS notification
sns_client.publish(
TopicArn=’arn:aws:sns:us-east-1:123456789:image-processed’,
Message=f’Thumbnail generated for {key}’
)

return {‘statusCode’: 200, ‘body’: ‘Success’}

except Exception as e:
print(f”Error: {str(e)}”)
# SNS alert on failure
sns_client.publish(
TopicArn=’arn:aws:sns:us-east-1:123456789:error-alerts’,
Message=f’Image processing failed: {str(e)}’
)
raise

Configuration:
Runtime: Python 3.11
Memory: 512 MB
Timeout: 30 seconds
Ephemeral storage: 512 MB
Environment: PILLOW_LAYER_ARN=arn:aws:lambda:…

Cost Analysis (1M images/month):
– Requests: (1M) * $0.20/1M = $0.20
– Duration: (1M * 3s * 512MB / 1024) * $0.0000166667 = $24.00
– Total: ~$25/month

Optimizations:
– Use Lambda layers for dependencies (avoid repackaging)
– Connection pooling for DynamoDB
– Batch operations where possible

Option 1: Provisioned Concurrency
aws lambda put-provisioned-concurrency-config \
–function-name my-function \
–provisioned-concurrent-executions 10 \
–qualifier LIVE

Cost: 10 concurrent * 0.512 GB * 730 hours/month * $0.015 = $56/month
Benefit: Eliminates cold starts

Option 2: Connection Pooling
import psycopg2
from psycopg2 import pool

# Create pool outside handler (reused across invocations)
connection_pool = pool.SimpleConnectionPool(
1, 5,
“dbname=mydb user=postgres password=secret host=rds.aws.com”
)

def lambda_handler(event, context):
conn = connection_pool.getconn()
try:
# Use connection
cursor = conn.cursor()
cursor.execute(“SELECT * FROM users”)
finally:
connection_pool.putconn(conn)

Cost: $0 (included in Lambda execution)
Benefit: Faster initialization, reuses DB connections

Option 3: Language Choice
Cold Start Times:
– Python: ~600ms
– Node.js: ~400ms
– Go: ~100ms (fastest)
– Java: ~1200ms (slowest)

Recommendation for 100 req/hour:
– Use connection pooling (free cost benefit)
– Node.js or Go (400-100ms overhead acceptable)
– Provisioned concurrency only if <100ms required Cost-Benefit Trade-off: - No optimization: 100 req/hour * 400ms = 40s/hour overhead - Connection pooling: saves database init (~200ms) = $0 cost - Provisioned concurrency: eliminates all (~100%) but $56/month

Current Configuration:
Reserved Concurrency: 1,000
Unreserved (burst): 1,000 (AWS account default)
Total available: 2,000

Scenario: 3,000 concurrent requests arrive
– First 2,000 execute normally
– Next 1,000 throttled (HTTP 429)

Solution 1: Increase Reserved Concurrency
aws lambda put-function-concurrency \
–function-name my-function \
–reserved-concurrent-executions 3000

Cost: Provisioned concurrency for 3000 concurrent
Monthly: 3000 * 0.512 GB * 730 hours * $0.015 = $16,848

Solution 2: Implement Burst and Queue
# Use SQS for buffering
– API Gateway → SQS queue → Lambda
– Lambda processes at max concurrency (1,000)
– Excess requests wait in queue
– Process time: queue depth / (concurrency * throughput)

Cost: SQS ~$0.40 per 1M requests
Benefit: No throttling, users don’t experience errors

Solution 3: Auto-Scale Reserved Concurrency
aws lambda update-function-concurrency \
–function-name my-function \
–reserved-concurrent-executions 2000

Monitor CloudWatch: Throttles metric
If throttles > threshold, increase reserved concurrency

Recommended: Option 2 (SQS buffering)
– Handles burst without limiting throughput
– Costs ~$0.40/month (vs $16k for provisioned concurrency)
– Users experience queue delay (acceptable vs throttling)

VPC Configuration:
aws lambda update-function-configuration \
–function-name my-function \
–vpc-config SubnetIds=subnet-12345,subnet-67890 \
–security-group-ids sg-12345

Security Group Rules (Lambda → RDS):
– Protocol: TCP
– Port: 5432 (PostgreSQL)
– Source: Lambda security group
– Direction: Egress

RDS Security Group:
– Protocol: TCP
– Port: 5432
– Source: Lambda security group
– Direction: Ingress

VPC Cold Start Penalty:
– Without VPC: 100ms cold start
– With VPC: 1-2 seconds cold start (ENI attachment)
– Mitigation: Provisioned concurrency

Code Example with Connection Pooling:
import psycopg2
from psycopg2 import pool
import os

# Initialize pool (outside handler, persists across invocations)
db_pool = None

def get_db_pool():
global db_pool
if db_pool is None:
db_pool = pool.SimpleConnectionPool(
1, 5,
dbname=os.environ[‘DB_NAME’],
user=os.environ[‘DB_USER’],
password=os.environ[‘DB_PASS’],
host=os.environ[‘DB_HOST’]
)
return db_pool

def lambda_handler(event, context):
conn = get_db_pool().getconn()
try:
cursor = conn.cursor()
cursor.execute(“SELECT * FROM users WHERE id = %s”, (event[‘user_id’],))
result = cursor.fetchone()
return {‘statusCode’: 200, ‘body’: result}
finally:
get_db_pool().putconn(conn)

Cost Impact:
– Without VPC: $0.008/invocation
– With VPC + provisioned concurrency: $0.008 + $0.015/GB-hour

Cost Optimization Strategy:

1. Right-size Memory Allocation:
Memory determines CPU (linear), cost (linear), execution time (inverse)

Function A: 512MB, 5 sec execution = 2.56 GB-sec cost
Cost: 2.56 * $0.0000166667 = $0.00004

Try 1024MB: 2.5 sec execution = 2.56 GB-sec (same!)
Cost: 2.56 * $0.0000166667 = $0.00004 (same, but faster)

Try 256MB: 10 sec execution = 2.56 GB-sec (same!)
Cost: 2.56 * $0.0000166667 = $0.00004 (same, but slower)

Insight: Execution time dominates. Higher memory speeds up execution,
often without increasing total GB-seconds cost.

2. Identify Inefficient Functions:
– List all functions with CloudWatch logs
– Sort by: Duration * Memory * Invocations
– Focus on top 10% by cost

CloudWatch Insights Query:
fields @duration, @memoryUsed, @maxMemoryUsed
| stats avg(@duration) as avgTime,
max(@maxMemoryUsed) as maxMem,
pct(@duration, 99) as p99Time
| filter pct(@maxMemoryUsed/@memorySize, 100) > 0.8

3. Consolidate Small Functions:
– 50 functions with <100 invocations/month - Consolidate into 5 multi-purpose functions - Savings: Request costs (first 1M free, then $0.20/1M) 4. Batch Invocations: - Instead of 1 invocation/second: - Batch 100 events, invoke 1x/100 seconds - Reduces invocation count 100x - Savings: $0.20 per 1M requests Cost Breakdown (Current): - 100M monthly invocations - Average memory: 512MB - Average duration: 3 seconds - Total GB-seconds: 100M * (512/1024) * 3 = 150M GB-sec - Cost: 100M * $0.20/1M + 150M * $0.0000166667 = $20 + $2,500 = $2,520/month Optimized Configuration: 1. Right-size memory: Reduce avg duration by 20% = $2,500 * 0.8 = $2,000 2. Consolidate functions: Save 40% on requests = $20 * 0.6 = $12 3. Batch invocations: Reduce count 50% = $12 * 0.5 = $6 Total optimized: $2,006/month Savings: $2,520 - $2,006 = $514 (20% reduction) Additional: Reserved Capacity (if predictable) - Save 35% on compute costs - Cost: 150M GB-sec * $0.0000166667 * 0.35 = $87.50/month for reservation - Savings: $2,500 * 0.35 - $87.50 = $787.50 - $87.50 = $700/month - Total optimized: $2,006 - $700 = $1,306/month - Total savings: $2,520 - $1,306 = $1,214 (48% reduction!)