Serverless Interview Guide

Lambda vs EC2 vs Fargate — Cost Comparison

Lambda Limits (Know These for Interviews)

• Memory: 128 MB – 10,240 MB (10 GB)
• Timeout: Max 15 minutes
• Payload: 6 MB sync, 256 KB async
• Concurrency: 1,000 default (can request increase to 10,000+)
• Deployment: 50 MB zipped, 250 MB unzipped (use container images for up to 10 GB)
• Graviton: arm64 architecture gives 20% better price-performance

A fully serverless web application on AWS — the #1 whiteboard question for Solutions Architect interviews:

Architecture (Layer by Layer)

HTTP API vs REST API — Which to Choose

Cost model: ~$5-20/month for 1M requests. Zero traffic = ~$0. EC2 equivalent: $50-100+/month minimum.

AWS Lambda as an inline transformation step in data pipelines — zero infrastructure, pay-per-execution:

Transform Patterns (Common Interview Scenarios)

Firehose + Lambda Architecture (Know This Flow)

Producers (IoT, apps, Kinesis Agent) → Kinesis Data Firehose → Lambda Transform (enrich/filter/convert) → S3 / Redshift / OpenSearch. Buffer: 60-900 seconds or 1-128 MB (whichever hits first). Failed records go to a dead-letter S3 prefix.

AWS Step Functions is the orchestration service for serverless workflows — essential for any multi-step process:

Standard vs Express Workflows

Common Patterns

• Saga Pattern: Orchestrate distributed transactions with compensating actions. If step 3 fails, Step Functions automatically calls undo functions for steps 1 and 2.
• Fan-out/Fan-in: Map state processes items in parallel (e.g., process 1,000 images concurrently), then collect results.
• Human Approval: Pause workflow with a task token, resume when a human approves via callback (e.g., expense approvals, content moderation).
• Error Handling: Built-in Retry (with exponential backoff) and Catch (route errors to fallback states) at every step.

Amazon EventBridge is the central nervous system of modern serverless architectures — a serverless event bus for building event-driven systems:

EventBridge vs SNS vs SQS — Decision Framework

Key Features for Architects

• Archive & Replay: Replay past events for debugging, testing, or backfilling — unique to EventBridge.
• Schema Registry: Auto-discovers event schemas from your bus. Generates code bindings (TypeScript, Python, Java).
• Pipes: Point-to-point integrations between sources (SQS, Kinesis, DynamoDB Streams) and targets with optional enrichment Lambda.
• Scheduler: Cron and rate-based scheduling with one-time or recurring events. Replaces CloudWatch Events for scheduled tasks.

Cold starts are the most-asked Lambda question in architect interviews. Know every mitigation strategy:

What Causes Cold Starts

When Lambda has no warm execution environment available, it must: 1) Download your code, 2) Start the runtime, 3) Run your initialization code (SDK clients, DB connections). This adds 100ms–10s depending on runtime, package size, and VPC configuration.

Cold Start Duration by Runtime

Mitigation Strategies (Most to Least Impactful)

1. Provisioned Concurrency — Pre-warms N execution environments. Eliminates cold starts completely but costs money (~$0.015/GB-hour). Use for latency-sensitive APIs.
2. SnapStart (Java) — Snapshots the initialized JVM after init. Restores from snapshot on cold start (~200ms vs 6s). Free. Only for Java 11+.
3. Smaller packages — Remove unused dependencies. Use Lambda Layers for shared code. Use tree-shaking (webpack for Node.js). Smaller package = faster download.
4. Lazy initialization — Initialize SDK clients and DB connections outside the handler (global scope) so they persist across warm invocations. But initialize lazily (only when first needed, not at module load).
5. Choose lighter runtimes — Python/Node.js over Java unless you need the JVM. Consider Go/Rust for performance-critical functions.
6. Avoid VPC unless necessary — VPC Lambda used to add 10s of cold start. Since Hyperplane (2019), penalty is minimal (~1s), but only put Lambda in VPC if it accesses VPC resources.

Understanding Lambda concurrency is critical for production architectures — it's the #1 cause of unexpected throttling:

Concurrency Types

Concurrency Formula

Concurrent executions = Invocations/second × Average duration (seconds)

Example: 100 requests/sec × 0.5 sec duration = 50 concurrent executions. If your function takes 2 seconds, the same 100 req/sec needs 200 concurrent executions.

Throttling Behavior

• Synchronous (API Gateway): Returns 429 Too Many Requests immediately. Client must retry.
• Asynchronous (S3, SNS): Lambda retries automatically (2 retries with backoff), then sends to DLQ/destination.
• Stream (Kinesis, DynamoDB): Blocks the shard until capacity available. Records accumulate but aren't lost.

When to put Lambda in a VPC and what to watch out for — a frequently tested topic:

When You NEED Lambda in VPC

• Accessing RDS / Aurora databases in private subnets
• Accessing ElastiCache (Redis / Memcached)
• Accessing OpenSearch clusters in VPC
• Connecting to on-premises resources via VPN / Direct Connect
• Compliance requirements mandating private network traffic only

When You DON'T Need Lambda in VPC

• Calling AWS APIs (S3, DynamoDB, SQS) — use VPC Endpoints or public endpoints
• Calling external APIs over the internet
• Simple event processing without VPC resource access

