Serverless & FaaS Architecture: Build Without Managing Servers

// handler.ts — A simple AWS Lambda function
import { APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
 
// Initialization code — runs ONCE per cold start
const dbClient = new DatabaseClient(process.env.DATABASE_URL!);
 
// Handler — runs on EVERY invocation
export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  const { httpMethod, path, body } = event;
 
  if (httpMethod === "GET" && path === "/api/users") {
    const users = await dbClient.query("SELECT * FROM users LIMIT 50");
    return {
      statusCode: 200,
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(users),
    };
  }
 
  if (httpMethod === "POST" && path === "/api/users") {
    const { name, email } = JSON.parse(body || "{}");
    const user = await dbClient.query(
      "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *",
      [name, email]
    );
    return {
      statusCode: 201,
      body: JSON.stringify(user),
    };
  }
 
  return { statusCode: 404, body: "Not Found" };
};

// app/api/users/route.ts — Next.js Route Handler (runs as serverless)
import { NextRequest, NextResponse } from "next/server";
import { neon } from "@neondatabase/serverless";
 
const sql = neon(process.env.DATABASE_URL!);
 
export async function GET(request: NextRequest) {
  const searchParams = request.nextUrl.searchParams;
  const limit = searchParams.get("limit") || "50";
 
  const users = await sql`SELECT * FROM users LIMIT ${limit}`;
 
  return NextResponse.json(users);
}
 
export async function POST(request: NextRequest) {
  const { name, email } = await request.json();
 
  const [user] = await sql`
    INSERT INTO users (name, email)
    VALUES (${name}, ${email})
    RETURNING *
  `;
 
  return NextResponse.json(user, { status: 201 });
}

// src/functions/getUsers.ts
import { app, HttpRequest, HttpResponseInit } from "@azure/functions";
 
app.http("getUsers", {
  methods: ["GET"],
  authLevel: "anonymous",
  route: "users",
  handler: async (request: HttpRequest): Promise<HttpResponseInit> => {
    const users = await db.query("SELECT * FROM users");
    return {
      status: 200,
      jsonBody: users,
    };
  },
});

// ❌ One giant function with many dependencies
import express from "express";
import mongoose from "mongoose";
import redis from "redis";
import { S3Client } from "@aws-sdk/client-s3";
import sharp from "sharp"; // Image processing — heavy!
// 50MB deployment package, slow cold start
 
// ✅ Focused function with minimal dependencies
import { neon } from "@neondatabase/serverless"; // ~200KB
// 2MB deployment package, fast cold start

# serverless.yml
functions:
  api:
    handler: handler.main
    provisionedConcurrency: 5  # 5 instances always warm

// ✅ Database client created ONCE, reused across invocations
const sql = neon(process.env.DATABASE_URL!);
 
export async function handler(event: any) {
  // sql is already initialized on warm starts
  const result = await sql`SELECT 1`;
  return { statusCode: 200, body: "OK" };
}

// ❌ WRONG — Stateful: relies on in-memory state
let requestCount = 0;  // Resets on cold start, not shared across instances
 
export async function handler(event: any) {
  requestCount++;  // Unreliable! Different instances have different counts
  return { body: `Request #${requestCount}` };
}

// ✅ CORRECT — Stateless: uses external storage
import { Redis } from "@upstash/redis";
 
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_URL!,
  token: process.env.UPSTASH_REDIS_TOKEN!,
});
 
export async function handler(event: any) {
  const count = await redis.incr("request-count");
  return { body: `Request #${count}` };
}

// Vercel: app/api/webhook/route.ts
export async function POST(request: NextRequest) {
  const payload = await request.json();
  await processWebhook(payload);
  return NextResponse.json({ received: true });
}

// AWS Lambda: SQS trigger
export async function handler(event: SQSEvent) {
  for (const record of event.Records) {
    const message = JSON.parse(record.body);
    await processOrder(message);
  }
}

// Vercel: app/api/cron/daily-report/route.ts
export async function GET(request: NextRequest) {
  // Verify cron secret
  const authHeader = request.headers.get("authorization");
  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  const report = await generateDailyReport();
  await sendReportEmail(report);
  return NextResponse.json({ success: true });
}

// vercel.json
{
  "crons": [
    {
      "path": "/api/cron/daily-report",
      "schedule": "0 9 * * *"
    }
  ]
}

// AWS Lambda: S3 trigger — process uploaded images
export async function handler(event: S3Event) {
  for (const record of event.Records) {
    const bucket = record.s3.bucket.name;
    const key = record.s3.object.key;
 
    // Download, resize, and upload thumbnail
    const image = await s3.getObject({ Bucket: bucket, Key: key });
    const thumbnail = await sharp(image.Body).resize(200, 200).toBuffer();
    await s3.putObject({
      Bucket: bucket,
      Key: `thumbnails/${key}`,
      Body: thumbnail,
    });
  }
}

