Je kunt je eigen authenticatie in een dag bouwen. Dat is de valkuil.

Tientallen B2B-teams vertelden ons hetzelfde verhaal. Het begint als een simpele loginpagina. Daarna komt er echte traffic en verandert het ongemerkt in een identiteit-infrastructuur: het fundament waarop je hele product leunt.

Het leek een feature. Het werd een heel identiteitsmodel.

Elke eigenbouw-authenticatie begint met een paar regels code. Het probleem begint pas na de lancering, wanneer elke kleine beslissing ongemerkt het model vormt waar je hele product op vertrouwt.

Dag één: veertig regels code

E-mail, wachtwoord, hash het, sla het op, vergelijk bij inloggen. Simpel en klaar.

Precies daarom begint elk team hier – en lijkt authenticatie iets dat je in een middagje fixt.

Dag tweehonderd: een stil identiteitsmodel

Wie geldt als gebruiker. Bij welke organisatie hoort hij. Welke sessie is nog betrouwbaar. Hoe trek je toegang weer in.

Rate limits, MFA en het herstelproces daarvan, sessies, refresh tokens, een organisatiemodel dat veel verder gaat dan een is_admin-boolean. Elk antwoord dat je levert wordt een regel waar het product nu stilzwijgend van uitgaat.

Jaar vijf: een fundament waar je niet aan kunt komen

Op papier het inlogscherm vervangen betekende in de praktijk het identiteitsfundament herbouwen.

Een SaaS-bedrijf van 20 jaar probeerde over te stappen naar e-mail-als-gebruikersnaam. Permissiechecks zaten verspreid over honderden modules. Niemand wilde goedkeuren, dus het proces sleepte voort tot het vastliep.

Eigen authenticatie werkt prima – tot het bedrijf verandert

Het laat mensen jarenlang probleemloos inloggen. Maar één bedrijfsverandering maakt van “het is genoeg” ineens “het zit in de weg”. Deze drie triggers komen bij bijna elk groeiend product voorbij.

Enterprise-klanten gaan om SSO vragen

  • Verschillende protocollen, veldmappings en certificaatrotaties per klant
  • SSO bouw je niet één keer. Je bouwt het opnieuw voor iedere enterprise-klant
  • Het wordt langzaam handwerk dat maar één engineer helemaal snapt

De eerste grote deal komt en inkoop wil SSO via hun eigen Entra of Google Workspace. Dan willen ze zowel SAML als OIDC, want de volgende klant gebruikt weer iets anders. Ieder zijn eigen identiteitsset-up, en bijna niets van het werk kun je hergebruiken.

Meer informatie

Identiteit die verspreid begon moet nu één geheel worden

  • Kan één e-mailadres bij meerdere organisaties horen? Hoe migreer je historische gebruikersnamen?
  • Negen producten uit overnames betekent negen authenticatiestacks parallel draaien
  • Trek aangepaste toegang in bij alle tegelijk, en audit dit op één plek

Gesplitst per organisatie, per product, vaak via overnames. “Identiteit unificeren” klinkt als een feature; in code betekent het herdefiniëren wie één gebruiker of organisatie is.

Meer informatie

AI-agenten en CLI’s gaan gebruikers namens hen vertegenwoordigen

  • Voor wie wordt het token uitgegeven, met welk bereik en welke doelgroep?
  • Geef slechts één tool of één dataveld toegang, en trek het later weer in
  • MCP- en CLI-toegang draait om OAuth, niet om een loginformulier

Het zijn niet langer alleen mensen in een browser. Agenten, MCP-servers en command lines claimen allemaal namens een gebruiker te handelen. En jouw authenticatie weet alleen hoe je iemand naar een pagina laat inloggen.

Meer informatie

De werkelijke kosten zitten niet in het bouwen. Maar in het jarenlang onderhouden.

De eerste versie is goedkoop: een paar engineers, een paar weken, klaar. Daarna blijft elk jaar tijd wegstromen die in je eigenlijke kernproduct had moeten gaan.

De rekening is veranderd, niet verdwenen

Je krijgt nooit een factuur met “authenticatie” erop.

Je betaalt in “persoon-maanden”, uitgestelde deadlines, security-schuld en herbouwen. Eén ledenorganisatie bouwde het zelf om licentiekosten te vermijden; vijf jaar later had onderhoud meer gekost dan ooit kopen zou doen.

Het rust stilletjes op één of twee mensen

De echt kritieke kennis zit in iemands hoofd, niet in de documentatie.

