joechrisnaldy/production-readiness

Lista de Verificación de Preparación para Producción

Cada entrada indica qué verificar. Aplica lo que se ajuste a la etapa del proyecto utilizando los niveles de etapa en CLAUDE.md; si no se definen, infiere la etapa (Prototipo, MVP, Producción o Escala) y establécela. En las revisiones, marca las entradas que no se ajusten a la etapa como no aplicables aún, con el desencadenante que las haría relevantes.

1. Seguridad y control de acceso

• Autorización: Verifica los permisos en el lado del servidor en cada endpoint y para cada objeto al que se accede, no solo al iniciar sesión (previene IDOR y BOLA). Con Supabase, Firebase o backends similares, la seguridad a nivel de fila o las reglas de seguridad deben estar habilitadas y probadas.
• Validación de Entrada: Valida tipo, longitud, formato y rango en cada límite de confianza con una librería de esquemas (Zod, Pydantic o equivalente). La validación del lado del cliente es para UX, nunca para seguridad.
• Inyección SQL: Usa solo consultas parametrizadas o enlaces ORM. Permite en lista blanca identificadores dinámicos, como columnas de ordenación.
• XSS: Confía en el escape del framework. Evita innerHTML, dangerouslySetInnerHTML y v-html con datos no confiables, o sanitiza con una librería verificada como DOMPurify. Agrega una Política de Seguridad de Contenido.
• CSRF: Para sesiones basadas en cookies, usa cookies SameSite más tokens CSRF o comprobaciones de Origen en solicitudes que cambien el estado. Nunca cambies el estado en GET.
• CORS: Permite en lista blanca orígenes exactos. Nunca reflejes orígenes arbitrarios ni permitas un comodín con credenciales. CORS no es control de acceso.
• SSRF: Cuando el servidor obtiene URLs proporcionadas por el usuario, permite destinos en lista blanca, bloquea direcciones privadas, de bucle local y de enlace local para IPv4 e IPv6 (incluyendo metadatos de la nube en 169.254.169.254), y vuelve a verificar después de redirecciones y resolución DNS.
• Gestión de Secretos: Carga secretos desde variables de entorno o un administrador de secretos. Nunca aparecen en código, registros, imágenes de contenedor o historial de git, y cualquier cosa que se haya filtrado se rota.
• IAM: Aplica el mínimo privilegio a cada persona, servicio y token. Usa credenciales separadas por entorno y por servicio, y nunca uses claves raíz o de administrador en aplicaciones.
• OAuth: Usa un proveedor o librería probada en lugar de autenticación personalizada. Usa Código de Autorización con PKCE para clientes de navegador y móvil, coincidencia exacta de URI de redirección, validación de estado y alcances mínimos.
• Rotación JWT: Usa tokens de acceso de corta duración, rotando tokens de actualización con detección de reutilización, y claves de firma rotadas a través de identificadores de clave (kid) y JWKS. Siempre verifica firma, algoritmo, emisor, audiencia y vencimiento.
• Seguridad de Contraseñas y Sesiones: Hashea contraseñas con Argon2id o bcrypt. Configura cookies de sesión como HttpOnly, Secure y SameSite. Ofrece MFA donde las cuentas tengan valor.
• TLS: Sirve HTTPS en todas partes con renovación automática de certificados, TLS 1.2 mínimo (prefiere 1.3) y HSTS. Nunca deshabilites la verificación de certificados.
• Cifrado en Tránsito: Cifra el tráfico interno así como el tráfico público, incluyendo conexiones de servicio, base de datos, caché y cola.
• Cifrado en Reposo: Cifra bases de datos, discos, copias de seguridad y almacenamiento de objetos, con claves en un KMS. Considera el cifrado a nivel de campo para datos altamente sensibles.
• Cabeceras de Seguridad: Configura Política de Seguridad de Contenido (incluyendo frame-ancestors contra clickjacking), Strict-Transport-Security, X-Content-Type-Options: nosniff y Referrer-Policy.
• WAF: Coloca un firewall de aplicaciones web con conjuntos de reglas administradas frente a aplicaciones de producción públicas.
• Protección DDoS: Confía en la protección del proveedor (Cloudflare, AWS Shield o valores predeterminados de la plataforma) más límites de velocidad y límites de escalado automático, de modo que un ataque no pueda convertirse en una factura ilimitada.
• Seguridad de la Cadena de Suministro: Ejecuta escaneos de vulnerabilidades de dependencias (npm audit, pip-audit, Dependabot o similar) en CI. Verifica que cada nuevo paquete sea real, esté correctamente nombrado y sea mantenido.
• Cargas de Archivos: Verifica el tipo por contenido en lugar de extensión, limita el tamaño, almacena en almacenamiento de objetos con nombres aleatorios, y sirve archivos privados a través de URLs firmadas de corta duración.
• Registros de Auditoría: Registra quién hizo qué y cuándo para acciones sensibles (eventos de autenticación, cambios de permisos, exportaciones de datos, movimientos de dinero) en almacenamiento de solo anexión.
• Privacidad y PII: Recoge el mínimo, sabe dónde viven los datos personales, mantenlos fuera de los registros, define la retención y soporta la eliminación y exportación donde leyes como GDPR o CCPA apliquen.

