Saltar al contenido
ROXEX Labs
Desarrollo Web

Heredar una app sin dueño: auditar, estabilizar o reescribir

Checklist para auditar una aplicación heredada (repo, build, dependencias, secretos, datos, hosting), puntuar riesgos y decidir si estabilizar o reescribir.

Por Levi Olivare · ROXEX Labs17 min de lectura
Código legacyAuditoría de códigoSoftware a medidaStrangler figDeuda técnicaSeguridad
Desarrollo Web

Te llega una aplicación que hace algo importante para el negocio (facturar, planificar repartos, gestionar pedidos) y la persona que la construyó ya no está. No hay documentación, nadie sabe muy bien cómo se despliega y cada cambio da miedo. Es una situación frecuente y tiene arreglo, pero el orden importa: primero asegurar, después entender, luego estabilizar y solo entonces decidir si se mejora lo que hay o se reescribe por partes.

En esta guía te proponemos una checklist para auditar una aplicación heredada, una forma sencilla de puntuar el riesgo, criterios para elegir entre estabilizar y reescribir, cómo funciona la reescritura por módulos (el patrón strangler fig) y cómo plantearlo como proyecto con alcance y precio cerrados. Los ejemplos son hipotéticos y están marcados como tales; las fuentes externas están enlazadas al final.

Qué es una "app sin dueño"

No es solo código antiguo. Una aplicación sin dueño es una que nadie en la empresa puede explicar ni cambiar con confianza. Suele tener varios de estos síntomas:

  • •El desarrollador original (interno, freelance o agencia) se fue y no dejó traspaso.
  • •No está claro quién controla el repositorio, el dominio, el servidor o las cuentas de proveedores.
  • •Desplegar es un ritual que solo sabía hacer una persona.
  • •No hay pruebas automatizadas, o las que hay no se ejecutan.
  • •Los errores se descubren porque llama un cliente.

La edad del código importa menos que esto. Una aplicación de hace diez años bien documentada es más fácil de mantener que una de hace dos que nadie entiende.

Semana cero: asegurar antes de auditar

Antes de evaluar la calidad del código hay que asegurarse de que no se va a perder nada. Esta lista no es la auditoría; es lo que evita que la auditoría llegue tarde:

  1. 1.Inventario de accesos. Repositorio, servidor o plataforma de hosting, base de datos, dominio y DNS, correo transaccional, pasarela de pago y cuentas de servicios externos. Para cada uno: quién es el titular, quién tiene acceso hoy y a nombre de quién se factura.
  2. 2.Copia de seguridad verificada. Del código, de la base de datos y de los ficheros que suben los usuarios. Verificada significa restaurada en otro sitio al menos una vez: una copia que nunca se ha restaurado es una hipótesis.
  3. 3.Congelar los cambios que no sean urgentes. Mientras no sepas cómo se despliega, cada cambio es un riesgo.
  4. 4.Recoger el conocimiento que queda. Las personas que usan la aplicación cada día saben qué falla, qué rodeos hacen y qué pantallas evitan. Una hora de conversación con ellas ahorra muchas horas leyendo código.

Si el desarrollador anterior sigue localizable, pídele un traspaso, aunque sea breve: credenciales, cómo se despliega y qué partes le preocupaban. Es la información más barata que vas a conseguir.

La checklist de auditoría: ocho áreas

Para cada área te contamos qué mirar, qué señales deberían preocuparte y qué debería quedar escrito al terminar. El resultado de una auditoría no es una opinión sobre si el código es "bonito", sino un mapa de riesgos con evidencias.

1. Repositorio y propiedad

Qué mirar: si existe un repositorio Git, si contiene todo lo que está en producción, a nombre de quién está y si el historial de cambios tiene sentido.

Señales de alarma: el código de producción no coincide con el del repositorio (se editaba directamente en el servidor), hay varias copias con nombres como "final" o "nuevo", o el repositorio está en una cuenta personal del desarrollador anterior.

Qué debe quedar: el repositorio a nombre de la empresa, con una rama que corresponde exactamente a lo que hay en producción. Si no existe, el primer trabajo es crearlo a partir de lo que está desplegado.

2. ¿Se puede compilar y desplegar desde cero?

Es la prueba más reveladora y la más infravalorada. Coge una máquina limpia, sigue (o escribe) las instrucciones y comprueba si sale una versión que funciona igual que la de producción.

