Serverless in der Praxis: AWS Lambda vs Vercel Functions vs Cloudflare Workers

spinny:~/writing $ vim serverless-aws-lambda-vercel-cloudflare.md

1~
2Serverless Computing ermoeglicht es dir, Code auszufuehren, ohne Server zu verwalten. Du schreibst Funktionen, deployst sie, und die Plattform kuemmert sich um Skalierung, Verfuegbarkeit und Infrastruktur. Im Jahr 2026 dominieren drei Plattformen die Serverless-Landschaft: **AWS Lambda**, **Vercel Serverless Functions** und **Cloudflare Workers**. Jede hat unterschiedliche Staerken und Kompromisse.
3~
4In diesem Artikel vergleichen wir sie mit realen Beispielen, Leistungsueberlegungen und Preisaufschluesselungen.
5~
6## Wie Serverless funktioniert
7~
8```mermaid
9graph LR
10    User -- "HTTP Request" --> Gateway[API Gateway / Edge]
11    Gateway -- "Invoke" --> Function[Serverless Function]
12    Function -- "Response" --> User
13    Function -- "Read/Write" --> DB[(Database)]
14```
15~
16Du deployst eine Funktion. Wenn eine Anfrage eintrifft, fuehrt die Plattform folgendes aus:
171. Startet eine Ausfuehrungsumgebung (oder verwendet eine bereits aktive wieder)
182. Fuehrt deine Funktion aus
193. Gibt die Antwort zurueck
204. Skaliert auf null, wenn inaktiv (du zahlst nicht fuer Leerlaufzeit)
21~
22## Plattformuebersicht
23~
24### AWS Lambda
25~
26Die urspruengliche Serverless-Plattform (gestartet 2014). Die ausgereifteste und funktionsreichste, mit tiefer Integration in das AWS-Oekosystem.
27~
28```javascript
29// AWS Lambda handler
30export const handler = async (event) => {
31  const body = JSON.parse(event.body);
32~
33  const result = await processData(body);
34~
35  return {
36    statusCode: 200,
37    headers: { 'Content-Type': 'application/json' },
38    body: JSON.stringify(result),
39  };
40};
41```
42~
43### Vercel Serverless Functions
44~
45Eng integriert mit Next.js und dem Frontend-Deployment-Workflow. Funktionen werden zusammen mit deinem Frontend ohne Konfiguration deployt.
46~
47```typescript
48// app/api/hello/route.ts (Next.js App Router)
49import { NextResponse } from 'next/server';
50~
51export async function GET(request: Request) {
52  const { searchParams } = new URL(request.url);
53  const name = searchParams.get('name') || 'World';
54~
55  return NextResponse.json({ message: `Hello, ${name}!` });
56}
57```
58~
59### Cloudflare Workers
60~
61Laeuft auf Cloudflares Edge-Netzwerk in ueber 300 Staedten weltweit. Verwendet die V8-Engine (dieselbe wie Chrome) anstelle von Node.js, was extrem schnelle Cold Starts bedeutet.
62~
63```javascript
64// Cloudflare Worker
65export default {
66  async fetch(request, env) {
67    const url = new URL(request.url);
68    const name = url.searchParams.get('name') || 'World';
69~
70    return new Response(
71      JSON.stringify({ message: `Hello, ${name}!` }),
72      { headers: { 'Content-Type': 'application/json' } }
73    );
74  },
75};
76```
77~
78## Funktionsvergleich
79~
80| Funktion | AWS Lambda | Vercel Functions | Cloudflare Workers |
81|---------|-----------|-----------------|-------------------|
82| **Runtime** | Node.js, Python, Go, Rust, Java, .NET | Node.js, Python, Go, Ruby | V8 Isolates (JS/TS, Rust via WASM) |
83| **Max. Ausfuehrungszeit** | 15 Minuten | 60s (Hobby), 300s (Pro) | 30s (kostenlos), 15min (bezahlt) |
84| **Speicher** | 128MB - 10GB | 1024MB - 3008MB | 128MB |
85| **Cold Start** | 100-500ms | 100-300ms | < 5ms |
86| **Deploy-Standort** | Einzelne Region (oder multi mit Aufwand) | Mehrere Regionen | 300+ Edge-Standorte |
87| **Max. Payload** | 6MB (synchron), 256KB (asynchron) | 4.5MB | 100MB |
88| **Integrierter Speicher** | Nein (nutze DynamoDB, S3) | Nein (nutze externe DB) | KV, D1 (SQLite), R2 (S3-kompatibel) |
89| **Preismodell** | Pro Anfrage + Dauer | Im Plan enthalten | Pro Anfrage + Dauer |
90| **Kostenloses Kontingent** | 1M Anfragen/Monat | 100K/Monat (Hobby) | 100K Anfragen/Tag |
91~
92## Cold Starts
93~
94Cold Start ist die Zeit, die benoetigt wird, um eine neue Funktionsinstanz zu initialisieren. Dies ist das groesste Leistungsproblem bei Serverless.
95~
96```mermaid
97graph LR
98    subgraph "Cold Start"
99        A[Request] --> B[Provision Environment]
100        B --> C[Load Code]
101        C --> D[Initialize Runtime]
102        D --> E[Execute Function]
103    end
104~
105    subgraph "Warm Invocation"
106        F[Request] --> G[Execute Function]
107    end
108```
109~
110| Plattform | Typischer Cold Start | Warum |
111|----------|-------------------|-----|
112| **Cloudflare Workers** | < 5ms | V8 Isolates, kein vollstaendiges Runtime noetig |
113| **Vercel Functions** | 100-300ms | Node.js Runtime auf Edge oder regional |
114| **AWS Lambda** | 100-500ms | Vollstaendige Container-Initialisierung |
115| **AWS Lambda (Java)** | 1-5 Sekunden | JVM-Start-Overhead |
116~
117Cloudflare Workers gewinnen bei Cold Starts mit grossem Abstand, da sie V8 Isolates statt Container verwenden.
118~
119## Preisvergleich
120~
121### Kostenloses Kontingent
122~
123| Plattform | Kostenlose Anfragen | Kostenloses Compute |
124|----------|--------------|--------------|
125| **AWS Lambda** | 1M/Monat | 400.000 GB-Sekunden |
126| **Vercel** | 100K/Monat | Im Hobby-Plan enthalten |
127| **Cloudflare Workers** | 100K/Tag (~3M/Monat) | 10ms CPU pro Aufruf |
128~
129### Im grossen Massstab (10M Anfragen/Monat, 50ms durchschnittliche Dauer)
130~
131| Plattform | Geschaetzte monatliche Kosten |
132|----------|----------------------|
133| **AWS Lambda** | ~$2,50 (Anfragen) + ~$4,15 (Compute) = **~$6,65** |
134| **Vercel** | **$20/Monat** (Pro-Plan, beinhaltet Funktionen) |
135| **Cloudflare Workers** | **$5/Monat** (Bezahlplan, beinhaltet 10M Anfragen) |
136~
137Fuer die meisten Anwendungsfaelle ist Cloudflare Workers am guenstigsten. Vercels Preisgestaltung ist einfach, beinhaltet aber die gesamte Plattform (Hosting, CDN, Analytics). AWS Lambda hat die granularste Preisgestaltung.
138~
139## Praxisnahe Anwendungsfaelle
140~
141### AWS Lambda: Am besten fuer
142~
143- **Komplexe Backend-Workflows** - Step Functions, event-gesteuerte Architekturen
144- **Integration mit AWS-Diensten** - S3-Trigger, DynamoDB-Streams, SQS-Warteschlangen
145- **Langfristige Aufgaben** - bis zu 15 Minuten Ausfuehrungszeit
146- **Mehrsprachige Teams** - unterstuetzt die breiteste Palette an Runtimes
147~
148```mermaid
149graph TD
150    S3[S3 Upload] --> Lambda1[Process Image]
151    Lambda1 --> SQS[SQS Queue]
152    SQS --> Lambda2[Generate Thumbnails]
153    Lambda2 --> DDB[DynamoDB]
154    DDB --> Lambda3[Send Notification]
155    Lambda3 --> SNS[SNS / Email]
156```
157~
158### Vercel Functions: Am besten fuer
159~
160- **Next.js-Anwendungen** - API-Routes ohne Konfiguration
161- **Frontend-orientierte Teams** - Frontend und Backend zusammen deployen
162- **Schnelles Prototyping** - git push zum Deployen
163- **Jamstack-Architekturen** - statisches Frontend + Serverless-API
164~
165```typescript
166// app/api/subscribe/route.ts
167import { NextResponse } from 'next/server';
168~
169export async function POST(request: Request) {
170  const { email } = await request.json();
171~
172  // Validate
173  if (!email || !email.includes('@')) {
174    return NextResponse.json(
175      { error: 'Invalid email' },
176      { status: 400 }
177    );
178  }
179~
180  // Save to database
181  await db.subscribers.create({ email });
182~
183  return NextResponse.json({ success: true });
184}
185```
186~
187### Cloudflare Workers: Am besten fuer
188~
189- **APIs mit niedriger Latenz** - Code laeuft an ueber 300 Standorten weltweit
190- **Edge Computing** - Antworten transformieren, A/B-Tests, Personalisierung
191- **APIs mit hohem Volumen** - am guenstigsten im grossen Massstab mit grosszuegigem Gratis-Kontingent
192- **Globale Anwendungen** - Daten nahe an Benutzern mit KV und D1
193~
194```javascript
195// Edge-side A/B test
196export default {
197  async fetch(request, env) {
198    const url = new URL(request.url);
199~
200    // Assign user to variant
201    const cookie = request.headers.get('Cookie') || '';
202    let variant = cookie.includes('ab=b') ? 'b' : 'a';
203~
204    if (!cookie.includes('ab=')) {
205      variant = Math.random() < 0.5 ? 'a' : 'b';
206    }
207~
208    // Fetch the appropriate version
209    const response = await fetch(`${url.origin}/variants/${variant}`);
210    const newResponse = new Response(response.body, response);
211~
212    // Set cookie for consistent experience
213    newResponse.headers.set('Set-Cookie', `ab=${variant}; Path=/; Max-Age=86400`);
214~
215    return newResponse;
216  },
217};
218```
219~
220## Wann welche waehlen
221~
222### Waehle AWS Lambda wenn:
223- Du bereits in das AWS-Oekosystem investiert bist
224- Du langfristige Funktionen brauchst (bis zu 15 Minuten)
225- Du komplexe event-gesteuerte Architekturen benoetigst
226- Du Runtimes jenseits von JavaScript brauchst (Python, Go, Rust, Java)
227~
228### Waehle Vercel Functions wenn:
229- Du mit Next.js oder einem Frontend-Framework entwickelst
230- Du die einfachste Deploy-Erfahrung willst (git push)
231- Dein Team frontend-orientiert ist
232- Du Hosting + Funktionen + CDN in einer Plattform willst
233~
234### Waehle Cloudflare Workers wenn:
235- Du die niedrigstmoegliche Latenz weltweit brauchst
236- Du die guenstigste Option im grossen Massstab willst
237- Du Edge-Computing-Faehigkeiten benoetigst
238- Die Cold-Start-Zeit fuer deinen Anwendungsfall entscheidend ist
239~
240## Kann man sie kombinieren?
241~
242Auf jeden Fall. Eine gaengige Architektur:
243~
244```mermaid
245graph TD
246    User --> CF[Cloudflare Workers\nEdge caching, routing, A/B tests]
247    CF --> Vercel[Vercel\nNext.js frontend + API routes]
248    Vercel --> Lambda[AWS Lambda\nHeavy processing, background jobs]
249    Lambda --> S3[S3 Storage]
250    Lambda --> DB[(Database)]
251```
252~
253- **Cloudflare Workers**: Edge-Routing, Caching, Sicherheit
254- **Vercel Functions**: Frontend-API-Routes, SSR
255- **AWS Lambda**: schwere Backend-Verarbeitung, geplante Aufgaben, Event-Pipelines
256~
257## Fazit
258~
259Serverless ist erheblich gereift. Im Jahr 2026 haengt die Wahl zwischen AWS Lambda, Vercel Functions und Cloudflare Workers von deinem Stack und deinen Prioritaeten ab:
260~
261- **Einfachste Entwicklererfahrung**: Vercel
262- **Am leistungsfaehigsten und flexibelsten**: AWS Lambda
263- **Beste Leistung und Preise**: Cloudflare Workers
264~
265Alle drei sind produktionsreif und praxiserprobt. Beginne mit der, die zu deinem aktuellen Stack passt, und erweitere, wenn deine Anforderungen wachsen.
266~