2. Datos y bases de datos

• Indexación de Bases de Datos: Indexa columnas utilizadas en filtros, uniones y ordenaciones en tablas que crecerán, incluyendo claves foráneas. Evita índices redundantes que ralentizan las escrituras.
• Optimización de Consultas: Verifica planes con EXPLAIN para consultas lentas o frecuentes. Selecciona solo las columnas necesarias y evita envolver columnas indexadas en funciones dentro de cláusulas WHERE.
• Consultas N+1: Encuentra bucles que consultan una vez por elemento. Reemplázalos con uniones, carga ansiosa o procesamiento por lotes.
• Pool de Conexiones: Tamaña los pools según los límites de la base de datos. En serverless, usa un pooler (PgBouncer, RDS Proxy o el pooler del proveedor) porque cada instancia abre sus propias conexiones.
• Transacciones: Envuelve escrituras de múltiples pasos que deben tener éxito o fallar juntas en una transacción, y elige el nivel de aislamiento deliberadamente.
• Restricciones: Aplica integridad en la base de datos con NOT NULL, UNIQUE, claves foráneas y restricciones CHECK. Las comprobaciones solo de la aplicación pierden contra las condiciones de carrera.
• Paginación: Pagina cada endpoint de lista y consulta con un tamaño de página limitado. Prefiere paginación por cursor (keyset) para datos grandes o cambiantes.
• Dinero y Tiempo: Almacena dinero como unidades menores enteras o un tipo decimal. Almacena marcas de tiempo en UTC y convierte solo para visualización.
• Réplicas de Lectura: Agrégalas solo cuando las lecturas sobrecarguen el primario y maneja el retraso de replicación, especialmente cuando los usuarios leen sus propias escrituras.
• Replicación: Sabe si es síncrona o asíncrona y cuántos datos puede perder una conmutación por error.
• Particionamiento: Particiona tablas muy grandes (a menudo por tiempo) para mantener índices y mantenimiento manejables, y expira datos antiguos eliminando particiones.
• Fragmentación: Trátala como último recurso después de indexación, almacenamiento en caché, réplicas y escalado vertical. Elige una clave de fragmentación que evite puntos calientes y consultas entre fragmentos.
• Migraciones de Base de Datos: Mantén las migraciones versionadas, revisadas, automatizadas en las implementaciones y reversibles cuando sea posible. Para cero tiempo de inactividad, usa expandir y contraer: agregar, rellenar, cambiar, luego eliminar en una versión posterior. Haz una copia de seguridad antes de cambios destructivos.
• Versionado de Esquemas: Versiona los contratos de datos (esquemas de base de datos, cargas de eventos, esquemas de API) para que el código antiguo y nuevo puedan ejecutarse lado a lado durante las implementaciones.

3. Concurrencia y sistemas distribuidos

