Migrare senza fermare il vecchio sistema: guida alla modernizzazione graduale

Un sistema legacy è un software che sostiene l'attività da anni, ma diventa sempre più difficile da mantenere, modificare e collegare ad altri sistemi. Sostituirlo in un'unica operazione concentra tutti i rischi in un solo giorno. Questa guida esamina come rinnovarlo modulo per modulo mentre il vecchio sistema continua a funzionare.

Perché un unico grande passaggio è rischioso?

La prima soluzione che viene in mente per rinnovare un vecchio sistema è riscriverlo da zero e passare interamente al nuovo in una data stabilita. Questo approccio, noto come migrazione «big bang», sembra lineare sulla carta: un progetto, un giorno di passaggio e il vecchio sistema viene spento. In pratica, tre problemi crescono contemporaneamente.

  • Lungo periodo di congelamento. Mentre si prepara il nuovo sistema, le funzionalità del vecchio vengono rinviate o sviluppate due volte. I reparti aspettano mesi e, nel frattempo, proliferano soluzioni temporanee: un altro file Excel o un'e-mail di approvazione aggiuntiva.
  • Migrazione dei dati in un'unica operazione. I dati accumulati negli anni contengono campi non documentati, registrazioni incoerenti ed eccezioni. Spostarli tutti in una notte significa scoprire i problemi per la prima volta in produzione.
  • Obiettivo in movimento. Durante il progetto l'attività continua a cambiare: nuovi prodotti, nuove norme, nuovi partner. Quando il sistema è pronto, una parte dei requisiti iniziali non è più valida.

A ciò si aggiungono le regole aziendali nascoste. Nei vecchi sistemi, molte esistono solo nel codice e nella memoria di pochi dipendenti esperti. Riscrivendo da zero, alcune emergono soltanto dopo la migrazione, quando qualcosa va storto.

Strangler Fig: rinnovare circondando il vecchio sistema

L'alternativa è sostituire il sistema per parti. Il modello «Strangler Fig», diffuso da Martin Fowler, prende il nome dal fico strangolatore: germoglia su un altro albero, porta gradualmente le radici al suolo e con il tempo ne prende il posto. Nel frattempo, l'albero che lo sostiene rimane in piedi.

Nel software funziona così: un livello di instradamento viene posto davanti al sistema esistente, le funzioni vengono riscritte una alla volta nel nuovo e, quando ciascuna è pronta, il relativo traffico viene reindirizzato. Il vecchio sistema continua a funzionare finché non viene trasferito anche l'ultimo modulo. Ogni fase va in produzione autonomamente; gli utenti vedono valore fin dalla prima fase, non solo alla fine del programma.

Una migrazione graduale non significa meno lavoro. Gestire per un periodo due sistemi e i relativi flussi di dati richiede uno sforzo aggiuntivo. In cambio, il rischio viene suddiviso in parti più piccole e risultati e limiti del ripristino possono essere valutati per ogni fase.

Fasi della migrazione graduale

I passaggi seguenti formano un ciclo ripetuto per ciascun modulo. Per renderli concreti, usiamo un esempio ipotetico: un distributore gestisce ordini, prezzi, scorte, fatturazione e reportistica in un unico sistema legacy sviluppato da vent'anni.

1. Mappa moduli, dipendenze e dati

Prima ricostruisci ciò che il sistema fa davvero: funzioni, team che le usano, tabelle scritte dai moduli, processi notturni e integrazioni. La mappa nasce dalla lettura del codice insieme all'osservazione degli utenti al lavoro; una sola delle due è insufficiente. Documenta già in questa fase il sistema autorevole per ciascun tipo di dato.

2. Scegli la prima porzione

Una buona prima porzione produce valore visibile, ha poche dipendenze ed è misurabile. Nell'esempio la fatturazione può sembrare interessante, ma dipende da contabilità, scorte e integrazioni fiscali: è impegnativa come primo passo. La schermata preventivi usata ogni giorno dal team commerciale è spesso una candidata migliore: frequente, notoriamente lenta e collegata a poche tabelle. Anche la reportistica in sola lettura è un avvio poco rischioso, ma il valore può essere limitato.

