Iedereen had wensen. Niemand wilde beslissen.
Sales wilde minder verplichte velden. Finance wilde er juist drie bij. Operations wilde flexibiliteit, IT wilde strikte rechten en de directie wilde vooral dat het snel live ging.
Het resultaat: software met twaalf ouders en geen opvoeding.
Een projectgroep is geen eigenaar
Een brede projectgroep is waardevol. Verschillende afdelingen zien verschillende risico’s en gebruikers moeten gehoord worden. Maar luisteren en beslissen zijn niet hetzelfde.
Zodra belangen botsen, moet iemand kunnen zeggen: dit is het doel, dit doen we nu en dit bewaren we voor later. Zonder die rol worden besluiten doorgeschoven naar het volgende overleg of stilletjes bij de softwarebouwer neergelegd.
Dan maakt de developer een keuze omdat het werk anders niet verder kan. Technisch misschien logisch, maar zonder mandaat over het bedrijfsbelang.
Een product owner hoeft niet alle antwoorden te hebben. Wel het mandaat en het lef om een antwoord te kiezen.
De korting die niemand kon goedkeuren
Stel dat een bedrijf nieuwe offertesoftware laat bouwen. Sales wil kortingen flexibel kunnen invoeren. Finance wil dat alles boven tien procent wordt goedgekeurd. De directie vindt dat strategische klanten een uitzondering verdienen.
Iedereen heeft een redelijk punt.
De technische vraag is eenvoudig: welke regel bouwen we? De productvraag is lastiger: welk risico accepteert de organisatie en wie mag daar in welke situatie van afwijken?
Als niemand eigenaar is, ontstaat vaak de slechtste combinatie. We bouwen alle varianten, voegen meerdere rechten toe en maken een uitzonderingsroute. De software wordt duurder en ingewikkelder, terwijl het echte besluit nog steeds niet genomen is.
Meer functionaliteit is dan een manier om een gesprek te ontwijken.
Eigenaarschap begint vóór de bouw
De eigenaar van software bepaalt niet ieder label en iedere kleur. Die persoon bewaakt de reden waarom het product bestaat.
Hij of zij kan antwoord geven op vragen als:
- welk probleem moet als eerste verdwijnen?
- welke gebruiker is op dit moment het belangrijkst?
- wanneer is een eerste versie goed genoeg?
- welke uitzondering accepteren we voorlopig handmatig?
- welke meetbare verandering verwachten we na de lancering?
Dat vraagt tijd. Een product owner die alleen aan het einde van een overleg “akkoord” zegt, is geen eigenaar maar een handtekeningenmachine.
Na livegang wordt eigenaarschap belangrijker
Software is na de lancering niet klaar. Processen veranderen, gebruikers ontdekken nieuwe situaties en beveiligingsupdates blijven nodig. Zonder eigenaar verzamelt de backlog wensen van iedereen, maar ontbreekt richting.
De luidste afdeling krijgt dan voorrang. Kleine irritaties worden gebouwd omdat ze makkelijk uit te leggen zijn. Belangrijk onderhoud blijft liggen omdat niemand er direct om vraagt.
Uiteindelijk veroudert de oplossing niet door slechte code, maar door een gebrek aan keuzes.
Bij Byte Me blijven we graag als technische partner betrokken. Maar wij kunnen het producteigenaarschap van de organisatie niet overnemen. Wij kunnen scherp adviseren, gevolgen zichtbaar maken en soms stevig tegenspreken. De bedrijfsbeslissing hoort bij iemand die verantwoordelijkheid kan dragen voor het resultaat.
Eén eigenaar betekent niet één mening
Goed eigenaarschap is geen dictatuur. De eigenaar spreekt gebruikers, begrijpt de operatie en betrekt specialisten. Het verschil is dat input uiteindelijk tot een besluit leidt.
Ook moet duidelijk zijn waar het mandaat stopt. Een product owner kan prioriteiten bepalen, maar misschien niet zelfstandig juridisch risico accepteren of een groot budget verhogen. Goede governance maakt die grenzen zichtbaar zonder voor ieder detail een comité op te richten.
De Byte Me-vraag
Voordat we een serieus softwaretraject starten, willen we weten wie aan klantzijde de knopen doorhakt. Niet omdat we minder mensen willen spreken. Juist omdat we hun input serieus genoeg nemen om er iets mee te doen.
Als het antwoord “dat beslissen we met zijn allen” is, vragen we door. Wie beslist als jullie het niet eens worden? Wie maakt tijd om tussentijds te testen? Wie bewaakt na livegang of de software nog steeds waarde levert?
Software zonder eigenaar wordt wees. Iedereen gebruikt haar, iedereen heeft er een mening over en niemand voelt zich verantwoordelijk wanneer ze langzaam achteruitgaat.
Dus voordat je vraagt wie de software gaat bouwen, stel eerst een andere vraag:
Wie gaat haar opvoeden?