• Condiciones de Carrera: Busca código de verificar-luego-actuar (saldos, inventario, nombres de usuario únicos, canje de cupones). Corrígelo con actualizaciones atómicas, restricciones, transacciones o bloqueos.
• Seguridad de Hilos: Sincroniza o elimina el estado mutable compartido entre hilos, workers y tareas asíncronas. Los globales a nivel de módulo a menudo se comparten entre solicitudes.
• Bloqueo Optimista: Verifica una columna de versión o ETag en la actualización para registros de baja contención y devuelve 409 o 412 en conflicto.
• Bloqueo Pesimista: Usa SELECT ... FOR UPDATE para secciones críticas de alta contención y mantén los bloqueos cortos.
• Puntos Muertos: Adquiere bloqueos en un orden consistente, mantén las transacciones cortas y reintenta en errores de punto muerto.
• Bloqueos Distribuidos: Úsalos solo para coordinación entre procesos, con arrendamientos que expiren y tokens de vallado. Prefiere restricciones de base de datos o colas cuando sean suficientes.
• Transacciones Distribuidas: Evita la confirmación en dos fases entre servicios. Mantén los límites transaccionales dentro de una base de datos cuando sea posible.
• Patrón Saga: Para flujos de trabajo que abarcan servicios, encadena transacciones locales con acciones compensatorias y haz que cada paso sea idempotente.
• Teorema CAP: Durante una partición de red, un sistema debe elegir consistencia o disponibilidad. Decide por característica: los saldos y el inventario necesitan consistencia, mientras que los feeds y contadores pueden tolerar desactualización.
• Consistencia Eventual: Donde se acepte, diseña la UI y la lógica para lecturas desactualizadas y haz que las actualizaciones converjan.
• Elección de Líder: Cuando exactamente una instancia debe actuar (planificadores, workers singleton), usa un arrendamiento o una primitiva de la plataforma, nunca una instancia codificada.
• Particiones de Red: Asume que cualquier llamada puede fallar a medio camino o tener éxito sin respuesta. Diseña con tiempos de espera, idempotencia y reconciliación.
• Desviación de Reloj: Nunca confíes en los relojes entre máquinas para orden o corrección. Usa marcas de tiempo de base de datos, números de secuencia o relojes lógicos, y permite un pequeño margen en las comprobaciones de vencimiento de tokens.
• Descubrimiento de Servicios: Resuelve servicios a través de DNS, la plataforma o un registro, nunca IPs codificadas.

4. Resiliencia y tolerancia a fallos

• Tiempos de Espera: Da a cada llamada saliente (HTTP, base de datos, caché, cola, API de LLM) tiempos de espera de conexión y solicitud que encajen dentro del propio plazo del llamante.
• Reintentos: Reintenta solo fallos transitorios (tiempos de espera, errores de conexión, 429, 502, 503, 504) en operaciones idempotentes, con intentos limitados. Evita reintentar en cada capa a la vez, lo que multiplica la carga.
• Retroceso Exponencial: Retrocede exponencialmente con jitter y honra las cabeceras Retry-After.
• Interruptores Automáticos: Deja de llamar a una dependencia fallida después de errores repetidos, falla rápido con un plan de respaldo y prueba la recuperación.
• Idempotencia: Da a las operaciones que pueden ser reintentadas (pagos, pedidos, manejadores de webhook, trabajos) una clave de idempotencia o clave natural, para que los duplicados no tengan efecto adicional.
• Contrapresión: Limita colas, buffers y concurrencia. Cuando esté sobrecargado, descarta carga o devuelve 429 o 503 en lugar de aceptar trabajo ilimitado.
• Compartimentación: Aísla recursos (pools o workers separados) para que una dependencia lenta no pueda agotar todo.
• Degradación Gradual: Decide qué sigue funcionando cuando una dependencia está caída, como datos en caché, un modo de solo lectura o la ocultación temporal de una característica.
• Apagado Gradual: En SIGTERM, deja de aceptar nuevo trabajo, termina las solicitudes y trabajos en curso, luego cierra conexiones.
• Verificaciones de Salud: Expón un endpoint de salud barato para el balanceador de carga o la plataforma.
• Sondas de Vitalidad y Preparación: La vitalidad solo detecta un proceso atascado y no debe depender de servicios externos, o un parpadeo de base de datos reinicia todo. La preparación decide si una instancia debe recibir tráfico y puede verificar dependencias.
• Conmutación por Error: Sabe qué sucede cuando falla la base de datos primaria, la zona o el proveedor. Automatízalo donde el tiempo de actividad importe y pruébalo.

5. Mensajería, trabajo en segundo plano y tiempo real