NORMAL · serverless-aws-lambda-vercel-cloudflare.md [readonly]266 lines · :q to close

2Serverless Computing ermoeglicht es dir, Code auszufuehren, ohne Server zu verwalten. Du schreibst Funktionen, deployst sie, und die Plattform kuemmert sich um Skalierung, Verfuegbarkeit und Infrastruktur. Im Jahr 2026 dominieren drei Plattformen die Serverless-Landschaft: **AWS Lambda**, **Vercel Serverless Functions** und **Cloudflare Workers**. Jede hat unterschiedliche Staerken und Kompromisse.

4In diesem Artikel vergleichen wir sie mit realen Beispielen, Leistungsueberlegungen und Preisaufschluesselungen.

6## Wie Serverless funktioniert

8```mermaid

9graph LR

10 User -- "HTTP Request" --> Gateway[API Gateway / Edge]

11 Gateway -- "Invoke" --> Function[Serverless Function]

12 Function -- "Response" --> User

13 Function -- "Read/Write" --> DB[(Database)]

14```

15~

16Du deployst eine Funktion. Wenn eine Anfrage eintrifft, fuehrt die Plattform folgendes aus:

171. Startet eine Ausfuehrungsumgebung (oder verwendet eine bereits aktive wieder)

182. Fuehrt deine Funktion aus

