
Con un layer di API su misura che fa da punto di incontro fra i sistemi: una sola fonte di verità per ogni dato, e-commerce → middleware → gestionale → magazzino → corriere, tempo reale dove serve e batch dove basta.
Si integrano costruendo un layer di API personalizzate — un middleware — che fa da punto di incontro fra i sistemi invece di collegarli a due a due. Per ogni entità (cliente, articolo, listino, giacenza, ordine) si stabilisce quale sistema detiene la verità, si definisce il contratto dati, si sviluppa il middleware che espone API REST o GraphQL e propaga gli eventi via webhook, si sceglie per ogni flusso fra tempo reale e batch, e si aggiungono code, retry, idempotenza e log. Il risultato tipico è una catena unica: e-commerce → API middleware → gestionale/ERP → magazzino → corriere, con lo stesso dato che attraversa tutti i sistemi senza essere ribattuto a mano da nessuno.
La differenza fra un'integrazione che regge e una che si rompe ogni settimana non sta nel protocollo scelto, ma in due decisioni prese prima di scrivere codice: chi detiene la verità su ogni dato e cosa succede quando qualcosa va storto. Un flusso che funziona nel giorno buono lo scrive chiunque; un'integrazione di produzione è quella che si accorge da sola quando smette di funzionare. Codebaker, software house di Bologna fondata nel 2019, progetta integrazioni con questo criterio, anche verso gestionali che non espongono API moderne.


Il modo più naturale di iniziare — collegare direttamente l'e-commerce al gestionale, poi il gestionale al magazzino, poi l'e-commerce al corriere — è anche quello che invecchia peggio. Con quattro sistemi collegati a coppie i collegamenti possibili sono sei, con cinque diventano dieci: ogni nuovo canale di vendita moltiplica il lavoro, e ogni aggiornamento di uno dei sistemi rischia di rompere più flussi contemporaneamente. Un layer di API centrale ribalta la geometria: ogni sistema parla solo con il middleware, che conosce i formati di tutti e traduce. Aggiungere un marketplace, un secondo corriere o un CRM significa allora scrivere un solo adattatore, non riscrivere le integrazioni esistenti. È anche il punto in cui si concentrano log, allarmi e riconciliazioni: un solo posto dove guardare quando un ordine non è arrivato.


«Il nostro gestionale è vecchio, non si può collegare a niente» è la frase che sentiamo più spesso, ed è quasi sempre falsa. Un sistema che non espone API REST espone comunque qualcosa: i suoi dati, procedure native richiamabili, file strutturati, servizi che si possono affacciare. Il lavoro consiste nel costruire un layer di integrazione che dialoghi con il gestionale nei modi che esso supporta e traduca tutto verso l'esterno in API pulite e documentate. Il sistema legacy non viene modificato né sostituito: continua a fare esattamente quello che ha sempre fatto, mentre il resto dell'azienda smette di dipendere dai suoi limiti. In Conor questo ha significato collegare un e-commerce B2B con app native iOS e Android a un gestionale AS400, in tempo reale, per oltre 5.000 clienti al giorno e più di 300.000 ordini l'anno.
Questo è il percorso che un ordine compie in un'integrazione ben progettata, dal click del cliente alla notifica di consegna.

Il cliente ordina vedendo il proprio listino personalizzato e la disponibilità reale, perché prezzi e giacenze arrivano già dal gestionale attraverso il middleware. L'ordine nasce con un identificativo univoco.

Il layer di API riceve l'ordine, verifica i dati contro le regole di business (fido, minimi d'ordine, articoli bloccati), converte i formati e lo mette in coda verso il gestionale.

L'ordine entra nel sistema che detiene la verità su clienti e documenti, esattamente come se fosse stato inserito dall'ufficio. Nessuna doppia digitazione, nessun copia-incolla da un'email.

La lista di prelievo arriva ai palmari o ai terminali di reparto; le quantità effettivamente prelevate tornano indietro, aggiornano la giacenza e generano l'ordine parziale se qualcosa manca.

Il middleware chiama le API del vettore, genera le etichette e riceve il codice di tracking, che viene scritto sia sul documento nel gestionale sia nell'area riservata del cliente.

