Construyendo Sistemas Escalables: Lecciones desde las Trincheras

El Desafío de la Escalabilidad

Cuando tu sistema crece de cientos a millones de usuarios, todo cambia. Las consultas a base de datos que eran instantáneas se convierten en cuellos de botella. Las APIs que eran rápidas empiezan a dar timeout. Y ese monolito que construiste? Ahora es una bomba de tiempo.

Estos son los patrones que me han salvado consistentemente.

1. Empieza por el Modelo de Datos

Antes de pensar en microservicios o Kubernetes, define bien tu modelo de datos. Un esquema bien diseñado puede posponer la necesidad de infraestructura compleja por meses o incluso años.

-- En vez de esto
SELECT * FROM users WHERE email LIKE '%@example.com';

-- Haz esto
CREATE INDEX idx_users_email_domain ON users (split_part(email, '@', 2));
SELECT * FROM users WHERE split_part(email, '@', 2) = 'example.com';

2. Cachea Estratégicamente

No todo necesita caché, y no todas las estrategias de caché son iguales. Sigo la regla del “hot path”: identifica el 20% de endpoints que manejan el 80% del tráfico, y cachea esos agresivamente.

from functools import lru_cache
from redis import Redis

redis = Redis()

def get_user_profile(user_id: str):
    cached = redis.get(f"profile:{user_id}")
    if cached:
        return json.loads(cached)

    profile = db.query(User).filter(User.id == user_id).first()
    redis.setex(f"profile:{user_id}", 300, json.dumps(profile.dict()))
    return profile

3. Async para Todo

En el momento que tienes dos servicios comunicándose, introduce una cola de mensajes. Es la decisión arquitectónica individual más impactante para la confiabilidad.

“El mejor sistema distribuido es aquel donde los componentes no necesitan saber de la existencia del otro.” — Todo ingeniero senior eventualmente

4. La Observabilidad No es Opcional

No puedes escalar lo que no puedes medir. Configura logging estructurado, tracing distribuido y alertas desde el día uno.

Conclusiones Clave

• Empieza simple, pero diseña para el crecimiento
• Mide antes de optimizar — las intuiciones suelen estar equivocadas
• Adopta patrones async — te dan backpressure natural
• Invierte en observabilidad — paga interés compuesto

Las mejores arquitecturas no son las más complejas — son las que son justo lo suficientemente complejas.