Welke klant hoe geconfigureerd is, waarom een migratie vroeger zo ging. Als die persoon er niet is, stokt het salesproces. Als hij vertrekt, gaat alle kennis met hem mee.

Waar wil je je engineers inzetten?

Geen enkele klant betaalt je meer omdat je je eigen OAuth-server schreef.

Authenticatie moet betrouwbaar zijn. Maar “betrouwbaar” is niet hetzelfde als “zelf gebouwd”. Voor de meeste producten is authenticatie een essentiële afhankelijkheid, geen uniek kernvoordeel. Dat verschil is groot.

Als je het niet zelf bouwt – hoe kies je dan?

De meeste volwassen authenticatiesystemen bieden de functionaliteit al: SSO, MFA, organisaties, unified login, agent access. Het echte verschil: kun je weg? Ga niet van je eigen code over naar een leverancier waar je net zo goed in vastzit.

Standaardprotocollen, geen eigen stack

OIDC, OAuth en RS256-getekende JWT’s ken je al. Claims lees je direct uit een standaardtoken, zonder vendor-specifieke API’s te hoeven leren.

Een deur waar je echt doorheen kunt

Is het open source en zelf te hosten, dan kun je altijd vertrekken wanneer je wilt. Ruil je eigen systeem dus niet in voor iets dat je ook niet kunt verlaten.

Facturatie volgt niet je gebruikerstabel

Rekening houden met geregistreerde of actieve maandelijkse gebruikers betekent een tabel die alleen groeit. Op schaal wordt dat een groeibelasting – precies waarom teams eigen systemen bouwen.

Je data zit nooit op slot

Exporteer gebruikersdata wanneer je wilt. Door deze gevoelige data aan een specialist toe te vertrouwen, voorkom je het risico op datalekken bij een partij die daar niet voor is ingericht.

Authenticatie is waarschijnlijk niet je core business. Behandel het ook zo.

Logto is open source, zelf te hosten, en ook als beheerde Cloud-dienst te krijgen. Sign-in, MFA, SSO en RBAC werken direct met standaard OIDC. Facturatie volgt tokens, en als je later weg wilt, staat de deur open.

Veelgestelde vragen

Moet je dan nooit je eigen authenticatiesysteem bouwen?

Nee. Voor vroege demo’s, interne tools, eenmalige validatieprojecten of hele specifieke fijnmazige autorisatie die kant-en-klare opties niet aankunnen kan eigenbouw prima zijn (deels of helemaal). Wat je wilt vermijden, is dat je zonder het te beseffen langdurige, algemene identiteit-infrastructuur opbouwt binnen de onderhoudsscope van een business-team.

Wat is het verschil tussen authenticatie en autorisatie?

Authenticatie beantwoordt de vraag: “wie ben je”. Autorisatie beantwoordt: “wat mag je doen”. In een echte SaaS zijn die lastig te scheiden: gebruikers, organisaties, rollen, permissies, sessies, token-claims en auditlogs lopen allemaal door elkaar. Dus als je een authenticatiesysteem vervangt, kun je niet alleen naar de loginpagina kijken.

Waarom maakt enterprise SSO eigen authenticatie ingewikkeld?

Omdat enterprise SSO betekent dat je product moet integreren met het authenticatiesysteem van de klant. Elke klant gebruikt weer andere IdP’s, protocollen, claimvelden, certificaten en organisatie-mappings. De eerste klant koppelen is geen garantie dat de rest net zo gaat. Vaak wordt het langzaam handwerk dat alleen één engineer nog snapt.

We draaien ons eigen systeem al jaren. Kunnen we nog migreren?

Ja, al is één harde overstap meestal niet realistisch. De praktische route is migreren in lagen: zet nieuwe sign-ups, logins en enterprise SSO eerst op het nieuwe platform, en migreer bestaande gebruikers geleidelijk bij hun volgende login. Maak eerst de gebruikersdirectory en het organisatiemodel uniform, werk dan de fijnmazige permissies bij, en houd rollback-opties en audits bij de hand.

Waarom worden AI-agenten en MCP een nieuwe druk op authenticatie?

Omdat ze een nieuwe use-case introduceren: een client die resources namens een gebruiker benadert. Als je oude systeem alleen mensen op een pagina liet inloggen, wordt het lastig te bepalen aan wie het token is uitgegeven, met welke scope, hoe je het intrekt en wie je in de auditlog vastlegt. Uiteindelijk is het soortgelijke business change als enterprise SSO, alleen door een nieuwer soort trigger.