VPC Lambda — Before and After Hyperplane (2019)

Cost Trap: NAT Gateway

VPC Lambda needs a NAT Gateway for internet access and for calling AWS services without VPC Endpoints. At $0.045/GB data processing + $0.045/hr, this can cost $500+/month even for moderate traffic. Mitigation: add VPC Endpoints for S3 (Gateway, free) and DynamoDB (Gateway, free).

Serverless is a top interview domain. These questions test your understanding of Lambda internals, event-driven patterns, and when serverless is NOT the right choice.

1. A Lambda function has cold starts averaging 3 seconds. Users complain about slow API responses. Walk me through every option to reduce cold start latency.
   Answer Guide

   Provisioned Concurrency (pre-warm instances, costs money), SnapStart (Java — snapshots initialized state), smaller deployment packages, avoid VPC unless necessary, use lighter runtimes (Python/Node over Java), lazy initialization of SDK clients, and Lambda Layers for shared dependencies.
2. Design an order processing workflow: validate order → charge payment → reserve inventory → send confirmation email. If payment fails after inventory is reserved, how do you handle rollback? Which AWS service orchestrates this?
   Answer Guide

   Step Functions (Standard Workflow) with compensation pattern. Each step has a corresponding undo step. If ChargePayment fails → call ReleaseInventory. Use Step Functions' built-in error handling (Catch/Retry). Discuss orchestration (Step Functions) vs choreography (EventBridge + SQS).
3. Explain Lambda concurrency. Your function has an account limit of 1,000 concurrent executions. You have 10 Lambda functions. One rogue function consumes 900 concurrency, throttling all others. How do you prevent this?
   Answer Guide

   Reserved Concurrency — allocate a guaranteed pool per function (e.g., 100 for critical functions). The rogue function gets a cap. Remaining unreserved pool is shared. Discuss: reserved concurrency also acts as a throttle (requests beyond the limit get throttled, not queued).
4. When would you choose EventBridge over SNS + SQS? Design an event-driven architecture for a system where 15 different consumers need to react to "order placed" events with different filtering criteria.
   Answer Guide

   EventBridge — content-based filtering (rules match on event body fields), schema registry, archive/replay, cross-account delivery. SNS — simple fan-out, filter on message attributes (limited). For 15 consumers with different filters, EventBridge rules are cleaner than 15 SNS filter policies.
5. A Lambda function processes SQS messages. Under high load, some messages are processed twice, causing duplicate database entries. How do you make the system idempotent?
   Answer Guide

   Idempotency key in DynamoDB (conditional write: PutItem with condition attribute_not_exists). Lambda Powertools provides a built-in idempotency decorator. Also: enable SQS FIFO with deduplication for exactly-once delivery (5-minute dedup window), or use DynamoDB conditional writes as the last line of defense.
6. Compare Step Functions Standard vs Express workflows. An image processing pipeline processes 10,000 images per minute, each taking 30 seconds. Which type and why?
   Answer Guide

   Express Workflows — for high-volume, short-duration (up to 5 min), lower cost ($0.000025/transition vs $0.025/transition). 10K images/min with Standard would cost 100x more. Trade-off: Express is at-most-once (no built-in exactly-once), no visual execution history in console. Standard for long-running, Express for high-throughput.
7. Your serverless API (API Gateway + Lambda) works perfectly at 100 requests/second but returns 429 errors at 1,000 requests/second. Walk through all the potential throttling points.
   Answer Guide

   API Gateway default: 10,000 req/s account limit (per region), per-stage throttling. Lambda: 1,000 concurrent executions default, reserved concurrency limits. DynamoDB: provisioned capacity throttling. Check CloudWatch metrics for each service's throttle count. Request limit increases or switch to provisioned concurrency.
8. When would you NOT use serverless? Give three concrete scenarios where EC2 or containers are a better choice than Lambda.
   Answer Guide

   1) Long-running processes (>15 min) — batch ETL, video transcoding. 2) Consistent high traffic (millions of req/s steady) — Lambda per-request pricing exceeds EC2 at ~1M requests/hour. 3) Applications needing persistent connections — WebSockets, gRPC streaming, stateful sessions. Also: GPU workloads, compliance requiring specific OS hardening.
9. Design a serverless data pipeline: ingest data from 50 IoT devices (1 event/second each), transform the data, and store it for analytics. Which services would you use?
   Answer Guide

   IoT Core → Kinesis Data Firehose (batching + buffering) → Lambda transform (enrich/filter) → S3 (Parquet format for Athena). For real-time: IoT Core → Lambda → DynamoDB for live dashboards. Discuss: Firehose handles batching and delivery guarantees, reducing Lambda invocations vs processing each event individually.
10. A Lambda function in a VPC takes 10+ seconds for cold starts (vs 1 second without VPC). Explain why this happens and how AWS has improved it. Is VPC still slow for Lambda in 2025?
    Answer Guide

    Before 2019: Lambda created an ENI per cold start (10-30s). After Hyperplane (2019): ENIs are pre-provisioned and shared — cold starts reduced to ~1s even in VPC. In 2025, there's minimal penalty. But: still need NAT Gateway for internet access from VPC Lambda, which adds cost. Only put Lambda in VPC if it needs to access VPC resources (RDS, ElastiCache).