193. Gibt die Antwort zurueck

204. Skaliert auf null, wenn inaktiv (du zahlst nicht fuer Leerlaufzeit)

21~

22## Plattformuebersicht

23~

24### AWS Lambda

25~

26Die urspruengliche Serverless-Plattform (gestartet 2014). Die ausgereifteste und funktionsreichste, mit tiefer Integration in das AWS-Oekosystem.

27~

28```javascript

29// AWS Lambda handler

30export const handler = async (event) => {

31 const body = JSON.parse(event.body);

32~

33 const result = await processData(body);

34~

35 return {

36 statusCode: 200,

37 headers: { 'Content-Type': 'application/json' },

38 body: JSON.stringify(result),

39 };

40};

41```

42~

43### Vercel Serverless Functions

44~

45Eng integriert mit Next.js und dem Frontend-Deployment-Workflow. Funktionen werden zusammen mit deinem Frontend ohne Konfiguration deployt.

46~

47```typescript

48// app/api/hello/route.ts (Next.js App Router)

49import { NextResponse } from 'next/server';

50~

51export async function GET(request: Request) {

52 const { searchParams } = new URL(request.url);

53 const name = searchParams.get('name') || 'World';

54~

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

56}

57```

58~

59### Cloudflare Workers

60~

61Laeuft auf Cloudflares Edge-Netzwerk in ueber 300 Staedten weltweit. Verwendet die V8-Engine (dieselbe wie Chrome) anstelle von Node.js, was extrem schnelle Cold Starts bedeutet.