El proyecto Reproducible Builds define las compilaciones reproducibles como un conjunto de prácticas que crean un camino verificable de forma independiente desde el código fuente hasta el binario. Una aplicación de negocio no necesita ese nivel de rigor, pero la idea de fondo es la misma: si no puedes reconstruir lo que está en producción a partir del repositorio, no controlas tu aplicación.

Señales de alarma: versiones del lenguaje o del framework sin fijar, dependencias sin fichero de bloqueo (lockfile), pasos manuales que nadie ha escrito y scripts que solo funcionan en el portátil de alguien.

Qué debe quedar: un documento corto (o un script) que lleve de un repositorio recién clonado a un entorno funcionando, y una forma repetible de desplegar.

3. Dependencias y vulnerabilidades conocidas

Casi toda aplicación moderna está hecha en buena parte de código de terceros: librerías, frameworks, el propio servidor. OWASP incluye los componentes vulnerables y desactualizados en su Top 10 de 2021 (categoría A06) y recomienda, entre otras cosas, eliminar las dependencias que no se usan, mantener un inventario continuo de versiones, vigilar las bases de datos de vulnerabilidades CVE y NVD y prestar atención a los componentes que ya no reciben mantenimiento ni parches de seguridad.

Para no revisar a mano cientos de paquetes existen herramientas de análisis de composición de software (SCA). Dos ejemplos:

  • •OWASP Dependency-Check, que identifica las dependencias de un proyecto y las cruza con las vulnerabilidades publicadas en la NVD.
  • •OSV-Scanner, que analiza ficheros de bloqueo, directorios o imágenes de contenedor contra la base de datos abierta OSV.

Las vulnerabilidades suelen venir con una puntuación CVSS (la versión vigente es la 4.0) que resume su gravedad. Úsala para ordenar, no para decidir sola: una vulnerabilidad grave en una librería que solo usa un script interno puede importar menos que una media en el formulario público de acceso. Lo que cuenta es la exposición real.

Señales de alarma: versiones del lenguaje o del framework que ya no reciben parches de seguridad, librerías abandonadas y dependencias copiadas a mano dentro del repositorio, que ningún escáner detecta.

Qué debe quedar: inventario de dependencias, lista de vulnerabilidades conocidas ordenada por exposición real y una estimación de lo que cuesta poner al día cada componente crítico.

4. Pruebas

Qué mirar: si hay pruebas automatizadas, si se ejecutan, si pasan y, sobre todo, qué cubren. Muchas pruebas sobre funciones auxiliares valen menos que cinco sobre el cálculo de facturas.

Señales de alarma: no hay pruebas; hay pruebas, pero están desactivadas; o nadie sabe cuál es el comportamiento correcto de un cálculo, solo el actual.

Ese último punto es clave en una aplicación heredada. A menudo no hay especificación, y la única referencia fiable es lo que el sistema hace hoy. Antes de cambiar nada en una zona crítica conviene escribir pruebas que fijen ese comportamiento actual (a veces se llaman pruebas de caracterización), aunque incluya algún error conocido. Así cualquier cambio posterior se compara contra una referencia, y los errores se corrigen a propósito, no por accidente.

Qué debe quedar: una lista de los flujos críticos (cobros, facturas, permisos, integraciones) con su nivel de cobertura, y un plan para cubrir primero los que más duelen si fallan.

5. Modelo de datos

Los datos suelen sobrevivir a la aplicación. Puedes reescribir todas las pantallas, pero los pedidos, los clientes y las facturas de años anteriores tienen que seguir ahí.

Qué mirar: el esquema de la base de datos, qué tablas se usan de verdad, si hay claves y restricciones o todo es texto libre, campos que significan cosas distintas según la época, datos duplicados y dónde hay datos personales.

Señales de alarma: lógica de negocio escondida en la base de datos (disparadores, procedimientos almacenados) que nadie conoce, varias aplicaciones escribiendo en las mismas tablas, falta de restricciones que deja datos incoherentes y datos personales que nadie sabía que se guardaban.

Qué debe quedar: un diagrama del modelo, un diccionario de los campos importantes y una lista de las anomalías detectadas. Si la decisión acaba siendo reescribir, esto es la base de la migración de datos.

6. Secretos y credenciales