• Colas de Mensajes: Mueve el trabajo lento, reintentable o ráfaga (correos electrónicos, procesamiento de medios, llamadas de terceros) fuera de la ruta de solicitud a una cola con workers.
• Semánticas de Entrega: Asume entrega al menos una vez, por lo que los consumidores deben ser idempotentes. No asumas orden a menos que el sistema lo garantice por clave.
• Colas de Mensajes Muertos: Enruta mensajes que agoten los reintentos a una DLQ con una alerta y una ruta de reproducción. Nunca los descartes en silencio ni reintentes para siempre.
• Pub/Sub: Úsalo para difusión a múltiples consumidores independientes, con esquemas de eventos definidos y propiedad.
• Arquitectura Orientada a Eventos: Adóptala cuando desacoplar valga el costo de depuración. Trata los eventos como contratos versionados y mantén las solicitudes rastreables a través de ellos.
• Bandeja de Salida Transaccional: Cuando una escritura de base de datos también debe publicar un evento, escribe ambas en una transacción (una tabla de bandeja de salida) y retransmite asíncronamente, lo que evita el problema de doble escritura.
• Trabajos Cron: Haz que los trabajos programados sean idempotentes, seguros de ejecutar dos veces o en superposición, limitados a una instancia a la vez, y monitoreados para ejecuciones perdidas o fallidas.
• WebSockets: Autentica en la conexión, envía latidos, reconecta con retroceso y planifica para múltiples instancias (pub/sub compartido o sesiones persistentes).
• Eventos Enviados por el Servidor: Prefiérelos sobre WebSockets para flujos unidireccionales del servidor al cliente, como notificaciones, progreso y transmisión de tokens LLM.
• Long Polling: Úsalo como respaldo cuando WebSockets y SSE no estén disponibles, con tiempos de espera y un límite en las conexiones mantenidas.
• Webhooks: Para webhooks entrantes, verifica firmas (HMAC), rechaza marcas de tiempo desactualizadas para detener repeticiones, reconoce rápido y procesa asíncronamente, y deduplica por ID de evento. Para webhooks salientes, firma cargas, reintenta con retroceso y versiona formatos de eventos.

6. Tráfico, borde y redes

• Limitación de Velocidad: Limita por usuario, clave API e IP en endpoints públicos, de autenticación y costosos (inicio de sesión, registro, restablecimiento de contraseña, OTP, llamadas LLM). Devuelve 429 con Retry-After.
• Balanceo de Carga: Distribuye el tráfico entre instancias verificadas por salud. Mantén los servidores de aplicación sin estado para que cualquier instancia pueda servir cualquier solicitud.
• Proxies Inversos: Termina TLS, comprime y aplica límites de tamaño de cuerpo y tiempo de espera en el proxy. Confía en X-Forwarded-For solo de proxies conocidos para que las IPs de cliente no puedan ser falsificadas.
• Pasarelas API: Centraliza autenticación, limitación de velocidad, enrutamiento y validación cuando haya múltiples servicios o una API pública. Una aplicación única rara vez necesita una.
• CDN: Sirve activos estáticos y medios a través de un CDN con largos tiempos de vida de caché y nombres de archivo con hash de contenido.
• DNS: Baja los TTL antes de migraciones, administra registros como código cuando sea posible y espera retrasos de propagación.
• TCP vs UDP: Por defecto, protocolos basados en TCP. Usa UDP solo para tráfico sensible a la latencia que tolere pérdidas (medios en tiempo real, juegos), con manejo a nivel de aplicación.
• HTTP/2 y HTTP/3: Actívalos en el borde o CDN para multiplexación y conexiones más rápidas. Esto suele ser configuración, no código de aplicación.
• gRPC: Úsalo para llamadas de servicio interno que necesiten contratos estrictos o transmisión, con una fecha límite en cada llamada. Los navegadores necesitan gRPC-Web o una pasarela.

7. Almacenamiento en Caché