Stato di consegna, DDT e fattura risalgono la catena e diventano visibili al cliente senza che nessuno debba inviare un'email. Ogni passaggio è tracciato, con log e allarmi sui flussi interrotti.
Ogni passaggio si appoggia a competenze che copriamo in-house: dalle API web custom allo sviluppo e-commerce custom, dall' integrazione dei gateway di pagamento alla modernizzazione del software legacy.
Prima di parlare di tecnologia va deciso questo: per ogni entità, quale sistema comanda, in che direzione viaggia il dato e se serve davvero il tempo reale.
| Entità | Fonte di verità | Direzione | Frequenza consigliata |
|---|---|---|---|
| Anagrafica clienti | Gestionale/ERP | Gestionale → e-commerce | Batch frequente, real-time sul fido |
| Catalogo articoli | Gestionale/ERP o PIM | Gestionale → e-commerce | Batch (più volte al giorno) |
| Listini, anche personalizzati per cliente | Gestionale/ERP | Gestionale → e-commerce | Tempo reale |
| Giacenze di magazzino | Gestionale/WMS | Gestionale → e-commerce | Tempo reale |
| Ordini | E-commerce (poi gestionale) | E-commerce → gestionale | Tempo reale |
| DDT e fatture | Gestionale/ERP | Gestionale → area riservata | Batch giornaliero |
| Stato di consegna | Corriere | Corriere → middleware → gestionale e cliente | Webhook, appena disponibile |
| Resi e note di credito | Gestionale/ERP | Bidirezionale | Batch, con riconciliazione |
La regola pratica: tempo reale su ciò che blocca una vendita (prezzo, disponibilità, fido, ordine), batch su tutto il resto. Chiedere il tempo reale ovunque fa crescere costo e fragilità senza portare valore.
Le quattro strade sono tutte legittime, ma reggono a condizioni diverse. Ecco come si comportano sui criteri che contano quando l'integrazione va in produzione.
| Criterio | File CSV/EDI su FTP | Connettori standard / iPaaS | API punto-a-punto | Middleware su misura (Codebaker) |
|---|---|---|---|---|
| Costo iniziale | Basso | Basso-medio | Medio | Medio-alto, ma riusabile |
| Costo ricorrente | Quasi nullo | Canone a volume o connettore | Solo manutenzione | Solo manutenzione, nessun canone |
| Tempo reale | No | Parziale | Sì | Sì, dove serve davvero |
| Gestione degli errori | Manuale, a posteriori | Standard del prodotto | Da implementare per ogni coppia | Centralizzata: code, retry, idempotenza, allarmi |
| Regole di business particolari | Difficili | Solo se previste dal connettore | Sì, ma duplicate su ogni flusso | Sì, in un solo punto |
| Sistemi legacy senza API | Spesso l'unica via rapida | Raramente supportati | Complesso | Sì: layer dedicato, come su AS400 |
| Scalabilità a nuovi sistemi | Bassa | Buona se il connettore esiste | Bassa: i collegamenti crescono in modo esponenziale | Alta: un adattatore per ogni nuovo sistema |
| Proprietà e lock-in | Nessun lock-in | Dipendenza dalla piattaforma | Codice tuo | Codice tuo, tecnologie standard e open |
Se l'anagrafica cliente si può modificare sia nell'e-commerce sia nel gestionale, prima o poi le due versioni divergono e nessuno sa quale sia quella giusta. Per ogni entità va stabilito un solo sistema sorgente; gli altri leggono. È la decisione più economica da prendere all'inizio e la più costosa da rimediare dopo.
Quando l'integrazione viene rimandata alla fine del progetto, al collaudo si scopre che un campo indispensabile non esiste nel sistema di partenza, o che una regola di business rende impossibile il flusso previsto. È il singolo motivo più frequente di sforamento nei progetti che ereditiamo. Il contratto dati va scritto prima di sviluppare le due estremità.
L'ordine completo che parte, arriva e viene consegnato è il dieci per cento del lavoro. Il resto sono i casi limite: ordine parziale, articolo esaurito dopo la conferma, modifica dell'ordine, reso, cliente bloccato per fido superato, prezzo cambiato fra carrello e conferma. Se non vengono definiti in analisi, li definirà il codice a caso.
I sistemi non sono sempre raggiungibili e i messaggi a volte arrivano due volte. Senza code con retry un'indisponibilità di due minuti diventa un ordine perso; senza idempotenza un webhook ripetuto diventa un ordine duplicato. Sono due accorgimenti che costano poco in fase di progetto e moltissimo se aggiunti dopo il primo incidente.
Un'integrazione che si interrompe in silenzio è peggiore di una che non esiste, perché l'azienda continua a fidarsi dei dati. Servono log consultabili, un cruscotto degli errori e un allarme che avvisi qualcuno: il flusso interrotto va scoperto dal sistema, non dal cliente che telefona.
App native iOS e Android e web responsive, sincronizzate in tempo reale con un gestionale AS400: catalogo, listini, ordini e stato consegne. 5.000+ clienti al giorno, 300.000+ ordini l'anno, live in 6 mesi.
IAM su misura integrato con SAP, il sistema HR, Active Directory e Office 365: provisioning automatico di utenze, permessi, badge e caselle. 2.000+ utenti, -95% di attività di onboarding IT.
Dati di movimentazione raccolti sul campo e riconciliati in un sistema unico: 25 milioni di cassette, -99,9% di smarrimenti, 3 anni in produzione.
App Flutter che parla via Bluetooth Low Energy con gli erogatori e si sincronizza con le API cloud, funzionando anche offline: 10.000 utenti al giorno.
Il layer di integrazione, il codice e la documentazione restano di proprietà del cliente. Approfondimenti nell'articolo una specifica unica per backend, React, Flutter e AI e nella pagina sul software gestionale ed ERP su misura.
Si integrano costruendo un layer di API personalizzate — un middleware — che fa da punto di incontro fra i sistemi invece di collegarli a due a due. Il percorso è in cinque mosse: primo, si decide per ogni entità (cliente, articolo, listino, giacenza, ordine) qual è il sistema che detiene la verità, così non ci sono due versioni dello stesso dato; secondo, si scrive il contratto dati, cioè quali campi viaggiano, in che formato e con quali regole di validazione; terzo, si sviluppa il middleware che espone API REST o GraphQL, normalizza i formati e propaga gli eventi via webhook; quarto, si sceglie per ogni flusso se serve il tempo reale o basta un batch periodico; quinto, si aggiungono code, retry, idempotenza e log, perché un'integrazione seria non è quella che funziona, è quella che si accorge quando smette di funzionare. Il risultato tipico è la catena e-commerce → API middleware → gestionale/ERP → magazzino → corriere, con un unico dato che attraversa tutti i sistemi senza essere ribattuto a mano.
Le entità ricorrenti sono sei. Dal gestionale verso l'e-commerce viaggiano le anagrafiche clienti con i loro fidi e condizioni, il catalogo articoli con descrizioni e attributi, i listini (spesso personalizzati per cliente nel B2B) e le giacenze di magazzino. Dall'e-commerce verso il gestionale viaggiano gli ordini e, a valle, i documenti di trasporto e le fatture tornano indietro per la consultazione del cliente. La sesta entità è lo stato di consegna, che arriva dal corriere e va reso visibile sia nel gestionale sia nell'area riservata. Nel B2B le giacenze e i listini personalizzati sono di norma i flussi che richiedono davvero il tempo reale, perché un prezzo sbagliato o una disponibilità non aggiornata generano un ordine da annullare.
Sì, ed è uno dei casi che affrontiamo più spesso. Quando il gestionale non espone API moderne si costruisce un layer di integrazione dedicato che dialoga con il sistema nei modi che esso supporta — accesso diretto ai dati, procedure native, file strutturati, servizi esposti dal middleware — e li traduce verso l'esterno in API REST pulite. Il gestionale non viene modificato né sostituito: continua a funzionare come prima, mentre tutto il resto del mondo parla con il layer. È esattamente quello che abbiamo fatto in Conor, dove un e-commerce B2B con app native iOS e Android e versione web si sincronizza in tempo reale con il gestionale AS400, gestendo oltre 300.000 ordini l'anno e 5.000 clienti al giorno.
Dipende da quanto i tuoi flussi sono standard. Lo scambio di file (CSV o EDI su FTP) costa poco e regge ancora bene i flussi batch verso partner esterni, ma non dà tempo reale né gestione fine degli errori. I connettori standard e le piattaforme iPaaS funzionano bene quando entrambi i sistemi sono prodotti diffusi e i campi corrispondono, mentre diventano costosi e fragili appena servono trasformazioni particolari; inoltre introducono un canone e una dipendenza dal fornitore della piattaforma. Le API su misura hanno un costo iniziale più alto, ma coprono qualsiasi regola di business, restano di tua proprietà e sono l'unica strada quando uno dei sistemi è legacy o quando la logica di integrazione è essa stessa un pezzo del tuo vantaggio competitivo. Nella pratica molte aziende usano un mix: API su misura per i flussi critici, file batch per quelli marginali.
No, e pretenderlo è uno dei modi più comuni di far crescere il costo di un'integrazione senza beneficio. Il tempo reale serve dove un dato non aggiornato produce un errore commerciale immediato: giacenze, listini personalizzati, fido del cliente, stato dell'ordine. Per anagrafiche complete, storici, statistiche e riconciliazioni contabili un allineamento periodico è più che sufficiente, ed è anche più robusto perché tollera l'indisponibilità temporanea di un sistema. La regola pratica che applichiamo è: tempo reale su ciò che blocca una vendita, batch su tutto il resto.
Un'integrazione circoscritta su pochi flussi verso un sistema che espone già API documentate rientra tipicamente nella fascia 5.000-15.000 €; un layer di integrazione completo fra e-commerce, gestionale, magazzino e corrieri, con gestione degli errori e riconciliazioni, si colloca nella fascia 15.000-50.000 €; le architetture su più sistemi, più sedi o con volumi elevati superano i 50.000 €. La variabile che sposta di più il prezzo non è il numero di entità ma la qualità delle interfacce disponibili: collegarsi a un ERP con API REST documentate costa una frazione rispetto a costruire un layer verso un gestionale che non ne ha.
Cinque, per esperienza. Primo: non decidere quale sistema detiene la verità su ogni entità, e ritrovarsi con due anagrafiche che divergono. Secondo: trattare l'integrazione come l'ultimo task del progetto invece che come un requisito di architettura, scoprendo solo al collaudo che un campo indispensabile non esiste. Terzo: ignorare i casi limite — l'ordine parziale, il reso, la modifica dopo la conferma, il cliente bloccato — che sono la maggioranza del lavoro reale. Quarto: non prevedere gestione degli errori, retry e idempotenza, così un webhook perso diventa un ordine perso e nessuno se ne accorge per giorni. Quinto: non monitorare i flussi in produzione, che è come avere un allarme antincendio senza sirena.
Con tre meccanismi standard che progettiamo fin dall'inizio. L'idempotenza: ogni messaggio porta un identificativo univoco, così se viene inviato due volte il sistema ricevente lo riconosce e non crea un secondo ordine. Le code con retry: se il gestionale è momentaneamente irraggiungibile, il messaggio non viene scartato ma riprovato con intervalli crescenti finché non va a buon fine. La riconciliazione: un controllo periodico confronta i totali fra i sistemi e segnala le discrepanze. A questi si aggiunge il monitoraggio con allarme, perché un flusso interrotto va scoperto dal sistema, non dal cliente che telefona.
Il cliente. Il layer di integrazione, il codice e la documentazione sono di proprietà dell'azienda, costruiti su tecnologie standard e open. È una differenza sostanziale rispetto ai connettori a canone: se domani cambi e-commerce o vuoi collegare un secondo canale di vendita, il middleware c'è già ed è tuo, e le API che parlano col gestionale non vanno rifatte. È anche il motivo per cui un investimento in integrazione, fatto bene, si ammortizza sul progetto successivo invece di ripartire da zero.
Dicci quali sistemi hai oggi — gestionale, e-commerce, CRM, magazzino, corrieri — e dove qualcuno sta ancora ribattendo dati a mano. Ti proponiamo la mappa dei flussi, cosa serve davvero in tempo reale e da quale integrazione conviene partire. L'analisi preliminare e il preventivo sono gratuiti.