No Servers? No, Just Other People's Servers.

Serverless: You write code (Function). Cloud Provider manages infrastructure (OS, patching, scaling).

Key Traits:

1. Event-Driven: Code sleeps until triggered (HTTP, S3 upload, Queue message).
2. Stateless: Functions are ephemeral. No local disk persistence.
3. Scale to Zero: If no traffic, you pay $0.

Architecture Patterns

1. Web API (API Gateway + Lambda)

Replaces EC2 + Nginx.

graph LR
    User -->|HTTP Request| APIGw[API Gateway]
    APIGw -->|Invoke| Lambda[Lambda Function]
    Lambda -->|Read/Write| Dynamo[(DynamoDB NoSQL)]

2. Async Processing (S3 + Lambda)

Image resizing pipeline.

1. User uploads photo.jpg to S3 Bucket raw-images.
2. S3 sends event ObjectCreated to Lambda.
3. Lambda resizes image and saves to processed-images.

3. Fan-Out (SNS + multiple Lambdas)

1. User registers.
2. Publish "UserCreated" to SNS Topic.
3. Lambda A (Email Service): Sends Welcome Email.
4. Lambda B (Analytics): Updates Dashboard.

The Cold Start Problem ❄️

The biggest drawback.

1. Request arrives: AWS finds no running container.
2. Download Code: Pulls your zip file (50MB) from S3.
3. Start Container: Spins up Firecracker MicroVM.
4. Init Runtime: Starts Python/Node/Java process.
5. Execute Handler: Runs your code.

Total Latency: 200ms (Node.js) to 10s (Java Spring Boot).

Mitigation:

• Keep Warming: Ping function every 5 mins.
• Provisioned Concurrency: Pay to keep $N$ instances warm.
• Micro-Frameworks: Don't use heavy frameworks (Spring/Django). Use lightweight ones (Flask/Express/Go).

Limitations

Code Example: AWS Lambda (Python)

import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('Users')

def lambda_handler(event, context):
    """
    Triggered by API Gateway.
    event: { "body": "{\"name\": \"Alice\"}" }
    """
    print(f"Received event: {event}")
    
    try:
        # Parse Input
        body = json.loads(event.get('body', '{}'))
        name = body.get('name')
        
        if not name:
            return {"statusCode": 400, "body": "Missing name"}

        # Business Logic
        user_id = save_user(name)
        
        return {
            "statusCode": 200,
            "body": json.dumps({"message": "Success", "id": user_id})
        }
        
    except Exception as e:
        print(f"Error: {e}")
        return {"statusCode": 500, "body": "Internal Error"}

def save_user(name):
    item = {"pk": name, "status": "active"}
    table.put_item(Item=item)
    return name

Interview Tips 💡

• "When NOT to use Serverless?" — Long-running tasks (>15m), WebSocket servers (need stateful connections), Heavy GPU tasks (Training), High-frequency trading (latency variance).
• "Idempotency" — Lambda guarantees "At Least Once" delivery. Your function might run twice for the same event. Make it idempotent! (Check DB before writing).
• "Vendor Lock-in" — Moving Lambda logic to Google Cloud Functions requires rewriting infrastructure code (Terraform helps, but logic is tied to SDKs).

Related Concepts

• Microservices
• Distributed Tracing (X-Ray)
• Message Queues (SQS)