De organisatie werkt wendbaar maar projecten duren te lang

projecten duren te lang

Regelmatig praten we met organisaties die de stap hebben gezet naar agile werken, maar daar niet de snelheid en wendbaarheid uithalen die ze beogen. Hoe kan dat? Een veel voorkomende oorzaak is het gebrek aan duidelijke ‘buckets’. In deze blog lees je hoe je dit probleem herkent én hoe je het kunt oplossen.


Stel je een fictieve organisatie voor: gemeente Rijnmaas, een middelgrote, Nederlandse gemeente is. Rijnmaas heeft de eerste stappen gezet naar wendbaar werken. De IT-organisatie van Rijnmaas bestaat uit verschillende teams. Een aantal teams werkt volgens het DevOps-concept met sprints van drie weken. Hierbij bepalen product owners de volgorde van het werk en experimenteren met Weighted Shortest Job First (WSJF) om hun backlog te prioriteren. Andere teams werken met Kanban-borden.


Naast de IT-organisatie heeft de organisatie een afdeling Projectmanagement. Die afdeling heeft tijdens de reorganisatie echter grotendeels aan de zijlijn gestaan. Tegelijkertijd introduceerde de organisatie een kwartaal-kadans om businessprojecten in te passen bij de verschillende teams. Daarbij hanteert het management als vuistregel dat teams 80% van de capaciteit aan businessprojecten besteden en 20% aan operationele werkzaamheden.


Op het eerste gezicht lijkt de organisatie daarmee een stuk wendbaarder. Echter, is dat in de praktijk ook zo?

Wendbare teams maken nog geen wendbare organisatie


De projectmanagers van Rijnmaas ervaren een andere werkelijkheid. Projecten lopen vertraging op en onderdelen die IT-teams moeten realiseren, krijgen niet altijd de verwachte prioriteit. Het management kan een project de hoogste prioriteit geven, terwijl een product owner de bijbehorende werkzaamheden lager op het backlog plaatst. Zo ontstaat naast de organisatiebrede prioritering een tweede prioriteitenlijst binnen de teams.


Daar komt nog een probleem bij. Voordat een team een onderdeel van een project kan oppakken, moet het werk voldoende zijn uitgewerkt. De projectmanager heeft daarvoor de kennis en capaciteit van het DevOps-team nodig. Juist die capaciteit blijkt moeilijk beschikbaar. Zonder refinement blijven onderdelen te groot en onvoldoende uitgewerkt.


Het toepassen van WSJF kan het probleem vervolgens onbedoeld versterken. Als grote, onvoldoende verfijnde projectonderdelen rechtstreeks concurreren met kleinere werkzaamheden, krijgen ze door hun omvang al snel een ongunstige positie. Een project kan op organisatieniveau de hoogste prioriteit hebben, maar door deze afweging zakken de werkzaamheden ervoor op het teamniveau toch naar beneden.


Het probleem zit daarmee niet vermoedelijk in de keuze voor agile, DevOps, projectmanagement of WSJF; de organisatie heeft verschillende besturingsmechanismen naast elkaar ingericht, maar heeft onvoldoende bepaald hoe deze op elkaar aansluiten.

Hoeveel capaciteit is werkelijk beschikbaar?


Een eerste vraag betreft de veronderstelde verdeling van 80% voor businessprojecten en 20% voor operations. Is deze verdeling gebaseerd op feiten of vooral op een bestuurlijke afspraak?


Een relatief eenvoudig onderzoek kan duidelijkheid geven. Analyseer samen met de product owner per team de gerealiseerde output over bijvoorbeeld een jaar. Bepaal waaraan het team daadwerkelijk capaciteit heeft besteed. Ging het om businessprojecten, operationeel werk, klein onderhoud, technical debt, wet- en regelgeving, lifecycle maintenance of iets anders?


Deze analyse kan bijvoorbeeld laten zien dat een team geen 80%, maar slechts 40% van diens capaciteit aan businessprojecten besteedt. De overige 60% gaat naar andere werkzaamheden. De oorspronkelijke capaciteitsaanname klopt dan simpelweg niet.


Vervolgens kun je onderzoeken of je werkzaamheden anders kunt organiseren. Misschien kun je kleine onderhoudsverzoeken bundelen en als businessproject behandelen. Stel dat hierdoor de te hanteren verdeling verschuift naar 50% businessprojecten en 50% overige werkzaamheden. Dan ontstaat een realistischer uitgangspunt voor de kwartaalplanning.


Voer deze analyse wel per team uit. Het ene team kan misschien 70% beschikbaar hebben voor businessprojecten, terwijl een ander team door veel operationeel werk niet verder komt dan 40%.