• Almacenamiento en Caché: Almacena en caché solo después de medir una necesidad y define la clave, TTL y audiencia de cada caché. Nunca almacenes datos específicos del usuario o dependientes de permisos en una caché compartida bajo una clave genérica.
• Caché de Borde: Configura Cache-Control explícitamente, marca respuestas personalizadas como private o no-store, y usa stale-while-revalidate donde la frescura importe menos que la velocidad.
• Caché de Aplicación: Usa Redis, Memcached o caché en proceso para datos a los que se accede con frecuencia (perfiles de usuario, configuraciones, resultados de consultas costosas). Establece TTLs apropiados y planes de invalidación.
• Invalidación de Caché: Invalida o actualiza las entradas de caché cuando los datos subyacentes cambien, ya sea por evento, por tiempo de vida o por clave específica.
• Caché de Consultas: Cachea resultados de consultas costosas o poco frecuentes, pero ten en cuenta que los resultados pueden quedar obsoletos. Establece TTLs cortos o invalida tras escrituras.
• Caché de Fragmentos: Cachea partes de una página o respuesta (fragmentos HTML, resultados de API parciales) para reducir el trabajo de renderizado.
• Caché de Objetos: Cachea objetos completos (archivos, imágenes, documentos) en almacenamiento de objetos o CDN con control de versiones.

8. Rendimiento y escalado

• Métricas de Rendimiento: Mide latencia, rendimiento y tasas de error de cada servicio y dependencia. Establece objetivos (SLOs) y presupuestos de error.
• Perfilado: Perfila la aplicación en condiciones de carga para encontrar cuellos de botella (CPU, memoria, E/S, red, base de datos).
• Carga de Trabajo Sintética: Genera carga de trabajo sintética para probar el rendimiento bajo estrés y validar SLOs.
• Escalado Automático: Configura el escalado automático basado en métricas de carga (CPU, memoria, longitud de cola) con límites superior e inferior para evitar costos excesivos.
• Caché de Base de Datos: Cachea consultas frecuentes de base de datos para reducir la carga de la base de datos.
• Compresión: Comprime respuestas (gzip, Brotli) en el proxy o CDN.
• Minificación y Agrupación: Minifica y agrupa activos estáticos (JavaScript, CSS) para reducir el tamaño de las descargas.
• Carga Diferida: Carga imágenes, scripts y otros recursos bajo demanda para acelerar el tiempo de carga inicial de la página.
• Carga Anticipada: Pre-carga recursos que se necesitarán pronto (enlaces, imágenes de la siguiente página) para que estén disponibles más rápido.
• HTTP/2 Server Push: Considera usar HTTP/2 Server Push para recursos críticos, pero ten cuidado con el desperdicio de ancho de banda.
• Optimización de Imágenes: Optimiza imágenes (tamaño, formato, compresión) para reducir el tamaño de las descargas.
• CDN para Contenido Estático: Sirve contenido estático a través de una CDN para una entrega más rápida.
• Reducción de Tamaño de Página: Minimiza el tamaño de las páginas HTML, CSS y JavaScript.
• Reducción de Solicitudes: Reduce el número de solicitudes HTTP combinando archivos, usando sprites CSS o cargando bajo demanda.
• Uso de Caché del Navegador: Configura cabeceras de caché del navegador para activos estáticos.
• Service Workers: Usa service workers para almacenar en caché activos y habilitar el modo offline.
• Optimización de Base de Datos: Optimiza esquemas, consultas e índices de base de datos para un mejor rendimiento.
• Escalado de Capa de Datos: Escala la capa de datos (bases de datos, cachés, colas) según sea necesario.
• Escalado de Capa de Aplicación: Escala la capa de aplicación (servidores, workers) según sea necesario.
• Escalado de Capa de Red: Escala la capa de red (balanceadores de carga, proxies, CDN) según sea necesario.
• Monitoreo Continuo: Monitorea continuamente el rendimiento y escala según sea necesario.

9. API y contratos