62~

63```javascript

64// Cloudflare Worker

65export default {

66 async fetch(request, env) {

67 const url = new URL(request.url);

68 const name = url.searchParams.get('name') || 'World';

69~

70 return new Response(

71 JSON.stringify({ message: `Hello, ${name}!` }),

72 { headers: { 'Content-Type': 'application/json' } }

73 );

74 },

75};

76```

77~

78## Funktionsvergleich

79~

81|---------|-----------|-----------------|-------------------|

85| **Cold Start** | 100-500ms | 100-300ms | < 5ms |

87| **Max. Payload** | 6MB (synchron), 256KB (asynchron) | 4.5MB | 100MB |

91~

92## Cold Starts

93~

94Cold Start ist die Zeit, die benoetigt wird, um eine neue Funktionsinstanz zu initialisieren. Dies ist das groesste Leistungsproblem bei Serverless.

95~

96```mermaid

97graph LR

98 subgraph "Cold Start"

99 A[Request] --> B[Provision Environment]

100 B --> C[Load Code]

101 C --> D[Initialize Runtime]

102 D --> E[Execute Function]

103 end

104~

105 subgraph "Warm Invocation"

106 F[Request] --> G[Execute Function]

107 end

108```

109~

110| Plattform | Typischer Cold Start | Warum |

