Serverless y Edge Computing: Por Qué 70% de las Empresas Están Migrando en 2025
Hola HaWkers, un cambio silencioso pero profundo está sucediendo en el mundo del desarrollo backend: 70% de las empresas están adoptando arquitecturas serverless hasta 2025, y Edge Computing se está volviendo un componente crítico de aplicaciones modernas.
Si todavía estás gestionando servidores manualmente, configurando infraestructura y lidiando con escalabilidad, estás perdiendo las ventajas de una revolución que promete reducir costos hasta 70% y mejorar drásticamente la experiencia del usuario.
Vamos a entender qué son Serverless y Edge Computing, por qué están dominando el mercado, y cómo puedes aprovechar esas tecnologías en la práctica.
El Problema con Arquitecturas Tradicionales
En el modelo tradicional, provisionas servidores, configuras load balancers, gestionas escalabilidad, monitoreas recursos y pagas por capacidad ociosa. Incluso cuando nadie está usando tu aplicación, estás pagando por servidores corriendo 24/7.
// Arquitectura Tradicional: Express.js en servidor dedicado
const express = require('express');
const app = express();
app.get('/api/users/:id', async (req, res) => {
const user = await db.users.findById(req.params.id);
res.json(user);
});
// Servidor corriendo 24/7, incluso sin requisiciones
app.listen(3000, () => {
console.log('Server running on port 3000');
// Pagas por este servidor todo el tiempo
// Necesitas configurar PM2, Nginx, load balancer, etc.
});Problemas de ese enfoque:
- Costos fijos: Pagas por capacidad incluso sin uso
- Escalabilidad manual: Necesitas provisionar más servidores manualmente
- Complejidad operacional: Gestionar infraestructura, patches, seguridad
- Latencia global: Servidores centralizados distantes de usuarios
Serverless: Solo Pagas Por Lo Que Usas
Arquitectura serverless permite correr código sin gestionar servidores. Escribes funciones que son ejecutadas bajo demanda, escalan automáticamente y solo pagas por las ejecuciones.
// Serverless Function (AWS Lambda, Vercel, Netlify)
// api/users/[id].js
export default async function handler(req, res) {
const { id } = req.query;
// Función ejecuta solo cuando es llamada
const user = await db.users.findById(id);
res.status(200).json(user);
// Después de responder, función "se apaga"
// Solo pagas por los milisegundos de ejecución
}Ventajas del Serverless:
- Costo por uso: Pagas solo por las ejecuciones
- Escalabilidad automática: De 0 a millones de requests sin configuración
- Zero gestión: Sin servidores para mantener
- Deploy simplificado: Git push y está en el aire
// Ejemplo real: API Serverless con TypeScript
// api/products/[id].ts
import { NextApiRequest, NextApiResponse } from 'next';
import { getProduct } from '@/lib/database';
interface Product {
id: string;
name: string;
price: number;
stock: number;
}
export default async function handler(
req: NextApiRequest,
res: NextApiResponse<Product | { error: string }>
) {
const { id } = req.query;
if (req.method !== 'GET') {
return res.status(405).json({ error: 'Method not allowed' });
}
try {
const product = await getProduct(id as string);
if (!product) {
return res.status(404).json({ error: 'Product not found' });
}
// Cache por 1 hora
res.setHeader('Cache-Control', 's-maxage=3600, stale-while-revalidate');
res.status(200).json(product);
} catch (error) {
console.error('Error fetching product:', error);
res.status(500).json({ error: 'Internal server error' });
}
}
Edge Computing: Procesando Próximo al Usuario
Edge Computing lleva la idea de serverless un paso más allá: en vez de ejecutar funciones en un data center centralizado, corren en servidores distribuidos globalmente, próximos a los usuarios.
El Problema de la Latencia:
// Escenario tradicional
// Usuario en Brasil -> Servidor en EEUU -> Banco de datos en EEUU
// Latencia total: 200ms - 500ms
// Con Edge Computing
// Usuario en Brasil -> Edge en Brasil -> Cache/Procesamiento local
// Latencia total: 10ms - 50msEdge Functions en Acción:
// Edge Function (Vercel Edge, Cloudflare Workers)
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
export function middleware(request: NextRequest) {
// Esta función corre en el Edge, próximo al usuario
const country = request.geo?.country || 'US';
const city = request.geo?.city || 'Unknown';
// Personalización basada en ubicación
// Sin latencia de servidor centralizado
if (country === 'BR') {
return NextResponse.redirect(new URL('/pt-br', request.url));
}
// A/B Testing en el Edge
const bucket = Math.random();
const response = bucket < 0.5
? NextResponse.rewrite(new URL('/variant-a', request.url))
: NextResponse.rewrite(new URL('/variant-b', request.url));
response.cookies.set('ab-test-variant', bucket < 0.5 ? 'a' : 'b');
return response;
}
export const config = {
matcher: '/',
};Comparación: Costos Serverless vs Tradicional
Vamos a comparar costos reales para una aplicación con tráfico medio:
// Aplicación con 10 millones de requisiciones/mes
// 💰 Arquitectura Tradicional (EC2, DigitalOcean, etc.)
const traditionalCosts = {
servers: 3, // Para redundancia
costPerServer: 40, // USD/mes
loadBalancer: 20, // USD/mes
total: (3 * 40) + 20 // = $140/mes
};
// 💸 Serverless (AWS Lambda, Vercel, Netlify)
const serverlessCosts = {
requests: 10_000_000,
freeRequests: 1_000_000, // AWS Free Tier
billableRequests: 9_000_000,
costPer1M: 0.20, // USD
total: (9_000_000 / 1_000_000) * 0.20 // = $1.80/mes
};
// 📊 Ahorro
const savings = traditionalCosts.total - serverlessCosts.total;
console.log(`Ahorro: $${savings}/mes`); // $138.20/mes (98.7% de reducción!)Atención: Costos varían mucho dependiendo del patrón de uso, pero para aplicaciones con tráfico variable, serverless generalmente es mucho más económico.
Cuándo Usar Serverless/Edge vs Tradicional
✅ Usa Serverless/Edge cuando:
- Tráfico es variable o intermitente
- Quieres enfocarte en código, no infraestructura
- Necesitas escalabilidad automática
- Latencia global es importante
- Quieres reducir costos operacionales
❌ Usa Tradicional cuando:
- Workloads son previsibles y constantes
- Necesitas control total del ambiente
- Aplicación exige estado persistente en memoria
- Latencia de cold start es crítica
- Costos de serverless superan tradicionales (workloads muy intensos)
El Futuro es Híbrido
La tendencia en 2025 es arquitecturas híbridas: combinar serverless, edge y servidores tradicionales conforme la necesidad:
// Híbrido: Edge para rutas rápidas, Serverless para APIs, Tradicional para procesamiento pesado
// Edge: Autenticación y routeo
// middleware.ts (Edge Runtime)
export function middleware(request: NextRequest) {
const token = request.cookies.get('auth-token');
if (!token) return NextResponse.redirect('/login');
return NextResponse.next();
}
// Serverless: APIs livianas
// api/users.ts (Serverless)
export default async function handler(req, res) {
const users = await db.users.findMany();
res.json(users);
}
// Tradicional: Jobs pesados en background
// Procesamiento de video, ML, ETL corren en servidores dedicadosSi quieres entender más sobre arquitecturas modernas, te recomiendo leer: WebAssembly y JavaScript: La Revolución de Performance en la Web donde exploramos cómo WASM está transformando performance de aplicaciones.
¡Vamos a por ello! 🦅
📚 ¿Quieres Dominar Arquitecturas Modernas?
Este artículo cubrió Serverless y Edge Computing, pero hay mucho más para aprender sobre desarrollo backend y arquitecturas escalables.
Desarrolladores que entienden esas arquitecturas tienen más oportunidades en el mercado moderno.
Material de Estudio Completo
Si quieres dominar JavaScript y arquitecturas modernas de básico a avanzado:
Opciones de inversión:
- $9.90 USD (pago único)