Serverless in de Praktijk: AWS Lambda vs Vercel Functions vs Cloudflare Workers

Serverless computing laat je code draaien zonder servers te beheren. Je schrijft functies, deployt ze, en het platform handelt schaling, beschikbaarheid en infrastructuur af. In 2026 domineren drie platformen het serverless landschap: AWS Lambda, Vercel Serverless Functions en Cloudflare Workers. Elk heeft verschillende sterktes en afwegingen.

In dit artikel vergelijken we ze met echte voorbeelden, prestatie-overwegingen en prijsanalyses.

Hoe Serverless Werkt

Je deployt een functie. Wanneer een verzoek binnenkomt, doet het platform het volgende:

1. Start een uitvoeringsomgeving (of hergebruikt een al opgewarmde)
2. Draait je functie
3. Retourneert de respons
4. Schaalt naar nul wanneer inactief (je betaalt niet voor inactieve tijd)

Platformoverzicht

AWS Lambda

Het originele serverless platform (gelanceerd in 2014). Het meest volwassen en functierijk, met diepe integratie in het AWS-ecosysteem.

// AWS Lambda handler
export const handler = async (event) => {
  const body = JSON.parse(event.body);

  const result = await processData(body);

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(result),
  };
};

Vercel Serverless Functions

Strak geintegreerd met Next.js en de frontend deployment workflow. Functies worden samen met je frontend gedeployed zonder configuratie.

// app/api/hello/route.ts (Next.js App Router)
import { NextResponse } from 'next/server';

export async function GET(request: Request) {
  const { searchParams } = new URL(request.url);
  const name = searchParams.get('name') || 'World';

  return NextResponse.json({ message: `Hello, ${name}!` });
}

Cloudflare Workers

Draait op Cloudflare's edge-netwerk in meer dan 300 steden wereldwijd. Gebruikt de V8-engine (dezelfde als Chrome) in plaats van Node.js, wat extreem snelle cold starts betekent.

// Cloudflare Worker
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    const name = url.searchParams.get('name') || 'World';

    return new Response(
      JSON.stringify({ message: `Hello, ${name}!` }),
      { headers: { 'Content-Type': 'application/json' } }
    );
  },
};

Functievergelijking

Cold Starts

Cold start is de tijd die nodig is om een nieuwe functie-instantie te initialiseren. Dit is de grootste prestatie-zorg bij serverless.

Cloudflare Workers wint cold starts met een enorme marge omdat het V8 isolates gebruikt in plaats van containers.

Prijsvergelijking

Gratis niveau

Op schaal (10M verzoeken/maand, gemiddelde duur 50ms)

Voor de meeste use cases is Cloudflare Workers het goedkoopst. Vercel's prijzen zijn eenvoudig maar omvatten het hele platform (hosting, CDN, analytics). AWS Lambda heeft de meest gedetailleerde prijzen.

Praktijkvoorbeelden

AWS Lambda: Best voor

• Complexe backend workflows - step functions, event-driven architecturen
• Integratie met AWS-diensten - S3 triggers, DynamoDB streams, SQS queues
• Langlopende taken - tot 15 minuten uitvoertijd
• Meertalige teams - ondersteunt het breedste scala aan runtimes

Vercel Functions: Best voor

• Next.js applicaties - zero-config API routes
• Frontend-gerichte teams - deploy frontend en backend samen
• Snel prototypen - git push om te deployen
• Jamstack architecturen - statische frontend + serverless API

// app/api/subscribe/route.ts
import { NextResponse } from 'next/server';

export async function POST(request: Request) {
  const { email } = await request.json();

  // Validate
  if (!email || !email.includes('@')) {
    return NextResponse.json(
      { error: 'Invalid email' },
      { status: 400 }
    );
  }

  // Save to database
  await db.subscribers.create({ email });

  return NextResponse.json({ success: true });
}

Cloudflare Workers: Best voor

• Low-latency API's - code draait op 300+ locaties wereldwijd
• Edge computing - respons transformeren, A/B testen, personalisatie
• High-volume API's - goedkoopst op schaal met royaal gratis niveau
• Globale applicaties - data dicht bij gebruikers met KV en D1

// Edge-side A/B test
export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    // Assign user to variant
    const cookie = request.headers.get('Cookie') || '';
    let variant = cookie.includes('ab=b') ? 'b' : 'a';

    if (!cookie.includes('ab=')) {
      variant = Math.random() < 0.5 ? 'a' : 'b';
    }

    // Fetch the appropriate version
    const response = await fetch(`${url.origin}/variants/${variant}`);
    const newResponse = new Response(response.body, response);

    // Set cookie for consistent experience
    newResponse.headers.set('Set-Cookie', `ab=${variant}; Path=/; Max-Age=86400`);

    return newResponse;
  },
};

Wanneer welke kiezen

Kies AWS Lambda als:

• Je al geinvesteerd bent in het AWS-ecosysteem
• Je langlopende functies nodig hebt (tot 15 minuten)
• Je complexe event-driven architecturen nodig hebt
• Je runtimes buiten JavaScript nodig hebt (Python, Go, Rust, Java)

Kies Vercel Functions als:

• Je bouwt met Next.js of een frontend framework
• Je de eenvoudigste deploy-ervaring wilt (git push)
• Je team frontend-gericht is
• Je hosting + functies + CDN in een platform wilt

Kies Cloudflare Workers als:

• Je de laagst mogelijke latency wereldwijd nodig hebt
• Je de goedkoopste optie op schaal wilt
• Je edge computing mogelijkheden nodig hebt
• Cold start tijd kritisch is voor jouw use case

Kun je ze combineren?

Absoluut. Een veelvoorkomende architectuur:

• Cloudflare Workers: edge routing, caching, beveiliging
• Vercel Functions: frontend API routes, SSR
• AWS Lambda: zware backend verwerking, geplande taken, event pipelines

Conclusie

Serverless is aanzienlijk volwassen geworden. In 2026 hangt de keuze tussen AWS Lambda, Vercel Functions en Cloudflare Workers af van je stack en prioriteiten:

• Eenvoudigste ontwikkelaarservaring: Vercel
• Krachtigst en meest flexibel: AWS Lambda
• Beste prestaties en prijzen: Cloudflare Workers

Alle drie zijn productie-klaar en beproefd. Begin met degene die bij je huidige stack past, en breid uit naarmate je behoeften groeien.