111|----------|-------------------|-----|

112| **Cloudflare Workers** | < 5ms | V8 Isolates, kein vollstaendiges Runtime noetig |

113| **Vercel Functions** | 100-300ms | Node.js Runtime auf Edge oder regional |

114| **AWS Lambda** | 100-500ms | Vollstaendige Container-Initialisierung |

115| **AWS Lambda (Java)** | 1-5 Sekunden | JVM-Start-Overhead |

116~

117Cloudflare Workers gewinnen bei Cold Starts mit grossem Abstand, da sie V8 Isolates statt Container verwenden.

118~

119## Preisvergleich

120~

121### Kostenloses Kontingent

122~

123| Plattform | Kostenlose Anfragen | Kostenloses Compute |

124|----------|--------------|--------------|

125| **AWS Lambda** | 1M/Monat | 400.000 GB-Sekunden |

126| **Vercel** | 100K/Monat | Im Hobby-Plan enthalten |

127| **Cloudflare Workers** | 100K/Tag (~3M/Monat) | 10ms CPU pro Aufruf |

128~

129### Im grossen Massstab (10M Anfragen/Monat, 50ms durchschnittliche Dauer)

130~

131| Plattform | Geschaetzte monatliche Kosten |

132|----------|----------------------|

133| **AWS Lambda** | ~$2,50 (Anfragen) + ~$4,15 (Compute) = **~$6,65** |

134| **Vercel** | **$20/Monat** (Pro-Plan, beinhaltet Funktionen) |

135| **Cloudflare Workers** | **$5/Monat** (Bezahlplan, beinhaltet 10M Anfragen) |

136~

137Fuer die meisten Anwendungsfaelle ist Cloudflare Workers am guenstigsten. Vercels Preisgestaltung ist einfach, beinhaltet aber die gesamte Plattform (Hosting, CDN, Analytics). AWS Lambda hat die granularste Preisgestaltung.

138~

139## Praxisnahe Anwendungsfaelle

140~

141### AWS Lambda: Am besten fuer

142~

143- **Komplexe Backend-Workflows** - Step Functions, event-gesteuerte Architekturen

144- **Integration mit AWS-Diensten** - S3-Trigger, DynamoDB-Streams, SQS-Warteschlangen

145- **Langfristige Aufgaben** - bis zu 15 Minuten Ausfuehrungszeit

146- **Mehrsprachige Teams** - unterstuetzt die breiteste Palette an Runtimes

147~

148```mermaid

149graph TD

150 S3[S3 Upload] --> Lambda1[Process Image]

151 Lambda1 --> SQS[SQS Queue]

152 SQS --> Lambda2[Generate Thumbnails]

153 Lambda2 --> DDB[DynamoDB]

154 DDB --> Lambda3[Send Notification]

155 Lambda3 --> SNS[SNS / Email]

156```

157~

158### Vercel Functions: Am besten fuer

159~

160- **Next.js-Anwendungen** - API-Routes ohne Konfiguration

161- **Frontend-orientierte Teams** - Frontend und Backend zusammen deployen

162- **Schnelles Prototyping** - git push zum Deployen

163- **Jamstack-Architekturen** - statisches Frontend + Serverless-API

164~

