Soevereiniteit zonder autonomie lost niets op

Digitale soevereiniteit staat hoog op de agenda. Terecht. Maar als je denkt dat een Europese cloud of een Nederlandse leverancier automatisch meer vrijheid oplevert, kijk je naar het verkeerde probleem. Want je kunt volledig soeverein zijn en toch muurvast zitten.

Het streven naar soevereiniteit is een gezonde ontwikkeling. Alleen dreigt daardoor ook verwarring te ontstaan. Want wat heb je aan een Nederlandse leverancier als je er nooit meer weg kunt? Wat heb je aan een Europese cloud als een overstap zo veel tijd en geld kost en zo veel risico met zich meebrengt dat niemand er serieus aan begint? Daar zit het verschil tussen soevereiniteit en autonomie.

De markt verwart twee verschillende problemen

Soevereiniteit gaat over controle. Over wie invloed kan uitoefenen op technologie, data en infrastructuur. Autonomie gaat over keuzevrijheid. Kun je nog veranderen als je weg wilt bij je leverancier? Dat lijkt een subtiel verschil, maar in de praktijk leidt het tot totaal andere keuzes.

Een organisatie kan volledig voldoen aan alle eisen rond digitale soevereiniteit en tegelijkertijd nauwelijks nog bewegingsvrijheid hebben. Dat zie je bijvoorbeeld wanneer software, hosting, beheer, support en doorontwikkeling in één pakket worden afgenomen. Zolang alles goed werkt, lijkt dat efficiënt. Problemen ontstaan pas zodra een organisatie iets wil veranderen.

Dan blijkt dat data lastig te exporteren is. Bovendien moeten koppelingen opnieuw worden gebouwd. Tot overmaat van ramp zit alle cruciale kennis bij één leverancier en heeft een migratie zoveel impact dat de bestaande situatie noodgedwongen in stand blijft. Op papier is er keuzevrijheid. In de praktijk wordt veranderen steeds moeilijker.

Juist daarom is autonomie uiteindelijk veel belangrijker dan soevereiniteit. Autonomie bepaalt tenslotte hoeveel vrijheid een organisatie daadwerkelijk overhoudt.

Digitale autonomie vraagt om ontkoppeling op drie niveaus

Autonomie is een gevolg van architectuurkeuzes. Het begint bij het loskoppelen van drie zaken die nog te vaak met elkaar verweven raken: infrastructuur, applicaties en dienstverlening.

Een applicatie die alleen in één specifieke cloudomgeving kan draaien, beperkt de bewegingsvrijheid. Hetzelfde geldt voor software die je niet kunt vervangen zonder een volledig migratietraject. En ook dienstverlening kan een bron van afhankelijkheid worden wanneer beheer, kennis en doorontwikkeling volledig bij één partij terechtkomen. In al die situaties ontstaat een enorm probleem: een wijziging op één plek heeft direct gevolgen voor de rest van het landschap.

Echte autonomie vraagt daarom om een architectuur waarin die onderdelen onafhankelijk van elkaar kunnen bewegen. Als organisatie moet je kunnen wisselen van infrastructuur zonder je applicaties opnieuw te bouwen. Een applicatie vervangen, moet kunnen zonder dat je tientallen andere systemen hoeft aan te passen. En wil je van dienstverlener wisselen, dan wil je niet meteen de controle over je technologie kwijtraken. Pas als je dat allemaal voor elkaar hebt, ontstaat echte keuzevrijheid.

Gemak is de grootste vijand van autonomie

Geen enkele organisatie kiest bewust voor lock-in. Afhankelijkheid ontstaat omdat gemak bijna altijd wint. Dat begint onschuldig. Een leverancier levert software en biedt daarnaast ook hosting aan. Wel zo handig, dus die wordt meegenomen. Vervolgens komen beheer, monitoring, authenticatie en support erbij. En, waarom niet, ook integraties en doorontwikkeling.

Iedere afzonderlijke keuze is te verdedigen. Maar samen zorgen de keuzes dat steeds meer onderdelen van het landschap aan elkaar vastgroeien. Dat zie je bij cloudplatformen, maar net zo goed bij ERP-systemen, CRM-oplossingen en sectorspecifieke software. Leveranciers hebben er belang bij om een zo groot mogelijk deel van het landschap te leveren. Wel zo goed voor hun businessmodel.

Hoe meer onderdelen aan elkaar gekoppeld raken, hoe kleiner de kans dat een klant vertrekt. Juist daarom moet autonomie een expliciet ontwerpprincipe zijn.

Zonder ontkoppeling bestaat autonomie niet

Wie autonomie als ontwerpprincipe serieus neemt, komt al snel uit bij integratie. Veel afhankelijkheid ontstaat doordat systemen rechtstreeks met elkaar verbonden worden. Iedere nieuwe point-to-point koppeling maakt verandering lastiger. Na verloop van tijd ontstaat een landschap waarin niemand nog precies weet welke systemen afhankelijk zijn van en verbonden aan elkaar.

Het gevolg laat zich raden. Iedere vervanging wordt een project en migraties vormen altijd een risico. Dat zet een flinke rem op de innovatie. Een goede integratielaag zorgt dat applicaties kunnen worden vervangen zonder dat alle omliggende systemen mee hoeven te veranderen. Daardoor ontstaat ruimte om infrastructuur, applicaties en dienstverlening onafhankelijk van elkaar te laten evolueren. En precies daar raakt integratie direct aan autonomie.

Autonomie moet je vooraf organiseren

“Autonomie, ach, daar kijken we later wel naar.” Voor de meeste organisaties is het niet het startpunt. En dat is een vergissing. Autonomie kan niet achteraf ontstaan. Je bouwt het in tijdens de selectie van software, bij architectuurkeuzes, tijdens aanbestedingen en bij het ontwerpen van koppelingen.

Daarom moet je niet alleen bekijken wat een oplossing vandaag kan. Wat je echt wilt weten, is hoeveel vrijheid er overblijft als de omstandigheden veranderen. Een leverancier kan zomaar de prijzen verhogen of worden overgenomen. Of je wilt simpelweg een betere oplossing.

Verwar je autonomie met soevereiniteit, dan loop je een serieus risico. De technologie kan nog zo goed zijn, maar de problemen ontstaan als de ene afhankelijkheid ongemerkt wordt ingeruild voor de andere. 

Hoeveel vrijheid houd je nu écht over?

De discussie over digitale soevereiniteit is waardevol en noodzakelijk. Maar organisaties die hun afhankelijkheden echt willen verkleinen, moeten verder kijken dan de locatie van een datacenter of de nationaliteit van een leverancier. Hoeveel vrijheid houd je over als je morgen wilt veranderen?

Klaar om autonomie concreet te maken?

Bij WeAreFrank! helpen we organisaties om afhankelijkheden zichtbaar te maken en digitale autonomie stap voor stap op te bouwen. Met het open source Frank!Framework maken we een integratielaag die systemen ontkoppelt zodat organisaties de keuzevrijheid houden, ook als leveranciers, technologieën of strategieën veranderen.

Benieuwd hoeveel bewegingsvrijheid er in jouw IT-landschap nog over is? Plan een vrijblijvend adviesgesprek. Dan kijken we samen waar afhankelijkheden zitten en hoe je die kunt verminderen.