1~
2Pinapayagan ka ng serverless computing na magpatakbo ng code nang hindi namamahala ng mga server. Sumulat ka ng mga function, i-deploy ang mga ito, at hahawakan ng platform ang scaling, availability, at infrastructure. Sa 2026, tatlong platform ang nangingibabaw sa serverless landscape: **AWS Lambda**, **Vercel Serverless Functions**, at **Cloudflare Workers**. Bawat isa ay may iba't ibang lakas at trade-off.
3~
4Sa artikulong ito, inihahambing natin sila gamit ang mga tunay na halimbawa, mga konsiderasyon sa performance, at pagsusuri ng presyo.
5~
6## Paano Gumagana ang Serverless
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~
16Mag-deploy ka ng function. Kapag dumating ang isang request, ang platform ay:
171. Naglulunsad ng execution environment (o ginagamit muli ang isang naka-warm na)
182. Pinapatakbo ang iyong function
193. Ibinabalik ang response
204. Nag-scale sa zero kapag idle (hindi ka nagbabayad para sa idle time)
21~
22## Pangkalahatang-ideya ng Platform
23~
24### AWS Lambda
25~
26Ang orihinal na serverless platform (inilunsad noong 2014). Ang pinaka-mature at pinakamaraming feature, na may malalim na integration sa AWS ecosystem.
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~
45Mahigpit na naka-integrate sa Next.js at sa frontend deployment workflow. Ang mga function ay naide-deploy kasama ng iyong frontend nang walang configuration.
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~
61Tumatakbo sa edge network ng Cloudflare sa mahigit 300 lungsod sa buong mundo. Gumagamit ng V8 engine (katulad ng Chrome) sa halip na Node.js, na nangangahulugang napakabilis na cold start.
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## Paghahambing ng mga Feature
79~
80| Feature | 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 na oras ng pagpapatakbo** | 15 minuto | 60s (Hobby), 300s (Pro) | 30s (libre), 15min (bayad) |
84| **Memory** | 128MB - 10GB | 1024MB - 3008MB | 128MB |
85| **Cold start** | 100-500ms | 100-300ms | < 5ms |
86| **Lokasyon ng deploy** | Isang rehiyon (o marami na may pagsisikap) | Maraming rehiyon | 300+ edge na lokasyon |
87| **Max na payload** | 6MB (synchronous), 256KB (asynchronous) | 4.5MB | 100MB |
88| **Kasama na storage** | Hindi (gamitin ang DynamoDB, S3) | Hindi (gamitin ang external DB) | KV, D1 (SQLite), R2 (S3-compatible) |
89| **Modelo ng presyo** | Bawat request + tagal | Kasama sa plan | Bawat request + tagal |
90| **Libreng tier** | 1M request/buwan | 100K/buwan (Hobby) | 100K request/araw |
91~
92## Cold Starts
93~
94Ang cold start ay ang oras na kailangan para i-initialize ang bagong function instance. Ito ang pinakamalaking performance concern sa 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| Platform | Karaniwang Cold Start | Bakit |
111|----------|-------------------|-----|
112| **Cloudflare Workers** | < 5ms | V8 isolate, hindi kailangan ng buong runtime |
113| **Vercel Functions** | 100-300ms | Node.js runtime sa edge o regional |
114| **AWS Lambda** | 100-500ms | Buong container initialization |
115| **AWS Lambda (Java)** | 1-5 segundo | JVM startup overhead |
116~
117Nanalo ang Cloudflare Workers sa cold starts nang malaking agwat dahil gumagamit sila ng V8 isolate sa halip na container.
118~
119## Paghahambing ng Presyo
120~
121### Libreng Tier
122~
123| Platform | Libreng Request | Libreng Compute |
124|----------|--------------|--------------|
125| **AWS Lambda** | 1M/buwan | 400,000 GB-segundo |
126| **Vercel** | 100K/buwan | Kasama sa Hobby plan |
127| **Cloudflare Workers** | 100K/araw (~3M/buwan) | 10ms CPU bawat invocation |
128~
129### Sa Malaking Sukat (10M request/buwan, average na tagal 50ms)
130~
131| Platform | Tinatayang Buwanang Gastos |
132|----------|----------------------|
133| **AWS Lambda** | ~$2.50 (request) + ~$4.15 (compute) = **~$6.65** |
134| **Vercel** | **$20/buwan** (Pro plan, kasama ang mga function) |
135| **Cloudflare Workers** | **$5/buwan** (bayad na plan, kasama ang 10M request) |
136~
137Para sa karamihan ng mga kaso ng paggamit, ang Cloudflare Workers ang pinakamura. Simple ang pricing ng Vercel pero kasama ang buong platform (hosting, CDN, analytics). Ang AWS Lambda ang may pinakadetailyadong pricing.
138~
139## Mga Tunay na Kaso ng Paggamit
140~
141### AWS Lambda: Pinakamabuti Para Sa
142~
143- **Komplikadong backend workflow** - step functions, event-driven architecture
144- **Integration sa mga serbisyo ng AWS** - S3 trigger, DynamoDB stream, SQS queue
145- **Matagal na gawain** - hanggang 15 minuto na oras ng pagpapatakbo
146- **Multi-language na mga team** - sumusuporta sa pinakamalawak na hanay ng runtime
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: Pinakamabuti Para Sa
159~
160- **Next.js application** - zero-config na API route
161- **Frontend-focused na mga team** - i-deploy ang frontend at backend nang magkasama
162- **Mabilis na prototyping** - git push para i-deploy
163- **Jamstack architecture** - static 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: Pinakamabuti Para Sa
188~
189- **Low-latency API** - tumatakbo ang code sa 300+ lokasyon sa buong mundo
190- **Edge computing** - baguhin ang mga response, A/B testing, personalization
191- **High-volume API** - pinakamura sa malaking sukat na may maluwag na libreng tier
192- **Global application** - data na malapit sa mga user gamit ang KV at 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## Kailan Piliin Kung Alin
221~
222### Piliin ang AWS Lambda kung:
223- Naka-invest ka na sa AWS ecosystem
224- Kailangan mo ng matagal na function (hanggang 15 minuto)
225- Kailangan mo ng komplikadong event-driven architecture
226- Kailangan mo ng runtime na higit sa JavaScript (Python, Go, Rust, Java)
227~
228### Piliin ang Vercel Functions kung:
229- Gumagawa ka gamit ang Next.js o frontend framework
230- Gusto mo ang pinakasimpleng deploy experience (git push)
231- Ang team mo ay nakatuon sa frontend
232- Gusto mo ng hosting + function + CDN sa isang platform
233~
234### Piliin ang Cloudflare Workers kung:
235- Kailangan mo ng pinakamababang latency sa buong mundo
236- Gusto mo ang pinakamura na opsyon sa malaking sukat
237- Kailangan mo ng edge computing capability
238- Kritikal ang cold start time sa iyong kaso ng paggamit
239~
240## Maaari Bang Pagsamahin?
241~
242Oo naman. Isang karaniwang architecture:
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, seguridad
254- **Vercel Functions**: frontend API route, SSR
255- **AWS Lambda**: mabigat na backend processing, nakaplanong gawain, event pipeline
256~
257## Konklusyon
258~
259Malaki na ang pag-unlad ng serverless. Sa 2026, ang pagpili sa pagitan ng AWS Lambda, Vercel Functions, at Cloudflare Workers ay depende sa iyong stack at mga prioridad:
260~
261- **Pinakasimpleng developer experience**: Vercel
262- **Pinakamakapangyarihan at flexible**: AWS Lambda
263- **Pinakamahusay na performance at presyo**: Cloudflare Workers
264~
265Lahat ng tatlo ay production-ready at nasubok sa labanan. Magsimula sa isa na tugma sa iyong kasalukuyang stack, at palawakin habang lumalaki ang iyong mga pangangailangan.
266~