Oude en nieuwe software laten samenwerken: wat zijn de opties?

Leonard Monderman ·
Antieke messing sleutelkast naast een modern kaartlezer op een betonnen lobbymuur, waar een facilitair manager een toegangspas aanhoudt

Oude en nieuwe software laten samenwerken kan op drie manieren: via directe API-koppelingen, via middleware die als tussenpersoon fungeert, of via een platformlaag die meerdere systemen tegelijk verbindt. Welke aanpak het beste werkt, hangt af van wat je legacy-systemen technisch ondersteunen en hoe centraal je de integratie wil beheren. De vragen hieronder helpen je bepalen welke keuze bij jouw situatie past.

Waarom communiceren oude en nieuwe software vaak niet met elkaar?

Oude software is gebouwd in een tijd dat systemen niet hoefden samen te werken. Ze gebruiken gesloten dataformaten, verouderde protocollen en hebben geen standaardinterfaces voor externe koppelingen. Nieuwe software werkt doorgaans met open standaarden zoals REST of OIDC, maar kan die taal niet spreken als het legacy-systeem geen vertaling aanbiedt.

Het probleem zit zelden in één systeem. Elk systeem op zich werkt prima. De pijn ontstaat in de ruimte ertussen. HR legt een vertrek vast, maar iemand moet handmatig de toegangspas blokkeren, het parkeerrecht intrekken en het sleutelregister bijwerken. Dat kost tijd, gaat mis en geeft niemand echt overzicht.

Drie technische oorzaken komen steeds terug:

  • Geen of beperkte API: Veel legacy-systemen bieden geen moderne interface waarmee andere software gegevens kan ophalen of versturen.
  • Incompatibele datamodellen: Systemen gebruiken andere veldnamen, coderingen of structuren voor dezelfde informatie, zoals een medewerkersnummer of een locatieaanduiding.
  • Geen gedeelde identiteitslaag: Systemen kennen gebruikers niet op dezelfde manier, waardoor een wijziging in het ene systeem niet automatisch doorwerkt in het andere.

Het resultaat is dubbele invoer, verouderde gegevens en processen die afhankelijk zijn van handmatige afstemming tussen afdelingen.

ONTDEK DE MOGELIJKHEDEN

Wat kan Rhyzi voor jouw organisatie doen?

Zie hoe je bestaande systemen verbindt en het beheer overzichtelijk houdt.

Laten we samen kijken  →

Wat zijn de meest gebruikte methoden om software te integreren?

De meest gebruikte methoden voor softwareintegratie zijn directe API-koppelingen, middleware of een integratieplatform, bestandsuitwisseling via exports en imports, en een centrale platformlaag die als verbindende identiteits- en rechtenlaag fungeert. Elke methode heeft een eigen toepassingsgebied en eigen beperkingen.

Directe API-koppeling

Twee systemen spreken rechtstreeks met elkaar via een gestandaardiseerde interface. Dit werkt goed als beide systemen moderne API’s ondersteunen en de koppeling relatief eenvoudig is. Nadeel: bij veel systemen wordt dit snel onoverzichtelijk, en elke koppeling moet afzonderlijk worden onderhouden.

Middleware en integratieplatforms

Een tussenpersoon vertaalt berichten tussen systemen, beheert de volgorde van acties en vangt fouten op. Dit is de aanpak voor complexere omgevingen met meerdere systemen die allemaal met elkaar moeten communiceren. De logica zit op één plek, wat onderhoud eenvoudiger maakt.

Bestandsuitwisseling

Systemen wisselen periodiek bestanden uit, zoals CSV-exports die ’s nachts worden ingelezen. Dit is de laagdrempeligste optie voor legacy-systemen zonder API, maar het is geen echte integratie: gegevens zijn altijd een stap verouderd en fouten worden pas achteraf ontdekt.

Centrale platformlaag

Een platformlaag fungeert als de verbindende kern tussen alle systemen. In plaats van punt-tot-puntkoppelingen beheert één platform alle identiteiten, rechten en gegevensstromen. Gegevens uit gekoppelde bronsystemen, zoals HR- en roostersystemen, worden via de platformlaag gebruikt voor de relevante gebouw- en facilitaire systemen. Dit is de aanpak die organisaties helpt van tientallen losse tools naar één beheersbare omgeving te gaan.

Wat is het verschil tussen een API-koppeling en middleware?

Een API-koppeling is een directe verbinding tussen twee specifieke systemen. Middleware is een tussenlaag die meerdere systemen met elkaar verbindt, berichten vertaalt en de communicatie coördineert. Het verschil zit in schaal en beheer: een API-koppeling werkt voor twee systemen, middleware voor een netwerk van systemen.

Stel je hebt vijf systemen die allemaal met elkaar moeten communiceren. Met directe API-koppelingen bouw je tien afzonderlijke verbindingen. Elke koppeling heeft eigen logica, eigen foutafhandeling en eigen onderhoud. Middleware vervangt dat door één centrale laag: elk systeem communiceert met de middleware, en de middleware regelt de rest.

Praktisch gezien kies je voor een directe API-koppeling als de integratie eenvoudig en stabiel is, en als beide systemen goed gedocumenteerde, moderne API’s hebben. Middleware is zinvoller als je meerdere systemen combineert, als de dataformaten vertaling vereisen, of als je de integratieverantwoordelijkheid op één plek wil beleggen.