165```typescript

166// app/api/subscribe/route.ts

167import { NextResponse } from 'next/server';

168~

169export async function POST(request: Request) {

170 const { email } = await request.json();

171~

172 // Validate

173 if (!email || !email.includes('@')) {

174 return NextResponse.json(

175 { error: 'Invalid email' },

176 { status: 400 }

177 );

178 }

179~

180 // Save to database

181 await db.subscribers.create({ email });

182~

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

184}

185```

186~

187### Cloudflare Workers: Am besten fuer

188~

189- **APIs mit niedriger Latenz** - Code laeuft an ueber 300 Standorten weltweit

190- **Edge Computing** - Antworten transformieren, A/B-Tests, Personalisierung

191- **APIs mit hohem Volumen** - am guenstigsten im grossen Massstab mit grosszuegigem Gratis-Kontingent

192- **Globale Anwendungen** - Daten nahe an Benutzern mit KV und D1

193~

194```javascript

195// Edge-side A/B test

196export default {

197 async fetch(request, env) {

198 const url = new URL(request.url);

199~

200 // Assign user to variant

201 const cookie = request.headers.get('Cookie') || '';

202 let variant = cookie.includes('ab=b') ? 'b' : 'a';

203~

204 if (!cookie.includes('ab=')) {

205 variant = Math.random() < 0.5 ? 'a' : 'b';

206 }

207~

208 // Fetch the appropriate version

209 const response = await fetch(`${url.origin}/variants/${variant}`);

210 const newResponse = new Response(response.body, response);

211~

212 // Set cookie for consistent experience

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

214~

215 return newResponse;

216 },

217};

218```

219~

220## Wann welche waehlen

221~

222### Waehle AWS Lambda wenn:

223- Du bereits in das AWS-Oekosystem investiert bist

224- Du langfristige Funktionen brauchst (bis zu 15 Minuten)

225- Du komplexe event-gesteuerte Architekturen benoetigst

226- Du Runtimes jenseits von JavaScript brauchst (Python, Go, Rust, Java)

227~

228### Waehle Vercel Functions wenn:

229- Du mit Next.js oder einem Frontend-Framework entwickelst

230- Du die einfachste Deploy-Erfahrung willst (git push)

231- Dein Team frontend-orientiert ist

232- Du Hosting + Funktionen + CDN in einer Plattform willst

233~

234### Waehle Cloudflare Workers wenn:

235- Du die niedrigstmoegliche Latenz weltweit brauchst

236- Du die guenstigste Option im grossen Massstab willst

237- Du Edge-Computing-Faehigkeiten benoetigst

238- Die Cold-Start-Zeit fuer deinen Anwendungsfall entscheidend ist

239~

240## Kann man sie kombinieren?

241~

242Auf jeden Fall. Eine gaengige Architektur:

243~

244```mermaid

245graph TD

246 User --> CF[Cloudflare Workers\nEdge caching, routing, A/B tests]

247 CF --> Vercel[Vercel\nNext.js frontend + API routes]

248 Vercel --> Lambda[AWS Lambda\nHeavy processing, background jobs]

249 Lambda --> S3[S3 Storage]

250 Lambda --> DB[(Database)]

251```

252~

253- **Cloudflare Workers**: Edge-Routing, Caching, Sicherheit

254- **Vercel Functions**: Frontend-API-Routes, SSR

255- **AWS Lambda**: schwere Backend-Verarbeitung, geplante Aufgaben, Event-Pipelines

256~

257## Fazit

258~

259Serverless ist erheblich gereift. Im Jahr 2026 haengt die Wahl zwischen AWS Lambda, Vercel Functions und Cloudflare Workers von deinem Stack und deinen Prioritaeten ab:

260~

261- **Einfachste Entwicklererfahrung**: Vercel

262- **Am leistungsfaehigsten und flexibelsten**: AWS Lambda

263- **Beste Leistung und Preise**: Cloudflare Workers

264~

265Alle drei sind produktionsreif und praxiserprobt. Beginne mit der, die zu deinem aktuellen Stack passt, und erweitere, wenn deine Anforderungen wachsen.

266~