3. Introduci un livello di instradamento

Utenti e altri sistemi non accedono più direttamente al vecchio sistema, ma attraverso un gateway API o un livello di instradamento. Inizialmente inoltra tutte le richieste al sistema esistente senza cambiare nulla. A ogni fase successiva reindirizza al nuovo soltanto le richieste interessate. Sul fronte dell'interfaccia può svolgere lo stesso ruolo un'applicazione contenitore che riunisce vecchie e nuove schermate sotto un menu unico.

4. Mantieni sincronizzati i dati tra i due sistemi

Durante il passaggio, gli stessi dati sono presenti in entrambi i sistemi. Due metodi comuni sono:

  • Doppia scrittura: L'applicazione invia la modifica a entrambi i sistemi. Una delle due scritture indipendenti può fallire; ordine delle operazioni, controllo duplicati, compensazioni e riconciliazione regolare vanno progettati separatamente. Scrivere lo stesso dato in due punti non garantisce da solo la coerenza.
  • Change Data Capture (CDC): Le modifiche nel log delle transazioni del vecchio database vengono lette e trasferite come eventi nel nuovo sistema. Poiché consente la sincronizzazione senza modificare il vecchio codice, è spesso preferita quando intervenire sul codice è rischioso.

Qualunque metodo si scelga, ogni registrazione deve avere un'unica fonte autorevole e deve essere eseguita regolarmente una riconciliazione tra le due parti. Quando un modulo passa al nuovo sistema, la fonte autorevole può cambiare. Se i dati devono tornare al vecchio, il trasferimento inverso va progettato separatamente: non si presume che la direzione cambi da sola. Anche il supporto CDC dipende da database, autorizzazioni e trasformazioni dei dati.

5. Esegui in parallelo e confronta

Prima della messa in produzione, il nuovo modulo lavora per un periodo in modalità ombra: si confrontano richieste di lettura o operazioni con effetti collaterali isolati nei due sistemi, mentre l'utente riceve la vecchia risposta. Pagamenti, e-mail, scarichi di magazzino o registrazioni di terze parti non devono essere generati due volte. Le differenze sono uno dei modi più affidabili per individuare regole nascoste. Per esempio, uno sconto applicato a un gruppo di rivenditori solo a fine mese può emergere dal confronto anziché dai documenti.

6. Sposta il traffico gradualmente

Quando le differenze scendono a un livello accettabile, il traffico passa al nuovo modulo per gradi: prima utenti interni, poi una regione o un gruppo di rivenditori, infine tutti. Il passaggio può essere gestito con un feature flag, ma riportare i dati creati nel nuovo sistema è un'attività separata. Fino a quale punto si può tornare indietro, chi avvia il ripristino e come riconciliare i dati vanno provati in anticipo.

7. Disattiva il vecchio modulo e misura

Quando tutto il traffico è passato al nuovo modulo, disattiva davvero quello vecchio: rimuovi i percorsi di codice, ferma i processi notturni e archivia i dati necessari. Ogni modulo legacy non spento rimane un secondo sistema da mantenere. Poi valuta la fase con i criteri definiti all'inizio: durata delle operazioni, tasso di errore, tempi di risposta, richieste di tornare alle vecchie schermate e costi operativi del sistema precedente. Per un confronto significativo devi aver registrato i valori iniziali prima della migrazione.

Migrare i dati dal vecchio sistema: prova, riconciliazione e ripristino

