Serverless Introduction

What is Serverless?#

Serverless lets you run code without provisioning or managing servers. You pay only for what you use.

Traditional:  Server runs 24/7 → Pay for uptime
Serverless:   Function runs on request → Pay per execution

Serverless vs Traditional#

When to Use Serverless#

Good For#

• APIs - REST/GraphQL endpoints
• Webhooks - Event handlers
• Cron jobs - Scheduled tasks
• Image processing - On-demand transformations
• Authentication - Token validation
• Low traffic - Intermittent usage

Not Ideal For#

• Long-running processes - >15 min tasks
• WebSockets - Persistent connections (except some platforms)
• Consistent low latency - Cold starts can add delay
• Heavy computation - CPU-intensive tasks

Serverless Platforms#

Basic Function Structure#

All serverless functions follow a similar pattern:

// Request → Handler → Response

export async function handler(request) {
  // 1. Parse input
  const data = await request.json();

  // 2. Do work
  const result = await processData(data);

  // 3. Return response
  return new Response(JSON.stringify(result), {
    headers: { 'Content-Type': 'application/json' },
  });
}

Environment Variables#

All platforms support environment variables for secrets:

# Set via CLI or dashboard
DATABASE_URL=postgres://...
API_KEY=sk_...
JWT_SECRET=...

// Access in function
const apiKey = process.env.API_KEY;

Statelessness#

Serverless functions are stateless. Don't rely on:

• Global variables persisting between requests
• Local file system (may be ephemeral)
• In-memory caches lasting forever

// BAD - State may not persist
let cache = {};

export async function handler(req) {
  cache[req.id] = 'value'; // May be lost
}

// GOOD - Use external storage
import { redis } from './redis';

export async function handler(req) {
  await redis.set(req.id, 'value'); // Persisted
}

Cold Starts#

First request after inactivity is slower:

Request 1: [Cold Start: 500ms] + [Execution: 50ms] = 550ms
Request 2: [Warm] + [Execution: 50ms] = 50ms
Request 3: [Warm] + [Execution: 50ms] = 50ms
... (idle for 15 minutes)
Request 4: [Cold Start: 500ms] + [Execution: 50ms] = 550ms

Minimizing Cold Starts#

1. Keep functions small - Fewer dependencies to load
2. Use lighter runtimes - Node.js is faster than Python
3. Provision concurrency - AWS Lambda provisioned concurrency
4. Edge functions - Cloudflare Workers have near-zero cold starts
5. Keep warm - Scheduled pings (not recommended for cost)

// Lazy load heavy dependencies
let prisma;

export async function handler(req) {
  if (!prisma) {
    const { PrismaClient } = await import('@prisma/client');
    prisma = new PrismaClient();
  }
  // Use prisma...
}

Project Structure#

/api
  /users
    route.js          # /api/users
    [id]/route.js     # /api/users/:id
  /webhooks
    stripe/route.js   # /api/webhooks/stripe
  /auth
    login/route.js    # /api/auth/login

/lib
  db.js               # Shared database connection
  auth.js             # Auth utilities

/middleware
  withAuth.js         # Auth wrapper

Middleware Pattern#

Since serverless functions are isolated, use wrapper patterns:

// middleware/withAuth.js
export function withAuth(handler) {
  return async (request) => {
    const token = request.headers.get('Authorization')?.replace('Bearer ', '');

    if (!token) {
      return new Response(JSON.stringify({ error: 'Unauthorized' }), {
        status: 401,
      });
    }

    try {
      const user = await verifyToken(token);
      request.user = user;
      return handler(request);
    } catch {
      return new Response(JSON.stringify({ error: 'Invalid token' }), {
        status: 401,
      });
    }
  };
}

// api/users/route.js
import { withAuth } from '@/middleware/withAuth';

export const GET = withAuth(async (request) => {
  const users = await getUsers(request.user.id);
  return Response.json({ data: users });
});

Key Takeaways#

1. Pay per use - Great for variable traffic
2. Auto-scaling - Handles traffic spikes
3. Stateless - Use external storage for state
4. Cold starts - Plan for initial latency
5. Time limits - Not for long-running tasks