Serverless Architecture - Introduction to FaaS

What is Serverless

Serverless is an architecture where you delegate server management to cloud providers and focus only on code execution. It doesn’t mean “no servers” but rather “you don’t need to think about servers.”

Benefits: No infrastructure management, automatic scaling, pay only for what you use

Types of Serverless

FaaS (Function as a Service)

Execute functions via event triggers.

// AWS Lambda example
export const handler = async (event) => {
  const name = event.queryStringParameters?.name || 'World';
  return {
    statusCode: 200,
    body: JSON.stringify({ message: `Hello, ${name}!` })
  };
};

BaaS (Backend as a Service)

Provides backend functionality like authentication, databases, and storage as services.

How FaaS Works

flowchart LR
    Event --> Startup["Container startup"]
    Startup --> Exec["Function execution"]
    Exec --> Response
    Response --> Stop

Parallel execution: Functions A, B, C can run simultaneously

Scaling: 0 → 1 → 100 → 1000 → 0 (automatic)

Event Sources

Major FaaS Platforms

Cold Start

When a function runs for the first time, container startup takes time.

Cold Start Mitigation

// Initialize connections outside handler (will be reused)
const db = new Database();

export const handler = async (event) => {
  // db is reused
  return await db.query('SELECT * FROM users');
};

Pricing Model

Pay-per-use Example (AWS Lambda)

Cost = Request count × Execution time × Memory

Free tier: 1M requests, 400,000 GB-seconds/month

Comparison with Traditional Servers

Use Cases

Good Fit

• ✓ Event-driven processing (file processing, webhooks)
• ✓ Irregular batch processing
• ✓ API backends (especially low-medium traffic)
• ✓ Parts of microservices
• ✓ Prototyping, MVPs

Not a Good Fit

• ✗ Consistently high traffic (cost inefficient)
• ✗ Long-running processes (timeout limits)
• ✗ Ultra-low latency required (cold starts)
• ✗ Stateful processing
• ✗ WebSocket (partial support)

Limitations

Implementation Patterns

API Gateway + Lambda

flowchart LR
    Client --> Gateway["API Gateway<br/>(Auth, rate limiting, caching)"]
    Gateway --> Lambda
    Lambda --> DynamoDB

Event Processing Pipeline

flowchart TB
    S3_1["S3 (image upload)"] --> Lambda["Lambda<br/>(thumbnail generation)"]
    Lambda --> S3_2["S3 (save thumbnail)"]
    S3_2 --> SNS["SNS (notification)"]

Scheduled Execution

// serverless.yml
functions:
  dailyReport:
    handler: handler.generateReport
    events:
      - schedule: cron(0 9 * * ? *)  // Daily at 9am

Frameworks

Summary

Serverless is an architecture that reduces infrastructure management burden and lets you focus on development. It’s particularly suited for event-driven processing and irregular workloads. However, there are considerations like cold starts and execution time limits. It’s important to choose between serverless and traditional servers based on your use case.