Aver completato il trasferimento non significa che i dati siano utilizzabili. Per esempio, il totale degli ordini può coincidere ma il debito di un cliente essere associato al cliente sbagliato. La decisione di passaggio deve basarsi su risultati accettati sia dal team tecnico sia dal responsabile che usa quei dati nel proprio lavoro.

  1. Mappatura e pulizia. Si documentano corrispondenze tra vecchi e nuovi campi, identificativi persistenti, date, valute, codici di stato e relazioni con i clienti. Il responsabile aziendale decide quali registrazioni vuote, duplicate o invalide correggere, archiviare o non trasferire.
  2. Migrazione di prova. Si trasferiscono dati rappresentativi in un ambiente di test ad accesso limitato, mascherando i dati personali dove necessario. Si misurano durata, carico sul sistema sorgente, registrazioni rifiutate ed effetti della ripetizione.
  3. Riconciliazione. Oltre al numero delle registrazioni, si confrontano importi per cliente, periodo, valuta e stato, righe d'ordine e documenti associati. I campi critici vengono verificati per singola registrazione. Le differenze attese dovute alla trasformazione vengono spiegate; quelle non spiegate hanno un responsabile e una soluzione.
  4. Ultime modifiche e passaggio. Si acquisiscono le registrazioni modificate dopo il caricamento iniziale. Se necessario si apre una finestra di blocco delle scritture; gli utenti passano al nuovo sistema dopo il completamento delle attività in attesa, dell'ultima sincronizzazione e dei controlli di accettazione. La durata della finestra dipende dalle prove.
  5. Prova del ripristino. Quale errore ferma il passaggio, chi decide e qual è l'ultimo punto sicuro per tornare indietro? Si prova separatamente come riportare nel vecchio sistema ordini e pagamenti creati nel nuovo. Un'operazione già eseguita in un sistema esterno non viene annullata automaticamente ripristinando un backup.

Scenario di esempio: migrazione graduale della schermata preventivi

Prezzi e anagrafica clienti restano nel vecchio sistema, mentre la nuova schermata prepara le bozze dei preventivi. Nella prima prova si confrontano prodotti, unità, sconti e arrotondamenti dello stesso preventivo; l'esecuzione in ombra non invia un secondo preventivo al cliente.

Se dopo l'avvio del gruppo pilota occorre tornare alla vecchia schermata, si elencano prima le bozze create nel nuovo sistema con i rispettivi identificativi persistenti. Se esiste un codice di stato sconosciuto al vecchio sistema, il trasferimento inverso si ferma e il responsabile aziendale decide la mappatura. Un ordine definitivo o un documento già inviato all'esterno non è annullato tornando alla vecchia schermata.

Chi accetta il passaggio esamina insieme le differenze ancora aperte e la prova di ripristino. Non si decide di spegnere il vecchio modulo finché la riconciliazione non è completata. È un flusso esemplificativo: nel progetto reale si definiscono separatamente finestra di interruzione e limite del ripristino.

La documentazione AWS sulla validazione dei dati spiega il confronto tra registrazioni sorgente e destinazione e le risorse aggiuntive necessarie alla validazione. L'esempio di ripristino dopo la migrazione dei dati mostra invece l'importanza di una strategia specifica per le modifiche generate nel nuovo sistema (verifica: 13 ottobre 2026). Lo strumento va scelto in base alle possibilità del proprio sistema; nel perimetro della modernizzazione software rientrano anche queste prove e fasi di accettazione.

Calendario: quando va online la prima fase?

La modernizzazione graduale viene pianificata con una tabella di marcia. Il calendario esemplificativo seguente varia in base a preparazione dati, accessi e dipendenze del primo modulo:

  • Discovery (1–2 settimane): Mappa di sistema, dati e processi; mappa dei rischi; proposta della prima porzione. Attività e risultati dello sprint di discovery sono trattati in un articolo separato.
  • Definizione e prototipo (2–3 settimane): Schermate della prima porzione e progettazione dell'integrazione; il prototipo viene provato con utenti reali nella terza settimana.
  • Sviluppo (sprint di 2 settimane): Ogni settimana viene mostrato software funzionante; la prima fase, definita insieme, viene pianificata per andare online in 6–12 settimane.
  • Fasi successive: Gli altri moduli sono ordinati nella tabella di marcia; ciascuno segue lo stesso ciclo e va online autonomamente.

Programmi ampi, come la modernizzazione del sistema centrale, non rientrano in un solo progetto di 6–12 settimane e non si dovrebbe forzarli a farlo. Chiarire subito che questo intervallo riguarda la prima fase, non l'intero programma, aiuta a definire aspettative corrette.