// Supabase: Database webhook on new user
// Triggers when a row is inserted into the "users" table
export async function handler(event: any) {
  const newUser = event.record;
  await sendWelcomeEmail(newUser.email);
  await createDefaultSettings(newUser.id);
}

// Neon — serverless Postgres with HTTP driver
import { neon } from "@neondatabase/serverless";
 
const sql = neon(process.env.DATABASE_URL!);
 
export async function handler() {
  // HTTP-based query — no persistent connection needed
  const users = await sql`SELECT * FROM users WHERE active = true`;
  return { statusCode: 200, body: JSON.stringify(users) };
}

// Neon with connection pooling
// Connection string uses the pooler endpoint
const sql = neon(process.env.DATABASE_URL!);
// DATABASE_URL=postgres://user:pass@ep-xxx-pooler.us-east-2.aws.neon.tech/neondb

import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
 
const client = new DynamoDBClient({});
 
export async function handler(event: any) {
  const result = await client.send(
    new GetItemCommand({
      TableName: "Users",
      Key: { userId: { S: event.pathParameters.id } },
    })
  );
  return { statusCode: 200, body: JSON.stringify(result.Item) };
}

// Simple chaining — each function calls the next
export async function validateOrder(order: Order) {
  validateItems(order.items);
  validateAddress(order.shippingAddress);
 
  // Call next function
  await processPayment(order);
}
 
async function processPayment(order: Order) {
  const payment = await stripe.charges.create({
    amount: order.total,
    currency: "usd",
  });
 
  await reserveInventory(order, payment.id);
}

// Fan-out: Split work into parallel tasks
export async function processLargeDataset(event: any) {
  const records = await fetchRecords();
  const batches = chunk(records, 100); // Split into batches of 100
 
  // Fan-out: invoke parallel Lambda functions
  const promises = batches.map((batch, index) =>
    lambda.invoke({
      FunctionName: "processBatch",
      Payload: JSON.stringify({ batch, batchIndex: index }),
    })
  );
 
  const results = await Promise.all(promises);
 
  // Fan-in: aggregate results
  const totalProcessed = results.reduce(
    (sum, r) => sum + JSON.parse(r.Payload!).processed,
    0
  );
  return { totalProcessed };
}

// AWS Step Functions state machine (simplified)
{
  "StartAt": "ValidateOrder",
  "States": {
    "ValidateOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:validateOrder",
      "Next": "ProcessPayment",
      "Catch": [{ "ErrorEquals": ["ValidationError"], "Next": "OrderFailed" }]
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:processPayment",
      "Retry": [{ "ErrorEquals": ["TimeoutError"], "MaxAttempts": 3 }],
      "Next": "ReserveInventory",
      "Catch": [{ "ErrorEquals": ["PaymentDeclined"], "Next": "OrderFailed" }]
    },
    "ReserveInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:reserveInventory",
      "Next": "SendConfirmation"
    },
    "SendConfirmation": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123:function:sendConfirmation",
      "End": true
    },
    "OrderFailed": {
      "Type": "Fail",
      "Cause": "Order processing failed"
    }
  }
}

Traditional server:
  1 EC2 t3.medium = $30/month (running 24/7, even at 2 AM with zero traffic)
 
Serverless (AWS Lambda):
  Price = (invocations × $0.20/million) + (duration × $0.0000166667/GB-second)
 
  Example: 1 million requests/month, 200ms average, 256MB memory
  = (1M × $0.20/M) + (1M × 0.2s × 0.25GB × $0.0000166667)
  = $0.20 + $0.83
  = $1.03/month

// sst.config.ts
export default {
  config() {
    return { name: "my-app", region: "us-east-1" };
  },
  stacks(app) {
    app.stack(function API({ stack }) {
      const api = new Api(stack, "api", {
        routes: {
          "GET /users": "packages/functions/src/users.list",
          "POST /users": "packages/functions/src/users.create",
        },
      });
      stack.addOutputs({ ApiEndpoint: api.url });
    });
  },
};

# serverless.yml
service: my-api
provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
 
functions:
  getUsers:
    handler: src/handlers/users.getAll
    events:
      - http:
          path: /users
          method: get
 
  processOrder:
    handler: src/handlers/orders.process
    events:
      - sqs:
          arn: !GetAtt OrderQueue.Arn
          batchSize: 10
 
resources:
  Resources:
    OrderQueue:
      Type: AWS::SQS::Queue

# template.yaml
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
 
Resources:
  GetUsersFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/users.getAll
      Runtime: nodejs20.x
      Events:
        GetUsers:
          Type: Api
          Properties:
            Path: /users
            Method: get

Monday morning: 10,000 requests/minute
Saturday night: 50 requests/minute
→ Serverless auto-scales and costs almost nothing when idle

Daily report generation → 1 Lambda invocation per day
Weekly email digest → 1 invocation per week
→ Pay for seconds of compute, not 24/7 server