En código heredado es habitual encontrar contraseñas, claves de API o cadenas de conexión escritas en el propio código o en ficheros de configuración versionados. La hoja de buenas prácticas de OWASP sobre gestión de secretos recomienda detectarlos con herramientas específicas, combinar más de una porque cada una tiene huecos, y centralizarlos en un gestor de secretos con el mínimo de permisos necesario.

Dos detalles de esa misma guía conviene tenerlos presentes al heredar una aplicación:

  • •Si un secreto se ha expuesto, el orden es revocarlo, rotarlo y después borrarlo de donde aparezca. Reiniciar la aplicación no invalida una credencial robada: sigue siendo válida hasta que el servicio que la emitió la revoca o caduca.
  • •Borrar un secreto del historial de Git tiene coste: reescribir el historial rompe las referencias a esos commits. Por eso lo primero es revocar; limpiar el historial es secundario.

Asume que cualquier credencial que conocía el equipo anterior debe cambiarse, aunque no haya ningún motivo para desconfiar. No es una acusación; es higiene.

Qué debe quedar: un inventario de secretos (qué es cada uno, para qué sirve y quién puede leerlo), las credenciales críticas rotadas y los secretos fuera del código.

7. Hosting e infraestructura

Qué mirar: dónde se ejecuta la aplicación, con qué versión de sistema operativo y de entorno de ejecución, quién paga la factura, si hay entornos separados de pruebas y de producción, cómo se hacen las copias y cuánto se tarda en restaurarlo todo.

Señales de alarma: un único servidor configurado a mano que nadie se atreve a reiniciar, un sistema operativo sin soporte, un certificado o un dominio que caducan sin que nadie reciba el aviso, o la cuenta del proveedor a nombre de alguien que ya no está.

Qué debe quedar: un esquema de la infraestructura, la lista de costes recurrentes con sus titulares y un procedimiento de restauración probado.

8. Observabilidad

Si la única forma de enterarte de un fallo es que te llame un cliente, no puedes saber si tus cambios mejoran o empeoran las cosas.

El libro de Site Reliability Engineering de Google propone cuatro señales básicas para vigilar un servicio: latencia (cuánto tarda en responder), tráfico (cuánta demanda recibe), errores (qué proporción de peticiones falla) y saturación (lo cerca que está de su límite). No hace falta un sistema sofisticado para empezar: un registro de errores centralizado y unas pocas métricas ya cambian la conversación.

Señales de alarma: no hay registros, o los hay pero nadie los mira; los errores se capturan y se descartan sin dejar rastro; no hay alertas.

Qué debe quedar: un registro de errores en producción y una línea base de esas señales antes de empezar a cambiar cosas. Sin línea base no podrás demostrar que la estabilización ha servido.

Cómo puntuar el riesgo

Con las ocho áreas revisadas tendrás una lista larga de problemas, y no todos importan igual. Una forma sencilla de ordenarlos, que no es un estándar sino una heurística práctica, es puntuar cada hallazgo de 1 a 3 en dos ejes:

  • •Probabilidad: ¿qué posibilidades hay de que esto cause un problema en los próximos meses?
  • •Impacto: si ocurre, ¿qué pasa? 1, una molestia; 2, se para una función o hay que hacer trabajo a mano; 3, se para el negocio, se pierden datos o hay una brecha de seguridad.

Multiplica los dos valores y tendrás una puntuación entre 1 y 9. Lo que puntúe 6 o 9 entra en la fase de estabilización, sin discusión. Lo que puntúe 3 o 4 se planifica. Lo que puntúe 1 o 2 se anota y se revisa más adelante.

Así podría quedar la tabla de una aplicación hipotética:

Hallazgo (ejemplo hipotético)ProbabilidadImpactoPuntuación
Sin copia de seguridad restaurable de la base de datos236
Clave de la pasarela de pago escrita en el código236
Framework sin parches de seguridad326
Sin pruebas en el cálculo de facturas224
Sin registro de errores centralizado313
Estilo de código inconsistente313

Los valores están puestos para ilustrar el método. La puntuación tiene además una ventaja que no es técnica: convierte una discusión de opiniones ("este código es horrible") en una lista que la dirección puede entender y priorizar.

Estabilizar, refactorizar o reescribir

Con el mapa de riesgos en la mano hay tres caminos, que a menudo se combinan:

CaminoQué esCuándo encaja
EstabilizarCerrar los riesgos graves sin cambiar lo que hace la aplicación: copias, secretos, parches, despliegue repetible, registro de erroresSiempre, como primer paso
RefactorizarMejorar la estructura interna poco a poco, con pruebas que protejan el comportamientoLa aplicación cumple su función y su tecnología tiene soporte
Reescribir por módulosSustituir partes del sistema por código nuevo mientras lo antiguo sigue funcionandoLa tecnología no tiene futuro, o hay partes que bloquean lo que el negocio necesita

Falta la opción que más tienta: tirarlo todo y empezar de cero. Joel Spolsky la describió, en un artículo del año 2000 que se sigue citando, como un error estratégico grave. Su argumento es que el código antiguo que parece feo suele contener años de correcciones de errores encontrados con el uso real, y una reescritura los pierde; mientras tanto, el negocio espera. Su ejemplo fue Netscape, que dedicó unos tres años a reescribir su navegador desde cero mientras perdía cuota de mercado.

Eso no significa que reescribir esté prohibido. Significa que la reescritura total de golpe concentra todo el riesgo al final, cuando ya no hay marcha atrás. Estas señales indican que una reescritura, por partes, está justificada:

  • •La plataforma o el lenguaje ya no tienen soporte de seguridad, y ponerlos al día equivale a reescribir.
  • •No hay quien quiera o sepa mantener esa tecnología a un coste razonable.
  • •Cada cambio pequeño cuesta semanas porque todo está acoplado con todo.
  • •El negocio necesita algo que la arquitectura actual no permite, por ejemplo abrir un portal a clientes sobre un sistema pensado para un único usuario.

Y estas, que conviene estabilizar y mejorar lo que hay:

  • •La aplicación hace bien su trabajo y los problemas son de operación (despliegues, copias, secretos), no de diseño.
  • •La tecnología tiene soporte y comunidad.
  • •Las quejas vienen sobre todo de quien lee el código, no de quien usa la aplicación.

Esa última es la trampa más habitual. Spolsky apunta que leer código es más difícil que escribirlo, y por eso a casi cualquier programador el código ajeno le parece peor de lo que es.

Reescribir por módulos: el patrón strangler fig

Cuando la respuesta es reescribir, la forma más segura de hacerlo es gradual. Martin Fowler bautizó este enfoque como Strangler Fig Application por las higueras estranguladoras que vio en los bosques de Queensland, en Australia: crecen alrededor de un árbol huésped hasta que se sostienen solas. En la versión revisada del artículo, de 2024, explica que los planes de sustitución completa han fracasado con frecuencia porque sustituir un sistema serio lleva mucho tiempo, los usuarios no pueden esperar a las funciones nuevas y el comportamiento existente es difícil de especificar.

La idea es construir lo nuevo alrededor de lo antiguo e ir moviendo funcionalidad poco a poco:

  1. 1.Identificar costuras (seams). Puntos donde se puede separar una parte del sistema: una pantalla, un informe, una integración, un tipo de usuario.
  2. 2.Poner algo delante. Un enrutador, un proxy o una capa de la propia aplicación que decide si cada petición la atiende el sistema antiguo o el nuevo.
  3. 3.Sustituir un módulo cada vez. Empezando por uno que aporte valor y tenga poco riesgo, para aprender el proceso.
  4. 4.Retirar lo antiguo cuando ya no recibe tráfico.

Fowler llama arquitectura de transición al código que solo existe para que lo nuevo y lo antiguo convivan: adaptadores, sincronización de datos, el propio enrutador. Es un coste que desaparece al terminar, y defiende que compensa porque reduce el riesgo y adelanta el valor: la inversión y el retorno llegan de forma gradual y visible.

Una técnica relacionada, para el interior del código, es Branch by Abstraction, también descrita por Fowler: se pone una capa de abstracción entre el código que usa un componente y su implementación, se construye la implementación nueva detrás de esa misma capa, se cambian los usos poco a poco y, cuando la antigua ya no se usa, se elimina. El sistema sigue compilando y desplegándose durante todo el proceso.

Por dónde empezar