Werk met twee backlogs


Voor een organisatie die nog aan het begin van deze ontwikkeling staat, bieden twee afzonderlijke backlogs een overzichtelijke oplossing. Iedere backlog kent een eigen doel, een eigen prioriteringsmechanisme en een vooraf afgesproken aandeel van de beschikbare capaciteit.


De eerste backlog bevat de features voor de businessprojecten. De organisatie heeft deze projecten op portfolioniveau geprioriteerd. Projectmanagers vertalen de benodigde projectresultaten naar features en zorgen dat deze voldoende zijn uitgewerkt om ze te kunnen beoordelen, inschatten en plannen. Tijdens de kwartaalsessies bepaalt de organisatie welke features prioriteit krijgen en binnen de beschikbare capaciteit passen.


De projectmanager werkt die features niet alleen uit. Deze heeft de kennis van de DevOps-teams nodig om ze te beoordelen en te verfijnen. De organisatie moet daarom ook capaciteit beschikbaar stellen voor refinement, bijvoorbeeld uit de capaciteit beschikbaar voor businessprojecten.


De tweede backlog bevat operationeel en productgerelateerd werk, zoals operations, technical debt en lifecycle maintenance. De product owner bepaalt binnen deze backlog de prioriteiten en kan bijvoorbeeld WSJF gebruiken om te bepalen welke werkzaamheden de meeste waarde opleveren.


De verbinding tussen beide backlogs ontstaat via de vooraf afgesproken capaciteitsverdeling. Als een team 50% van zijn capaciteit beschikbaar heeft voor businessprojecten en 50% voor operationeel en productgerelateerd werk, vormen die percentages het uitgangspunt voor beide backlogs.


Hierdoor voorkom je dat de product owner op teamniveau opnieuw bepaalt hoeveel capaciteit de organisatiebrede projecten krijgen.

Laat features en user stories niet met elkaar concurreren


De twee backlogs voorkomen ook dat features en user stories rechtstreeks met elkaar concurreren. Ze bevinden zich immers op verschillende abstractieniveaus.


Voor de businessprojecten loopt de lijn van portfolio naar projecten, van projecten naar features en van geselecteerde features via refinement naar user stories. Nadat een feature voor uitvoering is geselecteerd, werkt het team deze verder uit in user stories.


Zo voorkom je dat een kleine user story met bijvoorbeeld een gunstige WSJF-score ineens voorrang krijgt op een strategisch belangrijke, maar veel grotere feature.

Prioriteit alleen is niet genoeg


Een goede kwartaalplanning brengt twee zaken bij elkaar. Aan de ene kant staat de geprioriteerde vraag vanuit het portfolio: welke projecten vindt de organisatie het belangrijkst? Aan de andere kant staat de werkelijk beschikbare capaciteit van de teams.


Stel dat een team 50% van diens capaciteit beschikbaar heeft voor businessprojecten. Tijdens de kwartaalsessie bepaalt de organisatie welke features uit de geprioriteerde projecten binnen die capaciteit passen. Past het gevraagde werk niet, dan moet zij kiezen. De organisatie kan werk doorschuiven, de scope aanpassen, capaciteit anders verdelen of capaciteit uitbreiden.


Echter, alleen projectprioriteiten vertalen naar features is nog niet voldoende. Ook afhankelijkheden spelen een belangrijke rol. Een feature met een lagere prioriteit kan een randvoorwaarde vormen voor een hooggeprioriteerde feature. Daarnaast kunnen verschillende teams van elkaar afhankelijk zijn. Als team B pas kan starten nadat team A een interface heeft opgeleverd, moet de kwartaalplanning daar rekening mee houden.


De kwartaalsessie moet daarom niet alleen antwoord geven op de vraag “Wat heeft prioriteit?”,  maar ook op “wat moet wanneer gereed zijn?”, “welke features zijn van elkaar afhankelijk?”  en “Hebben de betrokken teams daarvoor voldoende capaciteit?”.


Zo ontstaat een iteratief proces van prioriteren, afhankelijkheden analyseren, toetsen aan capaciteit, plannen en opnieuw balanceren.

Wie bewaakt de samenhang?


De projectmanager bewaakt de afhankelijkheden tussen de features en teams binnen diens project. Deze weet welke teams iets moeten opleveren, in welke volgorde dat moet gebeuren en welke afhankelijkheden de voortgang kunnen blokkeren.