• Versionado de API: Versiona las API (URL, cabecera o parámetro) para permitir cambios sin romper a los clientes existentes.
• Documentación de API: Documenta las API (OpenAPI, Swagger, etc.) para que los desarrolladores sepan cómo usarlas.
• Consistencia de API: Mantén la consistencia en los nombres de rutas, parámetros, respuestas y errores.
• Seguridad de API: Protege las API con autenticación, autorización, limitación de velocidad y validación de entrada.
• Manejo de Errores: Maneja errores de manera consistente y proporciona mensajes de error útiles.
• Paginación: Pagina listas de resultados para evitar respuestas grandes.
• Filtrado y Ordenación: Proporciona capacidades de filtrado y ordenación en listas de resultados.
• Campos: Permite a los clientes seleccionar solo los campos que necesitan.
• Compresión: Comprime las respuestas de la API (gzip, Brotli) para reducir el tamaño de la transferencia.
• Almacenamiento en Caché: Cachea las respuestas de la API cuando sea apropiado y proporciona cabeceras de control de caché.
• Límites de Velocidad: Implementa límites de velocidad para evitar abusos.
• Documentación de Errores: Documenta los códigos de error y sus significados.
• Pruebas de API: Prueba las API con pruebas unitarias y de integración.
• Monitoreo de API: Monitorea las API para detectar errores, latencia y uso.
• Deprecación de API: Proporciona un proceso de deprecación suave para las API antiguas.
• Contratos de API: Define contratos de API claros (esquemas, tipos) y versionalos.
• API Gateway: Considera usar una pasarela API para centralizar la autenticación, limitación de velocidad y enrutamiento.
• Webhooks: Proporciona webhooks para que los clientes reciban notificaciones de eventos.
• GraphQL: Considera usar GraphQL para flexibilidad en consultas, pero sé consciente de los desafíos de seguridad y rendimiento.
• gRPC: Considera usar gRPC para comunicación entre servicios con contratos estrictos y streaming.

10. Observabilidad

• Registros: Registra eventos importantes (errores, advertencias, solicitudes, respuestas) con suficiente contexto para depurar.
• Métricas: Recopila métricas (latencia, rendimiento, tasas de error, uso de recursos) y visualízalas en paneles.
• Trazas: Rastrea solicitudes a través de servicios distribuidos para identificar cuellos de botella y errores.
• Alertas: Configura alertas para umbrales críticos (alta latencia, altas tasas de error, caídas de servicio).
• Paneles: Crea paneles para visualizar métricas y trazas.
• Presupuestos de Error: Define presupuestos de error para SLOs y alarma cuando se superen.
• Análisis de Causa Raíz: Utiliza herramientas de observabilidad para analizar la causa raíz de incidentes.
• Registros Estructurados: Utiliza registros estructurados (JSON) para facilitar la búsqueda y el análisis.
• Correlación de Registros: Correlaciona registros de diferentes servicios con IDs de solicitud.
• Muestreo: Muestrea trazas para reducir el costo de almacenamiento y procesamiento.
• Retención de Datos: Define políticas de retención para registros, métricas y trazas.
• Privacidad: Asegúrate de que los datos de observabilidad no contengan información sensible.
• Herramientas de Observabilidad: Elige herramientas de observabilidad adecuadas (Prometheus, Grafana, Datadog, New Relic, etc.).
• Instrumentación: Instrumenta la aplicación para exponer métricas y trazas.
• Monitoreo Sintético: Utiliza monitoreo sintético para probar la disponibilidad y el rendimiento de la aplicación.
• Monitoreo de Usuarios Reales: Utiliza monitoreo de usuarios reales para comprender la experiencia del usuario.
• Alertas Basadas en ML: Considera usar alertas basadas en ML para detectar anomalías.
• Incidentes: Define un proceso de gestión de incidentes para responder a las alertas.
• Postmortems: Realiza postmortems después de los incidentes para aprender y mejorar.

11. Pruebas