La migrazione graduale non garantisce zero interruzioni in ogni sistema. Trasformazioni dei dati, integrazioni esterne o limiti del rollback possono richiedere finestre di manutenzione; la durata accettabile viene definita nella discovery. Fonte dell'approccio: Martin Fowler — Strangler Fig (verifica: 11 ottobre 2026).

Rischi e come ridurli

La migrazione graduale non elimina il rischio: lo rende visibile e lo suddivide. I rischi principali di questi programmi e le contromisure sono:

RischioCome si manifestaCome ridurlo
Regole aziendali nascosteIl nuovo modulo produce risultati diversi dal vecchio per alcune registrazioniConfronto in modalità ombra; documentazione delle regole emerse tramite test automatici
Divergenza dei datiLo stesso cliente o ordine appare diverso nei due sistemiUnica fonte autorevole, sincronizzazione tramite CDC e riconciliazione periodica
Migrazione incompletaVecchio e nuovo sistema restano attivi insieme a tempo indeterminatoIncludere la data di disattivazione del vecchio modulo nella definizione di ogni fase
Latenza aggiuntivaIl livello di instradamento allunga i tempi di rispostaMantenere leggero il livello e monitorare i tempi fin dall'inizio
Resistenza degli utentiI team vogliono tornare alle vecchie schermateProvare il prototipo con utenti reali prima dello sviluppo; passaggio graduale

Esiste anche un rischio organizzativo: le persone che conoscono meglio il vecchio sistema spesso sostengono anche il carico quotidiano. Pianificare in anticipo il loro tempo per discovery ed esecuzione parallela è importante quanto le misure tecniche.

Che cosa preparare prima di affidare il software esistente a un nuovo team?

Prendere in carico un sistema funzionante non significa riscriverlo subito. Prima bisogna verificare che il nuovo team sappia installare la versione attuale in un ambiente di test separato e rieseguire un flusso essenziale. Se il problema è circoscritto, manutenzione e piccoli miglioramenti possono essere più adatti di una modernizzazione completa.

L'archivio del codice è stato consegnato: il passaggio è davvero concluso?

Il passaggio viene accettato sulla base di evidenze che il nuovo team sappia far funzionare il sistema e che le responsabilità siano chiare. La tabella seguente è un quadro di accettazione esemplificativo: non implica che in ogni progetto occorra trasferire tutti gli account o concedere sempre diritti di amministratore.

AreaEvidenza da cercareDecisione in assenza di evidenza
Codice e pubblicazioneSorgenti corrispondenti alla versione attiva, diritti d'uso e modifica, registri delle dipendenze e compilazione/pubblicazione ripetuta in testIndividua il passaggio di installazione o la risorsa mancante prima di impegnarti su modifiche in produzione.
Account e accessiTitolare dell'account, responsabile degli accessi e di fatture/rinnovi per dominio, cloud, database, e-mail ed eventuali store delle appChiarisci gli accessi dipendenti da una sola persona e il diritto di concedere autorizzazioni; non chiedere elenchi di password.
Backup e ripristinoEsito del ripristino in ambiente separato, accesso controllato a chiavi/configurazioni necessarie e verifica del flusso essenzialeNon considerare l'esistenza di un file di backup una prova di recuperabilità; chiarisci i limiti di perdita dati e interruzione.
Dipendenze esterneInventario di pacchetti/versioni, supporto del produttore, vincoli di licenza e responsabili di API e account esterniNon fissare il perimetro senza verificare manutenibilità e diritto di modifica.
Processi in background e costiAttività pianificate, code, limiti dei tentativi, autorizzazione all'arresto e responsabile dei costi a consumoDefinisci la sequenza di attivazione che impedisce al vecchio e al nuovo ambiente di eseguire due volte la stessa attività.
Responsabilità dell'assistenzaAccesso al monitoraggio, elenco dei problemi noti, decisore in caso d'incidente e decorrenza delle responsabilità tra vecchio e nuovo teamNon considerare automaticamente la consegna del codice come inizio della manutenzione o garanzia di assistenza continua.