Een platformlaag zoals een Building OS met gecertificeerde integraties combineert elementen van beide: het biedt koppelingen met veelgebruikte bronsystemen en fungeert tegelijkertijd als centrale beheerlaag voor identiteiten en rechten, zonder dat je zelf de middleware hoeft te bouwen of onderhouden. RHYZI host en beheert de software; ter plaatse blijven alleen lezers en controllers.

Wanneer is het beter om legacy-software te vervangen dan te integreren?

Vervanging is beter dan integratie als het legacy-systeem geen bruikbare interface biedt, als de integratie meer kost dan vervanging, of als het systeem een veiligheidsrisico vormt dat niet via een koppeling op te lossen is. In alle andere gevallen verdient integratie de voorkeur boven volledige vervanging.

Een aantal concrete signalen dat vervanging zinvoller is:

  • Het systeem heeft geen API en ondersteunt geen moderne protocollen, waardoor elke koppeling maatwerk vereist.
  • De leverancier biedt geen ondersteuning meer, wat beveiligingsrisico’s oplevert die niet via een tussenlaag zijn af te schermen.
  • De integratiebouw en het onderhoud kosten structureel meer dan een moderne vervanger zou kosten.
  • Het systeem blokkeert schaalbaarheid, bijvoorbeeld omdat het geen meerdere locaties of gebruikersgroepen aankan.

Maar vervanging is niet altijd nodig. Veel organisaties vervangen de beheersoftware terwijl ze de bestaande hardware gewoon laten zitten. Denk aan lezers, controllers of intercoms die technisch nog prima functioneren. De vraag is niet altijd “vervangen of integreren” maar ook: welk deel vervang je en wat kun je hergebruiken? Dat vereist een eerlijke beoordeling per component, niet een alles-of-nietsbeslissing.

Hoe voorkom je vendor lock-in bij het koppelen van systemen?

Vendor lock-in voorkom je door te kiezen voor open standaarden, hardware-onafhankelijke platforms en koppelingen die niet afhankelijk zijn van één leverancier. Zorg dat de integratiearchitectuur overdraagbaar is: als je morgen van systeem wisselt, moet de rest kunnen blijven staan.

In de praktijk betekent dit letten op een aantal concrete punten:

  • Open protocollen: Systemen die communiceren via open standaarden zoals REST en OIDC zijn uitwisselbaar. Gesloten, leverancierspecifieke protocollen binden je aan één partij.
  • Hardware-onafhankelijkheid: Kies een softwareplatform dat niet vastzit aan één hardwaremerk. Zo kun je bestaande lezers, controllers of parkeersystemen behouden als je van beheersoftware wisselt.
  • Dataportabiliteit: Controleer of je je eigen data kunt exporteren in een bruikbaar formaat. Data die alleen toegankelijk is via de interface van één leverancier, is feitelijk gegijzeld.
  • Contractuele vrijheid: Lees wat er in het contract staat over opzegtermijnen, data-eigendom en portabiliteit van configuraties.

Een platform dat gebouwd is op open standaarden en werkt met bestaande lezers en controllers geeft je de vrijheid om per component de beste keuze te maken, zonder dat je bij elke wissel alles opnieuw hoeft te bouwen. Bekijk hoe dat er in de praktijk uitziet via het RHYZI ecosystem.

Wat moet je controleren voordat je systemen gaat koppelen?

Voordat je systemen koppelt, moet je minimaal vier dingen in kaart brengen: welke interfaces elk systeem aanbiedt, welke data er uitgewisseld moet worden en in welke richting, wie verantwoordelijk is voor de integratie en het onderhoud, en of de koppeling voldoet aan geldende privacyregels zoals de AVG.

Een praktische checklist om mee te beginnen:

  1. Inventariseer de bestaande systemen: Welke versies draaien er, welke interfaces zijn beschikbaar, en zijn er nog actieve leverancierscontracten met ondersteuning?
  2. Bepaal de datastromen: Welke gegevens moeten van systeem A naar systeem B, hoe vaak, en wat is de gezaghebbende bron als er conflicten zijn?
  3. Beoordeel de technische haalbaarheid per component: Niet elk onderdeel van een legacy-installatie is integreerbaar. Sommige elementen vereisen een tussenstap, andere zijn technisch niet te koppelen zonder maatwerk.
  4. Leg verantwoordelijkheden vast: Wie beheert de koppeling als er iets misgaat? Wie is verantwoordelijk voor updates als een van de systemen wijzigt?
  5. Controleer privacy en compliance: Welke persoonsgegevens worden uitgewisseld, op welke grondslag, en hoe lang worden ze bewaard in elk systeem?

Deze voorbereiding voorkomt dat je halverwege een integratietraject ontdekt dat een systeem geen bruikbare interface heeft, of dat gegevens worden gedeeld op een manier die niet AVG-proof is. Wil je weten of jouw huidige systemen aansluiten op een centrale beheerslaag? Plan een demo en laat de mogelijkheden beoordelen op basis van jouw specifieke installatie.

Gerelateerde artikelen