Zodra afhankelijkheden meerdere projecten raken, kan een individuele projectmanager de afweging niet meer zelfstandig maken. Twee projecten kunnen bijvoorbeeld dezelfde specialist of dezelfde DevOps-capaciteit nodig hebben. Beide projectmanagers kunnen hun behoefte zichtbaar maken, maar niet zelfstandig bepalen wie voorrang krijgt.


Hier ligt een taak voor een centrale portfoliofunctie, bijvoorbeeld een Portfolio Management Office. Projectmanagers brengen de afhankelijkheden vanuit hun projecten in kaart en product owners vullen dit aan met afhankelijkheden vanuit hun producten en teams. De portfoliofunctie brengt deze informatie samen en ondersteunt daarmee de kwartaalsessies.


De verdeling van verantwoordelijkheden blijft zo helder. De product owner prioriteert het operationele en productgerelateerde werk binnen de tweede backlog. De projectmanager bewaakt de samenhang van zijn project. De portfoliofunctie bewaakt het integrale overzicht over projecten, teams, capaciteit en afhankelijkheden. De portfoliostuurgroep neemt besluiten wanneer projecten concurreren om dezelfde schaarse capaciteit.

Bewaak ook de verdeling tussen de backlogs


Een afgesproken capaciteitsverdeling heeft alleen waarde als de organisatie ook controleert of teams zich eraan houden. Stel dat een team 50% van de capaciteit aan businessprojecten zou besteden, maar in werkelijkheid structureel slechts 35% inzet. Dan krijgen de geprioriteerde projecten nog steeds niet de capaciteit waarop de kwartaalplanning is gebaseerd.


De product owner en het team maken daarom de werkelijke capaciteitsbesteding zichtbaar. De centrale portfoliofunctie vergelijkt de afgesproken verdeling met de werkelijke inzet en signaleert structurele afwijkingen.


Een incidentele afwijking hoeft geen probleem te zijn. Een ernstig productie-incident kan bijvoorbeeld tijdelijk meer operationele capaciteit vragen. De product owner zou de afgesproken verdeling echter niet zelfstandig structureel moeten wijzigen. Anders verschuift de organisatiebrede prioritering opnieuw ongemerkt naar het niveau van één team.


Blijkt een tekort structureel, dan moet het verantwoordelijke management besluiten. Het kan minder werk uitvoeren, capaciteit anders verdelen of capaciteit uitbreiden. De product owner en projectmanager maken de gevolgen van de schaarste zichtbaar, maar het managementniveau dat verantwoordelijk is voor portfolio, capaciteit en budget neemt de uiteindelijke beslissing.

Van lokale naar organisatorische wendbaarheid


Zo ontstaat een relatief eenvoudig duaal besturingsmodel. Ieder team werkt met twee backlogs en de organisatie reserveert vooraf capaciteit voor beide. De businessprojectenbacklog bevat features uit de op portfolioniveau geprioriteerde projecten. De tweede backlog bevat operationeel en productgerelateerd werk dat de product owner binnen de beschikbare capaciteit prioriteert.


De projectmanager bewaakt de samenhang van het project en de afhankelijkheden tussen features en teams. De product owner stuurt op de tweede backlog en maakt samen met het team de feitelijke capaciteitsbesteding zichtbaar. De portfoliofunctie brengt projecten, features, capaciteit en afhankelijkheden bij elkaar en ondersteunt de kwartaalplanning. De portfoliostuurgroep grijpt in wanneer projecten om dezelfde schaarse capaciteit concurreren of wanneer de organisatie prioriteit, scope, timing of capaciteit moet aanpassen.


Dit model verbindt projectmanagement, productmanagement, DevOps en portfoliomanagement zonder hun verantwoordelijkheden door elkaar te halen. Juist voor een organisatie die haar eerste stappen in wendbaar werken zet, helpt die eenvoud.


Wendbaarheid ontstaat namelijk niet door teams in sprints te laten werken, Kanban-borden op te hangen of WSJF toe te passen. Een organisatie wordt pas echt wendbaar als zij strategische prioriteiten, projecten, features, afhankelijkheden en werkelijk beschikbare capaciteit met elkaar verbindt.


Anders optimaliseert ieder team zijn eigen backlog, terwijl de belangrijkste projecten van de organisatie blijven wachten. Prioriteren zonder rekening te houden met capaciteit en afhankelijkheden creëert uiteindelijk vooral een goed georganiseerde wachtlijst.


Interessant? Wil je meer weten?
We gaan graag met je in gesprek.


Contact opnemen


De auteur: Henny Portman. Henny is blogger, recensent, auteur, internationaal key note spreker, trainer en consultant portfoliomanagement en P3M Volwassenheid.