Tag: Keten

  • Onze keten leek veilig, tot één freelancer ons bedrijf stillegde

    Onze keten leek veilig, tot één freelancer ons bedrijf stillegde

    Waarom kleine afhankelijkheden grote gevolgen kunnen hebben

    Deze casus is een samengesteld praktijkvoorbeeld. Het is geen situatie die bij ons of onze klanten heeft plaatsgevonden, maar gebaseerd op patronen die we in veel organisaties zien.

    Het was dinsdagochtend, iets na negen. Een klant meldde dat hij niet kon inloggen. Dat gebeurt wel eens, meestal lost het zich vanzelf op. Maar binnen enkele minuten kwamen meer meldingen. Het ticketsysteem vulde zich, medewerkers konden niet meer bij hun documenten en het gevoel van “het zal zo wel over zijn” maakte plaats voor spanning.

    Binnen een kwartiertje lag een belangrijk deel van de dienstverlening stil.

    Er was geen aanval, geen grote storing bij een leverancier en niemand had iets verkeerd ingesteld.

    De oorzaak bleek een freelance ontwikkelaar te zijn die een jaar eerder een klein script had geschreven. Dat script was ongemerkt een cruciale rol gaan spelen in het loginproces. Niemand wist dat het bestond. Niemand beheerde het. En de betreffende freelancer was op vakantie, zonder bereik.

    In één klap werd zichtbaar hoe kwetsbaar een organisatie kan zijn wanneer een kleine schakel wegvalt.

    Het echte probleem zat niet in het script, maar in het ontbreken van inzicht

    De storing was vervelend, maar wat vooral bleef hangen was het ongemak. Niet omdat er iets misging – dat gebeurt overal – maar omdat we niet wisten:

    • Wie verantwoordelijk was
    • Waar de documentatie stond
    • Hoe dit script in het proces was beland
    • Wie dit kon overnemen

    Er was geen inzicht en dus geen eigenaarschap. Zonder eigenaarschap is er geen controle en zonder controle geen continuïteit.

    In veel organisaties werkt het precies zo. Niet bewust, maar omdat systemen, mensen en processen organisch groeien. Een specialist die “even iets bouwt”. Een consultant die tijdelijk toegang krijgt. Een partner die een API-koppeling toevoegt. Het voelt allemaal klein en tijdelijk, totdat het dat niet meer is.

    Zoals we eerder al beschreven in De risicoanalyse: een onmisbaar instrument voor elke ondernemer, worden veel risico’s pas zichtbaar wanneer ze realiteit worden.

    Waarom kleine afhankelijkheden zo vaak onder de radar blijven

    Ketenrisico’s worden meestal geassocieerd met grote leveranciers. Daar is vaak wel iets voor geregeld: contracten, afspraken, certificaten, periodieke evaluaties.

    Maar de kleine schakels vallen vaak buiten het zicht. Ze staan niet in een leverancierslijst, hebben geen eigen risicoanalyse en worden niet meegenomen in audits. Ze zijn er gewoon ineens; betrouwbaar, behulpzaam en belangrijker dan iemand denkt.

    Organisaties die geen volledige compliance-afdeling hebben en waar mensen meerdere petten dragen, herkennen dit vaak. Veel kennis zit in hoofden. Veel keuzes worden pragmatisch gemaakt. En veel kleine afhankelijkheden ontstaan zonder dat iemand ze echt ziet.

    Dat is geen schuldvraag. Het is precies hoe organisaties werken wanneer iedereen het druk heeft en systemen elke week een stukje veranderen.

    De storing was een signaal: dit had voorkomen kunnen worden

    Toen duidelijk werd dat één script verantwoordelijk was voor de uitval, ontstond er een nieuw inzicht: niet dat er iets misging, maar dat we niet wisten welke risico’s al die tijd al aanwezig waren.

    Bij het terugkijken bleek:

    • Dat er meerdere freelancers toegang hadden tot productie.
    • Dat sommige koppelingen nooit formeel waren vastgelegd.
    • Dat documentatie niet aansloot op de huidige werkelijkheid.
    • Dat processen afhankelijk waren van één persoon.
    • Dat niemand het totaaloverzicht had.

    Het ging dus niet om het script, maar om het systeem eromheen.

    Wat wél helpt: structuur zonder gedoe

    Ketenrisico’s in kaart brengen hoeft geen groot project te zijn. Het begint met helderheid: wie raakt welke processen en systemen?

    Stap1: Breng alle externe partijen in kaart

    Niet alleen leveranciers met een contract, maar iedereen die invloed heeft op je systemen en processen. Ook kleine opdrachten kunnen grote afhankelijkheden worden.

    Onze eerdere blog over leveranciersbeoordeling laat goed zien waarom dit nodig is.

    Stap 2: Koppel partijen aan processen, systemen en gegevens

    Een naam zegt niets zonder context. Pas als je weet wat iemand raakt, zie je welke impact er ontstaat bij uitval.

    Dit sluit aan op wat we beschreven in Hoe een ISMS en ISO 27001 beschermen tegen cyberrisico’s: overzicht ontstaat door koppeling, niet door losse lijntjes.

    Stap 3: Maak een eenvoudige risico-inschatting

    Geen uitgebreide methodiek. Drie vragen volstaan:

    • Wat gebeurt er als deze persoon morgen stopt?
    • Wat gebeurt er als deze dienst tijdelijk niet beschikbaar is?
    • Wat gebeurt er als deze partij toegang heeft tot gegevens of systemen zonder toezicht?

    Het doel is bewustzijn, niet perfectie.

    Stap 4: Wijs eigenaarschap toe

    Elke applicatie, elk proces en elke integratie heeft een eigenaar nodig. Niet iemand die alles zelf uitvoert, maar iemand die verantwoordelijk is voor het overzicht.

    Stap 5: Leg documentatie en fallback vast

    Het gaat niet om dikke handboeken. Een paar concrete punten zijn genoeg:

    • Waar de code of configuratie staat,
    • Wie het kan overnemen,
    • Hoe het proces werkt bij uitval

    In onze blog over business continuity laten we zien hoe je dat slim en lichtgewicht kunt organiseren.

    Wat je vandaag al kunt doen

    Veel organisaties willen beginnen, maar weten niet goed waar. Het helpt om het klein te houden. Bijvoorbeeld:

    1. Maak één korte lijst met alle externe partijen die iets raken in je systemen.
    2. Noteer per partij welke processen of gegevens afhankelijk zijn van hun werk.
    3. Bepaal per partij wie intern de verantwoordelijke is.
    4. Herstel waar nodig de basisdocumentatie.
    5. Leg bij kritieke onderdelen vast wie het kan overnemen.

    Dit kost weinig tijd, maar geeft meteen grip. Het maakt afhankelijkheden zichtbaar die anders verborgen blijven.

    Het gaat niet om techniek. Het gaat om continuïteit.

    De storing van die dinsdagochtend duurde een paar uur. Het inzicht dat eruit voortkwam was waardevoller: kleine afhankelijkheden hebben grote gevolgen wanneer niemand ze ziet.

    Met een beetje structuur voorkom je dat één persoon, één script of één vergeten koppeling een keten breekt. Je hoeft geen grote afdeling te hebben of uitgebreide compliance programma’s te draaien. Met overzicht, eigenaarschap en een paar praktische stappen ontstaat de rust die nodig is om continuïteit te waarborgen.

    Verder lezen