Un orden que suele funcionar:

  • •Primero, lo que más duele y menos depende de lo demás. Un informe que tarda horas o una integración que falla cada semana son buenos candidatos: el beneficio se nota y el contagio es limitado.
  • •Los datos, con cuidado. Durante la transición, el sistema antiguo y el nuevo pueden tener que leer o escribir los mismos datos. Decide pronto cuál es la fuente de verdad de cada entidad para no acabar con dos versiones del mismo cliente.
  • •Lo más acoplado, al final. El núcleo que lo toca todo se mueve cuando ya has sacado lo de alrededor y el proceso es rutinario.

Los riesgos del enfoque

La reescritura por módulos no es gratis. Durante un tiempo mantienes dos sistemas, la arquitectura de transición añade piezas que también pueden fallar y existe el riesgo de quedarse a medias: la parte fácil migrada y la difícil, la que motivó todo, sin tocar. Para evitarlo, el plan necesita un final explícito: qué módulos se migran, en qué orden y cuándo se apaga el sistema antiguo.

Un ejemplo hipotético

Este caso es inventado para ilustrar el proceso; no describe a ningún cliente.

Una distribuidora usa una aplicación web interna para planificar repartos. La hizo un freelance hace años y desde entonces nadie la mantiene. Funciona, pero cada cambio de tarifas obliga a tocar el código, y el último intento de añadir un campo la dejó caída una mañana.

La auditoría encuentra el código de producción distinto del que hay en el repositorio, una versión del framework sin parches de seguridad, la clave del proveedor de mapas escrita en el código, ninguna prueba, un modelo de datos razonable y ningún registro de errores.

La decisión no es reescribir de golpe. Primero se estabiliza: el repositorio pasa a reflejar producción, la clave se revoca y se sustituye por una nueva guardada fuera del código, se monta un despliegue repetible con copias restaurables y un registro de errores, y se escriben pruebas que fijan el cálculo actual de rutas y tarifas. Con eso, la aplicación deja de dar miedo.

Después, como el framework no tiene soporte, se plantea una reescritura por módulos: primero el de tarifas, que es el que más cambios pide, detrás de una capa que decide qué versión responde; después la planificación; al final, el núcleo de pedidos. Cada módulo es una entrega con su demo y su validación, y el sistema antiguo se apaga cuando ya no atiende a nadie.

Cómo plantearlo como proyecto

Lo sensato es no comprometer todo el presupuesto antes de saber lo que hay. Por eso conviene separar el trabajo en fases, cada una con su alcance, su entregable y una decisión al final:

FaseEntregableDecisión al terminar
AuditoríaMapa de riesgos con evidencias; inventario de accesos, dependencias y secretos; recomendación razonadaEstabilizar y mantener, o estabilizar y reescribir por módulos
EstabilizaciónRiesgos graves cerrados, despliegue repetible, copias restauradas, pruebas sobre lo crítico, registro de erroresQué módulos se reescriben y en qué orden
Reescritura por módulosCada módulo nuevo en producción, con su migración de datos y la parte antigua retiradaSiguiente módulo, o parar si lo que queda funciona bien
MantenimientoActualizaciones, correcciones y evoluciónSeguir o traspasar a tu equipo

Así encaja con nuestro proceso: empieza con una llamada de 30 minutos, sin coste, para entender qué hace la aplicación, quién la usa y qué te preocupa; sigue una propuesta cerrada con alcance, hitos, plazos, presupuesto y entregables, que revisamos contigo antes de firmar; el trabajo se hace por iteraciones, con demo y revisión al final de cada una y acceso al repositorio y a un entorno de staging desde el primer día; y tras la entrega hay 30 días de soporte incluidos.

Sobre el precio: la auditoría y la estabilización se presupuestan en la propuesta según el tamaño del sistema, porque varían mucho de una aplicación a otra. Para el servicio de software a medida, la referencia publicada en nuestra página de precios es la línea de web app o MVP (de 8.000 a 30.000 €, de 2 a 6 meses), y el mantenimiento posterior puede ir con el retainer técnico (de 2.500 a 6.000 € al mes, sin permanencia mínima) o con tu propio equipo. Qué mueve esas cifras lo explicamos en cuánto cuesta desarrollar software a medida.

En cualquier caso, el repositorio, los dominios y los accesos quedan a tu nombre. Después de haber heredado una aplicación sin dueño, lo último que quieres es volver a depender de una sola persona.