Trasferire un account non equivale a ripulire gli accessi. Per esempio, nel trasferimento di un repository GitHub webhook, secret e deploy key possono rimanere associati al repository; gli effetti del passaggio tra account su permessi e funzionalità vanno controllati separatamente. Non presumere che il trasferimento chiuda i vecchi collegamenti ai servizi.

In quale ordine trasferire le responsabilità?

  1. Definisci i confini: Scrivi quali moduli, dati e orari di assistenza vengono trasferiti e quali problemi rimangono esclusi.
  2. Prima analisi e prove: Inizia con gli accessi minimi necessari. Verifica installazione, operazione essenziale e ripristino in test con dati opportunamente mascherati o sintetici.
  3. Registra le decisioni: Ogni questione aperta deve avere responsabile, impatto e motivazione di accettazione o rinvio. Se il sistema può continuare con la manutenzione, riscriverlo non è obbligatorio.
  4. Esegui un passaggio controllato: Verifica nuove autorizzazioni e collegamenti ai servizi; ordina la rimozione dei vecchi accessi e la rotazione delle chiavi necessarie secondo le dipendenze. Le urgenze di sicurezza, come la risposta a incidenti, richiedono un piano separato.

Decisione di esempio: Il nuovo team riesce a far funzionare la schermata ordini, ma il processo notturno delle scorte dipende soltanto dall'account personale del vecchio sviluppatore e il ripristino del backup non è mai stato provato. Si può valutare un perimetro ristretto di manutenzione della schermata; non si può considerare conclusa la presa in carico dell'intero sistema senza evidenza della responsabilità sul processo scorte e sul recupero dati. Lo scenario è fittizio, non un risultato cliente.

Anche la guida Microsoft al passaggio dell'assistenza Dynamics 365 tratta separatamente perimetro dell'assistenza, ruoli e preparazione operativa. Questo quadro generale è un esempio dell'approccio Codariva, non un impegno ad assistere o prendere in carico qualsiasi tecnologia. Per valutare il sistema esistente puoi consultare il perimetro della modernizzazione software. Nel primo incontro condividi finalità, tecnologie e titolari degli accessi attuali, senza inviare password o dati di produzione.

Checklist prima di iniziare

Chiarire i seguenti punti prima della prima fase semplifica anche il resto del programma.

Checklist della modernizzazione graduale

  • Mappa di moduli, dipendenze e dati completata; ogni modulo ha un responsabile aziendale.
  • Fonte autorevole di ciascun tipo di dato documentata.
  • Prima porzione selezionata: valore visibile, poche dipendenze, risultato misurabile.
  • Livello di instradamento progettato; destinazione del traffico gestita da un unico punto.
  • Metodo di sincronizzazione — doppia scrittura o CDC — e report di riconciliazione definiti.
  • Output da confrontare nell'esecuzione parallela e criteri di accettazione definiti.
  • Passaggi di ripristino per traffico e dati, autorità decisionale e ultimo punto sicuro definiti e provati.
  • Data di disattivazione del vecchio modulo inclusa nel piano della fase.
  • Valori iniziali delle metriche di successo registrati prima del passaggio.

Puoi vedere come questo approccio si traduce nelle interfacce nel concept Modernizzazione dell'infrastruttura assicurativa: nell'immaginaria X Sigorta, la prima fase comprende un preventivo kasko in un'unica schermata e un ponte eventi che sincronizza vecchio sistema centrale e nuova piattaforma. Perimetro, sequenza delle fasi e condizioni di consegna sono descritti nel servizio di modernizzazione software.

Se vuoi individuare insieme la prima porzione per il tuo sistema, richiedi un incontro per uno sprint di discovery.

Approfondimenti
Concept di prodotto correlato

Modernizzazione dell'infrastruttura assicurativa

Concept preparato per l'immaginaria X Sigorta: mentre il vecchio sistema polizze viene migrato per fasi senza fermare l'attività, l'agente prepara il preventivo in un'unica schermata.

Altri articoli