
Serverless: quando funções serverless valem a pena (e quando viram armadilha)
Serverless não significa 'sem servidor' — significa que você não gerencia o servidor: o provedor provisiona, escala e cobra por execução. Esse modelo muda a economia e a arquitetura de uma aplicação de formas que nem sempre são óbvias. Este artigo compara as principais plataformas, destrincha o modelo de custo e define com clareza onde serverless é a melhor escolha e onde vira armadilha cara.
O modelo mental: pague por uso, escale a zero
Em um servidor tradicional (VPS, container 24/7), você paga pela capacidade provisionada — esteja ela em 2% ou 90% de uso. Em serverless, a unidade de cobrança é a execução: milissegundos de CPU × memória alocada. Tráfego zero custa (quase) zero. Picos de 10.000 requisições simultâneas escalam sem intervenção. A contrapartida: cada execução é efêmera, stateless e com limites rígidos de tempo e memória.
Comparativo das plataformas (2026)
| Plataforma | Runtime | Cold start típico | Limite de execução | Ponto forte |
|---|---|---|---|---|
| AWS Lambda | Node, Python, Go, Java, Rust, custom | 100–500 ms (Node/Python); 1–10 s (Java/.NET) | 15 min | Integração com todo o ecossistema AWS |
| Cloudflare Workers | V8 isolates (JS/TS, WASM) | ~0 ms (sem cold start clássico) | Ilimitado no plano pago (CPU time limitado) | Latência na borda, em 300+ cidades |
| Vercel Functions | Node, Edge runtime | Baixo; varia por região | Até 800 s (Fluid compute) | DX integrada a Next.js |
| GCP Cloud Run Functions | Containers ou runtimes gerenciados | Depende da imagem | 60 min (Cloud Run) | Modelo de container com escala a zero |
Cloudflare Workers usam V8 isolates em vez de containers: o 'processo' já está quente e o isolate inicializa em microssegundos. É por isso que o cold start praticamente não existe — mas o runtime não é Node completo (sem fs real, sem TCP arbitrário); é um subconjunto Web-standard com compatibilidade Node opcional.
A matemática do custo: quando serverless é mais barato
Serverless vence financeiramente quando a utilização média de um servidor dedicado seria baixa ou muito variável. Exemplo com números de 2026: uma API com 5 milhões de requisições/mês, 100 ms cada, 256 MB — no free tier + preço sob demanda da Lambda, sai por poucos dólares. Um container equivalente 24/7 custa de 10 a 50x isso. Inverta o cenário — 200 milhões de requisições/mês com carga constante — e o servidor dedicado passa a custar uma fração do serverless.
| Perfil de carga | Escolha econômica | Por quê |
|---|---|---|
| Esporádica / picos imprevisíveis | Serverless | Escala a zero; paga só os picos reais |
| Carga constante e previsível | Container/VPS dedicado | Capacidade reservada é mais barata que milissegundos sob demanda |
| Jobs longos (>15 min) | Fila + worker dedicado | Limites de execução tornam funções inadequadas |
| WebSockets / conexões persistentes | Servidor tradicional ou serviço gerenciado específico | Funções são efêmeras e request-response |
Exemplo: uma função serverless real
// Cloudflare Worker: resize de imagem na borda, com cache
export default {
async fetch(request: Request, env: Env, ctx: ExecutionContext) {
const url = new URL(request.url);
// cache na borda: respostas repetidas nem executam a função de novo
const cache = caches.default;
const cached = await cache.match(request);
if (cached) return cached;
const largura = parseInt(url.searchParams.get("w") ?? "800", 10);
if (largura > 2000) return new Response("largura máxima: 2000", { status: 400 });
const origem = await fetch(`https://cdn.exemplo.com${url.pathname}`);
if (!origem.ok) return new Response("não encontrado", { status: 404 });
const resposta = new Response(origem.body, {
headers: { "content-type": "image/jpeg", "cache-control": "public, max-age=86400" },
});
ctx.waitUntil(cache.put(request, resposta.clone()));
return resposta;
},
};Onde serverless vira armadilha
- Carga alta e constante: o custo por execução supera — e muito — o custo de capacidade dedicada. Várias empresas documentaram reduções de 60–90% na conta ao repatriar workloads quentes para containers.
- Estado e conexões persistentes: WebSockets, SSE de longa duração e sessões em memória não cabem no modelo efêmero.
- Cold start em cadeia: função A chamando função B chamando função C multiplica latências de inicialização.
- Lock-in operacional: triggers, filas, IAM e observabilidade são específicos do provedor; a 'portabilidade' do código é a parte fácil.
- Debugging distribuído: sem tracing estruturado desde o dia 1, investigar falha em 40 funções é sofrimento garantido.
Onde serverless brilha
- APIs e backends de produtos em estágio inicial: custo quase zero até ter tração real.
- Webhooks e eventos esporádicos: pagamentos, integrações, notificações.
- Processamento disparado por evento: thumbnail ao subir imagem, ETL ao cair arquivo no storage.
- Lógica na borda: redirects, A/B, geolocalização, autenticação de requisição antes da origem.
- Tarefas agendadas de baixa frequência: relatórios, limpezas, sincronizações.
Conclusão
Serverless é uma decisão econômica e operacional, não ideológica. Para cargas irregulares, produtos novos e lógica de borda, é difícil competir: zero servidores para gerenciar e conta proporcional ao uso real. Para carga constante e alta, workloads stateful ou jobs longos, containers dedicados são mais baratos e mais simples de operar. Times maduros misturam os dois — e revisam a divisão conforme o perfil de tráfego muda.
Perguntas frequentes
+Cold start ainda é um problema relevante em 2026?
Depende do runtime. Em Cloudflare Workers (V8 isolates), é praticamente inexistente. Em Lambda com Node/Python, 100–500 ms em inicializações frias — imperceptível para APIs comuns, relevante para latência crítica. Java e .NET ainda pagam segundos sem SnapStart/provisioned concurrency.
+Serverless elimina a necessidade de DevOps?
Elimina a administração de servidores, não a disciplina operacional. IAM, observabilidade, limites de concorrência, retries de eventos e gestão de custos continuam exigindo competência — apenas em uma camada diferente.
+Como evitar lock-in em serverless?
Mantenha a lógica de negócio em módulos puros, isolados dos handlers do provedor; prefira padrões Web (fetch, Request/Response) onde possível; e trate triggers e filas como adaptadores. A portabilidade real, porém, é limitada — aceite isso na decisão.
+Posso rodar um banco de dados dentro de uma função serverless?
Não — funções são efêmeras e stateless. O padrão é banco gerenciado acessado por conexão HTTP ou pooling externo (ex.: conexões serverless-friendly, proxies de pool como PgBouncer gerenciado), já que milhares de execuções simultâneas esgotam conexões TCP diretas.
Fontes consultadas
- AWS Lambda — documentação e preços
- Cloudflare Workers — documentação
- Vercel Functions — documentação
- Google Cloud Run — documentação
Revisão editorial: publicado em . Última revisão em . Conteúdo educativo, sem patrocínio das ferramentas citadas.
Leia também

Core Web Vitals na prática: LCP, INP e CLS medidos e corrigidos
Guia técnico dos três Core Web Vitals: como medir com dados reais (CrUX/RUM), as causas mais comuns de LCP, INP e CLS ruins e as correções que funcionam.

Acessibilidade web (a11y) na prática: WCAG, ARIA e testes que funcionam
Guia técnico de acessibilidade: semântica HTML, quando (não) usar ARIA, contraste WCAG, navegação por teclado e testes automatizados com axe e Playwright.

PostgreSQL além do básico: índices, EXPLAIN e JSONB na prática
Aprenda a ler planos de execução com EXPLAIN ANALYZE, escolher entre B-tree, GIN e BRIN, e usar JSONB sem destruir a performance das suas queries.