Serverless Architecture: AWS Lambda, Vercel and Cloud Functions

What is Serverless?

Serverless is a cloud computing model that allows you to run code without managing servers. Servers still exist but you don't manage them.

FaaS (Function as a Service): You deploy your code as a function. Cloud provider runs the function when a request arrives and returns the result.

BaaS (Backend as a Service): You use backend services like database, authentication, storage as managed. Like Firebase, Supabase.

Advantages: No server management, automatic scaling, pay-per-use, zero idle cost.

AWS Lambda

AWS Lambda is AWS's serverless compute service. Supports Node.js, Python, Java, Go, .NET, Ruby runtimes.

Handler: Entry point of the function. Defined as exports.handler = async (event, context) => { ... }.

Trigger: Events that trigger the Lambda function. API Gateway (HTTP), S3 (file upload), DynamoDB (data change), SQS (message queue).

Cold start: Function needs to be initialized on first call. This creates 100ms-1s latency. Can reduce cold start with provisioned concurrency.

Limits: Maximum 15 minutes execution time, 10 GB memory, 10 GB ephemeral storage. Optimize timeout and memory settings.

Vercel and Netlify

Vercel: Serverless platform optimized for frameworks like Next.js, Nuxt, SvelteKit. Edge Functions and Serverless Functions support.

Netlify: Static site hosting + serverless functions. Add backend logic with Netlify Functions (AWS Lambda based).

Edge Functions: Functions running at the edge with Cloudflare Workers or Vercel Edge Runtime. Ultra-low latency.

Advantages: Automatic deploy on git push, preview deployments, global CDN, automatic HTTPS. Excellent developer experience.

Usage: JAMstack applications, API endpoints, form handling, image optimization, authentication.

Cold Start and Performance

Cold start: Container needs to be started when function is first called. This adds latency. Warm functions are faster.

Reduction strategies: Provisioned concurrency (AWS Lambda), keep-alive (periodic ping), smaller bundle, faster runtime (Node.js > Java).

Memory optimization: More memory = more CPU. Can reduce cold start time by increasing memory.

Connection pooling: Create database connections outside the function (global scope). Don't open new connection on each call.

Monitoring: Monitor cold start time and error rate with CloudWatch (AWS), Vercel Analytics.

Serverless Best Practices

Stateless: Functions should be stateless. Store state in external storage (DynamoDB, Redis).

Idempotency: Running function multiple times should produce same result. Should be safe for retries and duplicate events.

Error handling: Catch errors and send to dead letter queue (DLQ). Define retry mechanism.

Security: Least privilege IAM roles. Secret management with environment variables. Input validation.

Cost optimization: Optimize memory and timeout. Reduce unnecessary invocations. Use provisioned concurrency carefully.

Serverless vs Container vs VM

Serverless: Zero management, automatic scaling, pay-per-use. Ideal for short-lived, event-driven operations.

Container (Docker/K8s): More control, long-running operations, stateful applications. Requires orchestration.

VM: Full control, legacy applications, special hardware requirements. Highest management cost.

Selection: Short, event-driven operations → Serverless. Long-running, stateful applications → Container. Legacy, special requirements → VM.