• Pruebas Unitarias: Prueba unidades individuales de código de forma aislada.
• Pruebas de Integración: Prueba la interacción entre componentes.
• Pruebas de Sistemas: Prueba el sistema completo de extremo a extremo.
• Pruebas de Aceptación: Prueba que el sistema cumple con los requisitos del usuario.
• Pruebas de Regresión: Vuelve a probar después de los cambios para asegurarte de que nada se rompa.
• Pruebas de Rendimiento: Prueba el rendimiento bajo carga.
• Pruebas de Seguridad: Prueba la seguridad de la aplicación.
• Pruebas de Usabilidad: Prueba la usabilidad de la aplicación.
• Pruebas de Accesibilidad: Prueba la accesibilidad de la aplicación.
• Pruebas de Compatibilidad: Prueba la compatibilidad con diferentes navegadores, dispositivos y sistemas operativos.
• Pruebas de Recuperación: Prueba la capacidad de recuperación del sistema después de fallos.
• Pruebas de Carga: Prueba el rendimiento bajo cargas esperadas.
• Pruebas de Estrés: Prueba el rendimiento bajo cargas extremas.
• Pruebas de Pico: Prueba el rendimiento bajo picos repentinos de carga.
• Pruebas de Resistencia: Prueba el rendimiento durante períodos prolongados.
• Pruebas de Volumen: Prueba el rendimiento con grandes volúmenes de datos.
• Automatización de Pruebas: Automatiza las pruebas para ejecutarlas en CI/CD.
• Cobertura de Pruebas: Mide la cobertura de pruebas para identificar código no probado.
• Pruebas de Mutación: Utiliza pruebas de mutación para evaluar la calidad de las pruebas.
• Pruebas de Humo: Ejecuta pruebas rápidas después de una implementación para verificar que el sistema funciona.
• Pruebas de Sanidad: Ejecuta pruebas después de cambios menores para verificar que el sistema sigue funcionando.
• Pruebas Exploratorias: Explora la aplicación sin un plan de pruebas predefinido para encontrar defectos.
• Pruebas de Aceptación de Usuario: Prueba con usuarios reales para validar que el sistema cumple con sus necesidades.
• Pruebas A/B: Prueba diferentes versiones de una característica para determinar cuál funciona mejor.
• Pruebas de Feature Toggle: Prueba características ocultas detrás de feature toggles.

12. Implementación y entrega

• Integración Continua: Integra el código de los desarrolladores de forma frecuente y automática.
• Entrega Continua: Automatiza la entrega de código a los entornos de prueba y producción.
• Despliegue Continuo: Automatiza la implementación en producción.
• Entornos: Gestiona entornos (desarrollo, prueba, puesta en escena, producción) de forma consistente.
• Infraestructura como Código: Gestiona la infraestructura como código (Terraform, Pulumi, CloudFormation).
• Contenedores: Utiliza contenedores (Docker) para empaquetar y desplegar aplicaciones.
• Orquestación de Contenedores: Utiliza orquestadores (Kubernetes, ECS) para gestionar contenedores.
• Estrategias de Despliegue: Elige estrategias de despliegue adecuadas (recreación, rodante, azul-verde, canario).
• Rollback: Automatiza el rollback a una versión anterior si una implementación falla.
• Feature Toggles: Utiliza feature toggles para activar/desactivar características sin implementar código nuevo.
• Versionado Semántico: Versiona las aplicaciones y bibliotecas utilizando versionado semántico.
• Registro de Cambios: Mantén un registro de cambios (CHANGELOG) de los cambios.
• Etiquetado: Etiqueta los commits y las versiones en git.
• Gestión de Dependencias: Gestiona las dependencias de forma segura y actualizada.
• Seguridad en CI/CD: Integra la seguridad en la cadena CI/CD (análisis de código, escaneo de vulnerabilidades).
• Pruebas en CI/CD: Ejecuta pruebas automáticas en CI/CD.
• Implementaciones Azul-Verde: Implementa una nueva versión junto a la anterior y luego cambia el tráfico.
• Implementaciones Canarias: Implementa una nueva versión para un pequeño porcentaje de usuarios y luego aumenta gradualmente.
• Implementaciones Recreativas: Detiene la versión anterior e inicia la nueva.
• Implementaciones Rodantes: Reemplaza las instancias de la versión anterior por la nueva de una en una.
• Implementaciones sin Tiempo de Inactividad: Diseña implementaciones sin tiempo de inactividad.

13. Recuperación ante Desastres

• Plan de Recuperación ante Desastres: Define un plan de recuperación ante desastres que incluya RPO (Objetivo de Punto de Recuperación) y RTO (Objetivo de Tiempo de Recuperación).
• Copias de Seguridad: Realiza copias de seguridad periódicas de datos críticos (bases de datos, almacenamiento de objetos, configuraciones).
• Prueba de Copias de Seguridad: Prueba periódicamente que las copias de seguridad se pueden restaurar correctamente.
• Restauración Automatizada: Automatiza el proceso de restauración desde las copias de seguridad.
• Regiones Multi-AZ/Región: Despliega la aplicación en múltiples zonas de disponibilidad o regiones para alta disponibilidad.
• Failover Automatizado: Automatiza la conmutación por error a una región secundaria.
• Resiliencia de Red: Diseña la red para que sea resistente a fallos (enlaces redundantes, balanceadores de carga).
• Resiliencia de Aplicación: Diseña la aplicación para que sea resistente a fallos (tiempos de espera, reintentos, interruptores automáticos).
• Resiliencia de Datos: Diseña la capa de datos para que sea resistente a fallos (réplicas, fragmentación, copias de seguridad).
• Documentación de Recuperación: Documenta los procedimientos de recuperación ante desastres.
• Entrenamiento en Recuperación: Entrena al equipo en los procedimientos de recuperación ante desastres.
• Simulacros de Recuperación: Realiza simulacros periódicos de recuperación ante desastres.
• Monitoreo de Recuperación: Monitorea la capacidad de recuperación del sistema.
• Mejora Continua: Mejora continuamente los planes y procedimientos de recuperación ante desastres.

