Als dezelfde klant, bestelling of instelling in meerdere systemen wordt aangepast, moet een synchronisatieproces bepalen welke wijziging leidend is. Lees hoe eigenaarschap per veld, expliciete conflictregels en versiebeheer voorkomen dat gegevens ongemerkt worden overschreven.
Eén bron van waarheid is niet altijd één systeem
Je hoort vaak over de ‘bron van waarheid’. Het klinkt alsof er altijd één applicatie de leiding heeft en alle andere systemen alleen informatie ophalen. Maar dat is zelden zo strak geregeld. Meestal zijn er meerdere systemen verantwoordelijk voor hun eigen stuk. Een CRM beheert contactgegevens, een boekhoudpakket schrijft betaalstatussen, en een planningssysteem is leidend voor afspraken. Zodra meer dan één applicatie bepaalde gegevens mag wijzigen, is de bron eigenlijk een set afspraken, niet één database.
Dus leg expliciet vast welk systeem mag wijzigen en welke alleen mogen lezen. Maak een duidelijk verschil tussen ergens een kopie bewaren en ook echt mogen schrijven. Je wil namelijk niet dat systemen elkaars wijzigingen blijven terugsturen. Laat daarom niet aan het toeval over wie welk veld mag aanpassen. Zonder zo’n afspraak krijg je anders al snel cirkelverwijzingen en raken gegevens verstrikt.
Een werkbare opzet geeft bij elk gegevenstype of veld aan welk systeem eigenaar is, bepaalde schrijfrechten, en regels voor uitzonderingen. Je hebt soms een integratielaag nodig die streng bepaalt wie mag publiceren. Ligt er niks vast, dan pakt het systeem meestal de laatste wijziging, zelfs als die verandering uit een verloren gelopen kopie komt. Voor maatwerk zijn API-koppelingen een mogelijke oplossing.
Eigenaarschap per veld voorkomt strijd tussen systemen
Eigenaarschap opleggen op recordniveau werkt vaak niet. In klantrecords staan naam, factuuradres, marketingvoorkeuren of kredietlimieten door elkaar, terwijl niet één systeem daarin alles mag aanpassen. Je kunt dus beter per veld (of logische groep) bepalen wie de baas is. Het CRM heeft dan gezag over naam en communicatie, het financiële pakket over adres en limieten.
De indeling moet kloppen met hoe mensen werken, niet alleen technisch. Als je collega’s in een portaal adreswijzigingen mogen doen, maar alleen het CRM mag adressen wegschrijven, moet je kiezen: wijziging afkeuren, als voorstel opslaan of even afwachten totdat iemand het goedkeurt. Als een scherm een wijziging wel accepteert maar de koppeling draait het terug, ja, dan snapt straks niemand wat er gebeurt.
Leg per veld vast wie schrijft, wie leest en wat er gebeurt als een niet-eigenaar het probeert. Vergeet geen uitzonderingen zoals bij datamigraties of admin-acties. Uitzonderingen moeten een aparte bevoegdheid krijgen, plus logging. Anders groeit een tijdelijke oplossing uit tot een sluiproute en weet niemand meer wie een waarde mag bijwerken.
Kies conflictregels die passen bij het soort gegevens
Conflicten ontstaan als twee wijzigingen hetzelfde veld raken of als systemen ze in een andere volgorde verwerken dan ze zijn aangemaakt. ‘Laatste wijziging wint’ lijkt makkelijk, maar je hebt er alleen wat aan als systemen het échte tijdsverloop kennen én als die volgorde ook inhoudelijk klopt. Bij sommige velden werkt een prioriteit beter: een wijziging uit het bronsysteem is belangrijker dan een wijziging van een kopie-app.
Er zijn ook velden die samenvoeging nodig hebben. Je kunt niet zelf een telefoonnummer combineren uit twee verschillende waarden. Maar notities kun je soms wel als twee aparte toevoegingen bewaren. Soms is een wachtrij met expliciete beoordeling slimmer, vooral bij gevoelige informatie. Dat vertraagt wel, maar voorkomt dat een terechte wijziging stil verdwijnt.
Kies je regel per veldtype, niet global. Voorraad wordt vaker uit mutaties opgebouwd dan willekeurig overschreven. Een status kan niet terug naar ‘in behandeling’ zodra die ‘afgehandeld’ is. Denk dus na over detectie, logging en wat er precies gebeurt als er een conflict opduikt. Bij webshops vraagt webshopvoorraad koppelen om zulke expliciete regels. Een praktijkvoorbeeld zijn marketplace-koppelingen via WooCommerce en Channable.
Waarom tijdstempels alleen conflicten niet oplossen
Tijdstempels lijken een makkelijke manier om de laatste wijziging eruit te pikken, maar dat beeld klopt niet. Klokken lopen uit, tijdzones worden soms verkeerd gelezen en offline apparaten kunnen met flinke vertraging hun update sturen. Het moment van ontvangst is vaak wat anders dan het echte bewerkingstijdstip.
Als je alleen vertrouwt op tijdstempels, loop je het risico een nieuwe wijziging kwijt te raken. Iemand werkt een adres offline bij, stuurt het uren later in, maar intussen verwerkt een tweede systeem een andere wijziging met een jongere eigen tijdstempel. Laatste tijd wint? Dan gaat de goede correctie onderuit, enkel omdat ‘ie later binnenkomt.
Beter is een servergegenereerde volgordemarker of een oplopend versienummer. Leg naast tijdstip ook bron en binnenkomtijd vast, zodat het verschil duidelijk blijft tussen aanmaak en verwerking. In gedistribueerde omgevingen werken dingen als vector clocks om echt onafhankelijk gemaakte wijzigingen te herkennen. Ja, dat vergroot de complexiteit, maar één tijdstempel per record doet alsof iedereen altijd dezelfde klok heeft (en dat is bijna nooit zo).
Optimistic locking beschermt tegen stil overschrijven
Een vaak gemaakte fout: een medewerker past iets aan, het systeem leest het hele record, iemand anders verandert op hetzelfde moment iets anders en bij het terugschrijven overschrijft de eerste actie alle andere velden. Het gebeurt zelfs als er maar één veld is gewijzigd, want de rest van het record zit nog in de oudere payload.
Met optimistic locking sla je bij het ophalen het versienummer op. Je mag alleen bijwerken als de huidige versie identiek is aan die waarmee je begon. Is er ondertussen iets veranderd, krijg je een conflict. Bijvoorbeeld met een ETag in een HTTP-API werkt dat, via If-Match. Is er iets aangepast, meldt het systeem de fout en kun je opnieuw beoordelen of samenvoegen.
Soms helpt het om updates alleen per veld te sturen. Maar ook dan kunnen twee gebruikers tegelijk hetzelfde veld aanpassen. Combineer dus deelupdates met versiecontrole waar dat nodig is. Hoe je client daarop reageert is belangrijk: direct nieuwe poging met dezelfde data betekent vaak gewoon opnieuw alles overschrijven. Dus pas op: conflictmelding heeft alleen zin als ‘ie tot echte handmatige actie leidt.
Samenvoegen vraagt om regels op veld- en domeinniveau
Krijg je twee wijzigingen die eigenlijk naast elkaar mogen bestaan, dan kun je met merge verlies voorkomen. Maar dat werkt alleen als de software weet wat het veld betekent. Twee aanpassingen aan verschillende velden samenvoegen is makkelijk, als de update alleen die velden bevat. Lijsten, notities of samengestelde objecten zijn lastiger: een nieuwe lijst slaat aanvulling van een ander soms weg, maar blind samenvoegen levert weer dubbele regels op.
Modelleer aparte delen indien mogelijk als eigen objecten met een vaste sleutel. Dan kan bijvoorbeeld een lijst contacten per persoon worden gewijzigd in plaats van de hele lijst te vervangen. Bij tekst kun je soms automatisch samensmelten, maar niet bij subtiele of overlappende aanpassingen. Geeft het veld juridische betekenis? Toon dan beide versies expliciet. Klakkeloos samenvoegen werkt daar averechts.
Domeinregels vertellen je of samenvoegen aanleiding is. Aantallen in een winkelmandje kun je soms optellen, reserveringen meestal niet. Statussen mogen vaak niet ‘achteruit’. Test merges met gelijktijdige updates, dubbele berichten en deels verwerkte wijzigingen. Kijk niet alleen of info blijft bestaan, maar vooral of de eindtoestand klopt binnen je bedrijfsregels. Voor zulke regels kan PHP-maatwerk nodig zijn.
Verwijderingen en archivering moeten expliciete regels krijgen
Een verwijdering brengt z’n eigen problemen mee: een verdwenen record valt zonder extra aanwijzing niet te onderscheiden van een nog niet gesynchroniseerd item. Verwijdert één systeem fysiek, dan kan een ander systeem die oude kopie zomaar weer aanmaken. Of een vertraagde update blaast een record weer leven in dat iemand als verwijderd beschouwde.
Tombstones bieden uitkomst. In plaats van direct wissen, noteer je dat een item verwijderd is, mét id, versie en tijdstip. Die marker verspreidt je, zodat alle systemen weten: dit is niet vergeten maar weg. Belangrijk: tombstones moeten bewaard blijven tot alle clients (ook offline) zijn bijgepraat. Ruim je ze te vroeg op, keert een oude kopie onbedoeld terug.
Maak daarnaast onderscheid tussen verwijderen, archiveren en toegang intrekken. Archiveren betekent vaak: niet actief zichtbaar, wel nog bewaard. Privacyverzoeken vereisen soms definitief wissen, inclusief het schonen van kopieën en afgeleiden. Leg vast wie mag verwijderen, hoe je omgaat met conflicten rond verwijdering en hoe herstel werkt. Terugzetten hoort een eigen actie te zijn, geen bijeffect van een vergeten of vertraagde synchronisatie.
Maak conflicten zichtbaar met logging en gerichte tests
Een synchronisatie kan technisch geslaagd zijn terwijl de data inhoudelijk fout zit. Log om die reden niet alleen succes, maar registreer ook bron, vorige versie, gewijzigde velden en welke conflictregel is gebruikt. Bewaar ook de afgewezen waarde en reden, maar let op privacy en bewaartermijn. Meer over logging en foutafhandeling lees je in een apart artikel.
Maak conflicten zichtbaar als aparte uitkomst, niet verstopt tussen gewone fouten of successen. Herken patronen: veel conflicten bij één veld, een nieuwe koppeling die iets blijft terugsturen, of clients die onbedoeld volledige records pushen. Beheerportalen kunnen openstaande conflicten tonen met bron, beide waardes, tijdstip en context. Zet niet zomaar overal een 'neem deze maar'-knop neer; dat geeft gebruikers schijnkeuze zonder context.
Test realistische scenario’s: dubbele of vertraagde berichten, apps die offline zijn, gelijktijdige acties. Vergeet herstel van storingen niet. Controleren of één waarde doorkomt zegt weinig over je conflictprocedures. Werk met echte testdata en check na verwerking hoe elk systeem erbij staat, inclusief logging en de eventuele handmatige wachtrij.
Veelgestelde vragen
Hoe voorkom je dubbele verwerking van synchronisatieberichten?
Je voorkomt dubbele verwerking door elke boodschap een unieke sleutel te geven en bij te houden of je die al gezien hebt. Netwerken en berichtenbussen sturen soms nogmaals (bijvoorbeeld als de eerste poging onzeker is door time-out). Voor je iets verwerkt kijk je of de sleutel al bekend is; is dat zo, dan sla je ‘m over.
- Koppel de sleutel aan gebeurtenis én bron, niet alleen aan het record zelf.
- Bewaar verwerkingsstatussen lang genoeg zodat vertraagde kopieën alsnog worden herkend.
- Test gevallen waarin een update halverwege strandt en daarna opnieuw binnenkomt.
Hoe migreer je gegevens naar een nieuw systeem zonder synchronisatieconflicten?
Migratieconflicten vermijd je door het omslagmoment goed af te spreken en tijdens de overgang duidelijk vast te leggen wie mag schrijven. Anders concurreert je import met live wijzigingen of worden oude waarden als nieuwe verspreid. Pas over op het nieuwe systeem nadat je alle verschillen tussen de oude situatie en nieuwe mutaties inzichtelijk hebt.
- Test met representatieve kopieën en controleer niet alleen aantallen, maar ook velden die belangrijk zijn.
- Leg vast of mutaties tijdens overgang worden gepauzeerd, samengesteld, of meteen verwerkt.
- Zorg dat je weet wat is aangepast na de omschakeling (terugvalplan).
Welke KPI's gebruik je om problemen met gegevenssynchronisatie te bewaken?
Kijk niet alleen of berichten aankomen, maar ook hoe actueel de data is en hoeveel ingrepen handmatig moeten. Je kunt hoge succespercentages halen terwijl berichten blijven hangen of veel conflicten onopgelost blijven. Meet per bron, bestemming en type gegeven om de werkelijke prestaties te volgen.
- Volg hoe lang het oudste onverwerkte bericht wacht en de verwerkingstijden.
- Meet hoeveel conflicten, afwijzingen en handmatige correcties optreden.
- Controleer hoeveel records na synchronisatie nog afwijken tussen systemen.
- Zet alarmsignalen op afwijkingen vergeleken met wat gebruikelijk is.
Hoe lang moet je synchronisatielogs en conflictgegevens bewaren?
Bewaartijd van synchronisatielogs hangt af van de eisen die gelden: voor onderzoek van incidenten, compliance of intern beleid. De termijn is afhankelijk van risico’s, herstelmogelijkheden en gevoeligheid van de gegevens. Er bestaat geen standaardtermijn. Leg per soort logboek vast hoe lang informatie blijft, wie het mag inzien en wanneer er wordt verwijderd of geanonimiseerd.
- Waar mogelijk alleen ids en metadata opslaan, geen volledige persoonsgegevens.
- Toegang beperken en elke inzage van gevoelige logs bijhouden.
- Zorg dat back-ups en exports dezelfde bewaartermijnen aanhouden.
Wat doe je als de wachtrij met onopgeloste synchronisatieconflicten blijft groeien?
Kijk eerst waarom er meer conflicten bijkomen dan je afhandelt, in plaats van alleen harder handmatig te gaan verwerken. Een groeiende backlog wijst vaak op een recente systeemwijziging, fout in een koppeling of te weinig menskracht voor beoordeling. Splits de wachtrij op in bron, soort veld, oud of nieuw, en wat de gevolgen zijn. Dan zie je sneller wat dringend is en waar je steeds dezelfde fout tegenkomt.
- Zet het belangrijkste probleem voorop: wat blokkeert kritieke processen of klantgegevens?
- Herken en los structurele fouten op die telkens nieuwe conflicten veroorzaken.
- Geef herhaalde groepen conflicten een duidelijke eigenaar en afhandeltermijn.
- Kijk na de oplossing of de wachtrij echt slinkt en geen sync-gegevens zijn verdwenen.
Foto: Саша Алалыкин