Pillar page

Modernización de sistemas legacy

Refactor incremental de monolito a microservicios, migración desde tecnologías obsoletas a stacks modernos, migración a la nube — sin downtime de negocio, con plan de rollback y audit trail completo.

Toda empresa tiene algún sistema legacy. Algunas tienen varios. Una aplicación contable de 2008 que de algún modo sigue funcionando. Un CRM escrito por consultores que ya nadie recuerda. Un almacén corriendo sobre Access. Cada uno de ellos habrá que reemplazarlo tarde o temprano — la pregunta no es si, sino cuándo y cómo.

La modernización de sistemas legacy es uno de los tipos de proyecto IT más difíciles. Requiere equilibrar tres fuerzas: mantener la continuidad del negocio (el sistema debe seguir funcionando todo el tiempo), introducir tecnologías modernas (microservicios, cloud, IA) y controlar el riesgo (cualquier refactor puede romper algo que llevaba años funcionando).

¿Por qué no basta con „reescribir desde cero"?

Según nuestra experiencia, 9 de cada 10 modernizaciones exitosas son refactorings incrementales, no rewrites. Los rewrites son conceptualmente tentadores („empezamos con una hoja en blanco"), pero en la práctica tienen tres problemas fundamentales:

  • Lógica de negocio invisible. El sistema antiguo acumula años de reglas de negocio — condiciones especiales para los mayores clientes, exenciones fiscales para sectores concretos, workarounds para regulaciones de 2015. La mayoría no está documentada. Un rewrite debe reconstruirlas todas a partir de la memoria de las personas o del análisis del código.
  • Trabajo duplicado. Mientras se escribe el nuevo sistema, el negocio sigue exigiendo cambios en el antiguo (regulaciones, nuevos clientes, pequeños bugs). El equipo o duplica el trabajo (cambios en dos lugares) o congela el sistema antiguo (riesgo de negocio).
  • Despliegue big bang. Tras un año de trabajo, el sistema nuevo está „casi listo". Cambiar a todos los usuarios en una sola noche genera un riesgo monumental. Cualquier problema inesperado significa volver al sistema antiguo, perder moral del equipo y erosionar la confianza del negocio.

El refactor incremental (habitualmente siguiendo el patrón Strangler Fig) resuelve los tres: la lógica de negocio se descubre gradualmente, una única fuente de verdad por entidad, despliegue por etapas con feature flags.

Seis patrones de modernización

Cada uno aborda un riesgo concreto. En la mayoría de proyectos combinamos varios, eligiendo un patrón por módulo.

Strangler Fig

„Envolver" gradualmente el sistema antiguo con componentes nuevos. El código antiguo sigue corriendo, pero cada nueva funcionalidad se desarrolla en un microservicio nuevo y los módulos existentes se reemplazan uno a uno. Tras 12-24 meses, el monolito antiguo se apaga.

Anti-corruption layer

Un adaptador que protege al código nuevo de las rarezas del sistema antiguo (nombres de campo ilegibles, formatos de fecha extraños, tipos inconsistentes). Toda la lógica „fea" queda aislada en un único lugar — el código nuevo opera sobre un modelo de dominio limpio.

Database refactoring

Patrones del libro Refactoring Databases (Ambler/Sadalage): expand-and-contract para migraciones de esquema, validación de datos antes de eliminar columnas antiguas, mantenimiento paralelo de ambos esquemas durante la migración de la aplicación.

Branch by abstraction

Introducir una capa de abstracción alrededor del componente antiguo, implementar el nuevo componente en paralelo, ir cambiando el tráfico del 0% al 100% (feature flag). Sin despliegue „big bang".

Shadow mode

El código nuevo corre en paralelo al antiguo — ambos procesan las mismas peticiones, pero solo los resultados del antiguo llegan al usuario. Los resultados se comparan offline. Tras confirmar la compatibilidad (típicamente 2-4 semanas) cambiamos el tráfico al nuevo código.

Event sourcing para migración

Grabamos el flujo de eventos de negocio del sistema antiguo y lo replicamos en el nuevo. Permite la validación previa de la nueva arquitectura sin riesgo de producción, y volver a cualquier estado histórico.

Hoja de ruta típica de modernización

Para un sistema mediano (monolito de ~200k líneas de código, 5-10 módulos de negocio):

  1. Mes 1: Discovery y documentación. Ingeniería inversa de la arquitectura, mapeo de dependencias, identificación de flujos de datos, documentación de procesos de negocio con ayuda de los stakeholders del negocio.
  2. Mes 2: Arquitectura objetivo y piloto. Diseño de la nueva arquitectura, selección de tecnologías, piloto sobre el módulo más sencillo (proof of concept). Primera validación del enfoque.
  3. Meses 3-4: Extracción del primer módulo productivo. Patrón Strangler Fig, shadow mode durante 2-3 semanas, cutover de tráfico, hypercare. Primer valor real de negocio.
  4. Meses 5-12: Extracción iterativa de los siguientes módulos. Cada uno en un ciclo de 4-6 semanas: refactor → tests → shadow → producción → hypercare. Mejora continua del proceso, reducción del tiempo por módulo.
  5. Meses 12-18: Migración de datos y retirada del monolito. Cuando todos los módulos críticos están extraídos, finalizamos la migración de datos históricos, apagamos el sistema antiguo y archivamos. A celebrar.

Sistema antiguo vs. modernizado

AspectoSistema legacy (típico)Tras la modernización
Tiempo para entregar una nueva funcionalidad4-8 semanas (alto riesgo de regresión)3-7 días (tests automáticos minimizan el riesgo)
Cobertura de tests5-15% (o ninguna)>80%, en el pipeline CI/CD
Disponibilidad de desarrolladoresBaja (tecnología obsoleta)Alta (stacks populares y modernos)
SeguridadBibliotecas antiguas con CVEs sin parchearEscaneo OWASP, gitleaks, actualizaciones automáticas
EscaladoVertical (más recursos para el monolito)Horizontal (escalado de microservicios concretos)
ObservabilidadLogs en ficheros, sin métricasPrometheus + Grafana + Sentry + SIEM
Compliance (RGPD, EU AI Act, ISO 27001)Exigente, costoso de demostrarIncorporado a la arquitectura, listo para auditoría

Seis riesgos típicos — y cómo los abordamos

Riesgo: Sistema legacy sin tests

Mitigación: Primero construimos tests de caracterización (capture tests) — grabando el comportamiento actual del sistema a partir de logs de producción y capturas de tráfico. Solo entonces comenzamos el refactor, con los tests como red de seguridad.

Riesgo: Conocimiento concentrado en una persona („truck factor 1")

Mitigación: La transferencia de conocimiento empieza la primera semana del proyecto. Todas las reuniones con la persona que conoce el sistema se graban y transcriben, los procesos clave se documentan, las decisiones de arquitectura se justifican. Al finalizar, todo el equipo entiende el sistema.

Riesgo: Ralentización temporal del equipo

Mitigación: Durante los primeros 2-3 meses, el equipo mantiene el sistema antiguo + construye el nuevo. Ralentización natural del ritmo de cambio. Lo mitigamos: priorizando los cambios que solo van al nuevo sistema y congelando los cambios de baja prioridad en el antiguo.

Riesgo: Migración de datos

Mitigación: Cada migración de datos tiene tres fases: dry-run (sobre copia de producción), staging (entorno de pruebas con datos a escala real), producción (en ventana de servicio o de forma incremental). Plan de rollback listo antes de empezar.

Riesgo: Resistencia organizacional

Mitigación: Comunicación con el negocio desde el primer día: por qué modernizamos, qué cambia para el usuario, qué calendario, cómo medimos el éxito. La primera iteración se elige para mostrar rápidamente un valor tangible (p. ej. una nueva UI o un informe más rápido).

Riesgo: Subestimación del coste

Mitigación: Discovery (1-2 semanas) antes de presupuestar el proyecto. Iteraciones de 2-3 semanas con entregables concretos — es más fácil corregir el rumbo que en un proyecto largo „todo a la vez". Presupuesto con un colchón del 20-30% para imprevistos.

Preguntas frecuentes

¿Qué es un sistema legacy?
Un sistema legacy es software que aún corre en la organización pero se basa en tecnología obsoleta, arrastra deuda técnica profunda, carece de tests o documentación, o ha perdido al desarrollador que lo escribió. Ejemplos clásicos: una aplicación monolítica en PHP 5.x o .NET Framework 4.0, una base de datos sin migraciones, un frontend en jQuery, despliegue por FTP. Funciona, pero cada cambio es de alto riesgo y alto coste.
¿Por qué modernizar si el sistema funciona?
Tres razones principales. Primera: el coste de mantenimiento crece exponencialmente con la edad del sistema — cada vez menos desarrolladores conocen la tecnología, cada cambio lleva más tiempo, cada bug tiene un radio de impacto mayor. Segunda: riesgo de seguridad — frameworks antiguos con vulnerabilidades sin parchear, sin soporte del proveedor, incumplimiento del RGPD/ISO 27001. Tercera: bloqueo del crecimiento del negocio — los nuevos requisitos (mobile, API, integraciones, IA) son difíciles o imposibles de añadir.
¿No es más fácil reescribirlo todo desde cero?
El clásico dilema „rewrite vs. refactor". Los rewrites son conceptualmente tentadores, pero en la práctica: tardan 2-3 veces más de lo previsto, el proyecto se hunde bajo el peso de reconstruir la lógica de negocio invisible y, mientras tanto, el sistema antiguo sigue necesitando evolución (trabajo duplicado). Nuestra experiencia: 9 de cada 10 modernizaciones exitosas son refactor incremental (patrón Strangler Fig) — reemplazar piezas del sistema antiguo gradualmente preservando la continuidad del negocio. Un rewrite solo tiene sentido para sistemas muy pequeños.
¿Requiere la modernización un downtime de negocio?
En la inmensa mayoría de proyectos, no. Utilizamos patrones que permiten cambiar componentes „en caliente": blue-green deployment, feature flags, dark launches, ejecución paralela de código antiguo y nuevo con comparación de resultados (shadow mode). Pueden ser necesarias ventanas de servicio cortas para migraciones de base de datos con cambios significativos de esquema, pero las planificamos con antelación (típicamente de noche, en fin de semana) y con plan de rollback completo.
¿Cuánto tarda una modernización típica?
Depende de la escala. Un único módulo monolítico extraído como microservicio: 1-2 meses. Una modernización mayor (5-10 módulos, nueva base de datos, nueva API): 6-12 meses en iteraciones de 2-3 semanas. Una transformación completa de monolito enterprise: 18-36 meses, pero el valor de negocio aparece tras la primera iteración — cada módulo extraído ofrece beneficios inmediatos (cambios más rápidos, menor riesgo, mejor observabilidad).
¿Desde qué tecnologías migramos con más frecuencia?
Rutas más comunes: PHP 5/7 → PHP 8 o Python (FastAPI) o Node.js (Express/Fastify). .NET Framework 4.x → .NET 8 o Java/Spring Boot. Java EE (JBoss/WebSphere) → Spring Boot o Quarkus. jQuery + plantillas monolíticas → React/Vue/Astro. Oracle DB → PostgreSQL (ahorros significativos en licencias). On-premise → cloud (AWS, Azure, GCP, cloud privado local).
¿Qué pasa con las integraciones existentes con otros sistemas?
Cada integración existente se mapea en la fase de discovery. El plan de migración cubre: preservar los contratos actuales (los clientes internos y externos no notan cambio alguno), introducir versionado (v1 contrato antiguo, v2 nuevo), migrar consumidores a v2 gradualmente y solo después retirar v1. Compatibilidad hacia atrás total durante la migración.
¿Cómo reducís el riesgo de negocio?
Cinco capas: 1) incrementalidad — reemplazamos un módulo cada vez, no todo a la vez; 2) tests de caracterización — antes del refactor capturamos el comportamiento actual del sistema (capture tests), que luego verifican que nada se ha roto; 3) feature flags — la nueva funcionalidad se despliega gradualmente (1% de usuarios → 10% → 50% → 100%); 4) plan de rollback para cada despliegue (<5 min); 5) hypercare tras el lanzamiento (monitorización intensiva de 2-4 semanas).
¿Qué pasa con la documentación del sistema que no existe?
Un problema legacy habitual. Primera etapa del proyecto: ingeniería inversa de la documentación. Los agentes IA analizan el código, el esquema de base de datos y los logs de producción y generan: diagrama de arquitectura, lista de endpoints, mapa de dependencias, descripción de procesos de negocio. Esta documentación se verifica luego con las personas de negocio (¿el proceso es como lo entendimos por el código?). Resultado: documentación completa antes de iniciar el refactor, útil no solo para el proyecto de modernización sino también para el equipo de producto.
¿Cómo se compara el coste de la modernización con el de mantener el sistema antiguo?
A corto plazo, la modernización es más cara que el mantenimiento (inversión en refactor + mantenimiento del sistema antiguo en paralelo). El punto de equilibrio (cuando el sistema nuevo es más barato de mantener que el antiguo) llega típicamente tras 12-18 meses. A partir de ahí el sistema nuevo: cuesta menos mantener (menos desarrolladores, más automatización), permite cambios más rápidos (menor time-to-market) y reduce el riesgo (mejor observabilidad, más tests, aislamiento de fallos).

Empecemos con una auditoría

Auditoría técnica de una semana: mapeo del estado actual, identificación de las áreas de modernización más urgentes, plan por fases con resultados de negocio concretos en la primera iteración.