14. Lado del Cliente

• Rendimiento del Lado del Cliente: Optimiza el rendimiento del lado del cliente (carga de página, interactividad, uso de memoria).
• Seguridad del Lado del Cliente: Protege el lado del cliente contra ataques (XSS, CSRF, clickjacking).
• Accesibilidad: Asegúrate de que la aplicación sea accesible para usuarios con discapacidades.
• Usabilidad: Diseña la aplicación para que sea fácil de usar y navegar.
• Compatibilidad: Asegúrate de que la aplicación funcione en diferentes navegadores, dispositivos y sistemas operativos.
• Responsividad: Diseña la aplicación para que sea responsive en diferentes tamaños de pantalla.
• Internacionalización: Soporta múltiples idiomas y regiones.
• Localización: Traduce la aplicación a diferentes idiomas y culturas.
• Privacidad del Usuario: Protege los datos del usuario en el lado del cliente.
• Experiencia del Usuario: Proporciona una experiencia de usuario agradable y eficiente.
• Gestión del Estado: Gestiona el estado de la aplicación de forma predecible y eficiente.
• Enrutamiento del Lado del Cliente: Maneja el enrutamiento de la aplicación en el lado del cliente.
• Componentes Reutilizables: Utiliza componentes reutilizables para mantener la consistencia y reducir el código duplicado.
• Pruebas del Lado del Cliente: Prueba la aplicación del lado del cliente con pruebas unitarias y de integración.
• Monitoreo del Lado del Cliente: Monitorea el rendimiento y los errores del lado del cliente.

15. Características de Modelos de Lenguaje Grande (LLM)

• Gestión de Tokens: Gestiona el uso de tokens para controlar costos y evitar exceder límites.
• Manejo de Errores: Maneja errores de la API de LLM (tiempos de espera, límites de velocidad, errores de autenticación).
• Reintentos: Reintenta las llamadas a la API de LLM en caso de fallos transitorios.
• Almacenamiento en Caché: Cachea las respuestas de LLM cuando sea apropiado para reducir costos y latencia.
• Paginación: Pagina las respuestas largas de LLM para evitar respuestas grandes.
• Transmisión: Transmite las respuestas de LLM para proporcionar una experiencia de usuario más rápida.
• Contexto: Gestiona el contexto de la conversación para mantener la coherencia.
• Historial: Guarda el historial de la conversación para permitir la continuidad.
• Privacidad: Asegúrate de que los datos del usuario no se envíen a la API de LLM sin consentimiento.
• Seguridad: Protege la API de LLM contra abusos (limitación de velocidad, autenticación).
• Costos: Monitorea y optimiza los costos de las llamadas a la API de LLM.
• Selección de Modelo: Elige el modelo de LLM adecuado para la tarea (rendimiento, costo, latencia).
• Ajuste (Fine-tuning): Considera el ajuste de modelos de LLM para tareas específicas.
• Plantillas de Prompt: Utiliza plantillas de prompt para generar prompts consistentes y efectivos.
• Validación de Salida: Valida la salida del LLM para asegurarte de que sea correcta y segura.
• Moderación: Utiliza la moderación de contenido para filtrar resultados inapropiados.
• Observabilidad: Monitorea el rendimiento, los costos y los errores de las llamadas a la API de LLM.
• Pruebas: Prueba las integraciones de LLM con pruebas unitarias y de integración.
• Documentación: Documenta cómo usar las características de LLM en la aplicación.
• Despliegue: Despliega las características de LLM de forma segura y gradual.