Errores habituales

  • •Empezar por reescribir. Sin auditoría no sabes qué hace el sistema; sin estabilización, el antiguo sigue fallando mientras construyes el nuevo.
  • •Confundir feo con roto. Un código poco elegante que hace bien su trabajo no es la prioridad.
  • •Cambiar sin red. Tocar el cálculo de facturas sin pruebas que fijen el comportamiento actual es la forma más rápida de crear un problema nuevo.
  • •Olvidar los datos. La migración de datos suele ser la parte más subestimada de cualquier reescritura.
  • •No rotar credenciales. Las claves que conocía el equipo anterior deben cambiarse, aunque la relación terminara bien.
  • •Un plan sin final. Una reescritura por módulos sin fecha para apagar lo antiguo acaba en dos sistemas para siempre.

Preguntas frecuentes

¿Cuánto dura una auditoría de código heredado? Depende del tamaño de la aplicación, del número de integraciones y de cuántos accesos haya que recuperar. Por eso no damos un plazo genérico: lo fijamos en la propuesta, después de ver el sistema en la llamada inicial.

¿Hace falta el desarrollador anterior para auditar la aplicación? No, aunque ayuda. Con acceso al código, a la infraestructura y a las personas que usan la aplicación se puede reconstruir casi todo. Si el desarrollador anterior está localizable, un traspaso breve ahorra tiempo.

¿Es mejor reescribir con una tecnología moderna? Solo si la tecnología actual es el problema. Si la aplicación hace bien su trabajo y la plataforma tiene soporte, estabilizar y mejorar suele costar menos y tener menos riesgo. Cuando hay que reescribir, hacerlo por módulos permite que el negocio siga funcionando.

¿Qué es el patrón strangler fig? Es una forma de sustituir un sistema poco a poco: se construye lo nuevo alrededor de lo antiguo y se mueve funcionalidad módulo a módulo hasta que lo antiguo se puede apagar. El nombre se lo puso Martin Fowler.

¿Podéis trabajar sobre una aplicación que hizo otro proveedor? Sí. Empezamos revisando el código, la infraestructura y los datos y, con eso, te proponemos si conviene estabilizar y documentar lo que hay o reescribirlo por módulos sin parar el negocio.

¿Qué pasa con los datos personales que guarda la aplicación? Forman parte de la auditoría: dónde están, quién puede verlos y si se guardan más de los necesarios. Si hay dudas legales sobre su tratamiento, conviene que las revise quien te asesore en protección de datos.

Cómo seguir

Si has heredado una aplicación que nadie quiere tocar, cuéntanos qué hace, quién la usa y qué te preocupa. En la llamada inicial te diremos por dónde empezaríamos y si tiene sentido auditarla. Puedes escribirnos aquí, ver el servicio de desarrollo de software a medida o revisar cómo trabajamos. Si lo que te preocupa es el mantenimiento de una web más que de una aplicación, lo tratamos en por qué el mantenimiento web es vital.

Fuentes

  • •Martin Fowler — Strangler Fig Application (bliki, versión revisada de 2024). https://martinfowler.com/bliki/StranglerFigApplication.html
  • •Martin Fowler — Branch By Abstraction (bliki, 2014). https://martinfowler.com/bliki/BranchByAbstraction.html
  • •Joel Spolsky — Things You Should Never Do, Part I (Joel on Software, 2000). https://www.joelonsoftware.com/2000/04/06/things-you-should-never-do-part-i/
  • •OWASP Top 10:2021 — A06 Vulnerable and Outdated Components. https://top10.owasp.org/2021/A06_2021-Vulnerable_and_Outdated_Components
  • •OWASP Cheat Sheet Series — Secrets Management Cheat Sheet. https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html
  • •OWASP — Dependency-Check. https://owasp.org/www-project-dependency-check/
  • •OSV — Open Source Vulnerabilities (base de datos y OSV-Scanner). https://osv.dev/
  • •FIRST — Common Vulnerability Scoring System (CVSS). https://www.first.org/cvss/
  • •Google — Site Reliability Engineering, capítulo 6: Monitoring Distributed Systems. https://sre.google/sre-book/monitoring-distributed-systems/
  • •Reproducible Builds. https://reproducible-builds.org/

¿Hablamos de tu proyecto?

Una llamada de 30 minutos, gratis y sin compromiso, con quien escribiría el código.