Samenwerken over organisaties heen

Willen twee organisaties digitaal samenwerken, dan koppelen we meestal hun systemen. We spreken af welke API’s er zijn, welke gegevens worden uitgewisseld en welke berichten aan de andere kant iets in gang zetten. Dat werkt, tot de samenwerking hechter wordt. Dan moet organisatie A steeds meer weten van het proces van organisatie B, en breekt een wijziging aan de ene kant iets aan de andere.

Het alternatief is samen één platform gebruiken. Dat haalt een deel van het technische werk weg, maar brengt een andere afhankelijkheid: beide organisaties moeten zich aanpassen aan dezelfde applicatie, hetzelfde datamodel en vaak dezelfde werkwijze.

Hoe dan ook betalen we voor digitale samenwerking met een stuk autonomie. Dat is vreemd. Buiten software besteden we voortdurend een verantwoordelijkheid uit zonder voor te schrijven hoe de ander intern werkt. Een gemeente die een constructieve toets laat doen, beheert het proces van het ingenieursbureau niet. Ze moet weten wat ze vraagt, welke informatie erbij hoort, waaraan het resultaat moet voldoen en wat er terugkomt.

Organisaties dragen verantwoordelijkheden over. Software koppelt meestal systemen.

Neem een aanvraag voor een omgevingsvergunning. Tijdens de case heeft de gemeente een constructieve toets nodig, en belegt die bij een ingenieursbureau.

De case blijft bij de eigenaar, de gemeente. Wat de organisatiegrens overgaat is een caserol: een omschreven verantwoordelijkheid, met toegang tot de informatie en handelingen die in elke fase van de case nodig zijn. Het bureau doet mee in de case zonder de case zelf over te nemen, en zonder de systemen van de gemeente te hoeven gebruiken. De gemeente hoeft op haar beurt niet te weten hoe het bureau zijn toets organiseert.

De grens tussen beide organisaties is de caserol. Die beschrijft welke verantwoordelijkheid wordt overgedragen, welke informatie erbij hoort, wat de rol mag op de plek waar de case nu staat, en welk resultaat wordt verwacht. Dat is veel minder dan een heel proces of dossier delen, en veel meer dan een API-aanroep.

Vandaag voert de partner de rol uit in de case van de eigenaar, of leest hij hem vanuit zijn eigen systeem; hem aan de kant van de partner als eigen caseflow laten lopen is de volgende stap.

Samenwerking is zelden één eenvoudige opdracht. Tijdens de toets kan het bureau extra informatie nodig hebben. Later komt een concept-advies binnen waar nog vragen over zijn. Is het advies definitief, dan horen sommige handelingen helemaal niet meer mogelijk te zijn.

Een caserol is dus geen statisch contract. De fase waarin de case staat, bepaalt wat de rol op dit moment ziet en mag. Verandert de fase, dan verandert ook wat er bij de rol hoort: andere informatie, andere handelingen. De server dwingt dat bij elke stap af: geen afspraak op papier, maar een poort.

Vervult een partner eenmaal de rol, dan veranderen zijn bevoegdheden mee met de fase terwijl de case verdergaat; niemand hoeft ze bij elke stap met de hand bij te stellen.

Omdat de grens een rol is, blijven drie dingen die meestal door elkaar lopen bewust gescheiden:

• Wie de rol vervult. De gemeente kan de toets bij een ander bureau beleggen, of weer zelf doen, zonder de case opnieuw te ontwerpen. Uitbesteden wordt een besluit, geen herontwerp.
• Hoe de rol wordt uitgevoerd. De mensen, tools en systemen van het bureau zijn de zaak van het bureau. Die veranderen verandert niets aan de verantwoordelijkheid die het op zich nam.
• De caseflow. De eigenaar kan zijn proces verbeteren. Een nieuwe versie verandert niets aan cases die al lopen.

Raakt een wijziging de afspraak tussen beide, dan moeten beide organisaties de nieuwe voorwaarden aanvaarden; ook een nieuw bureau aanvaardt de rol voordat het hem vervult.

Autonomie betekent niet werken zonder afspraken. Het betekent vrij zijn om je eigen werk te organiseren binnen de verantwoordelijkheden en grenzen die je hebt aanvaard.

De organisaties spreken af wat de rol moet opleveren, wanneer, aan welke kwaliteit het moet voldoen, welke informatie de rol mag gebruiken, en wat er gebeurt als de samenwerking stopt.

CaseFlows verbindt die afspraak met de caseflow die draait. Een afgesproken termijn moet in het proces staan, met wat er gebeurt als hij verstrijkt, zoals de case die terugkomt bij de vergunningverlener; anders wordt de rol niet aangesloten. En een wijziging van de afspraak geldt pas als beide organisaties haar hebben aanvaard.

Samenwerking wordt niet alleen opgeschreven. De grenzen ervan worden afgedwongen.

Voor de gemeente vervult het ingenieursbureau één caserol en is het verantwoordelijk voor één omschreven resultaat. Dat betekent niet dat één persoon bij het bureau alles doet. Een projectleider neemt de opdracht aan, een specialist doet de analyse, een collega controleert en iemand tekent het advies.

Vandaag kan het eigen systeem van het bureau zijn rol al over de grens heen lezen, binnen precies wat die rol mag zien. Zegt een fase niet wat de rol mag zien, dan verlaat er niets het platform.

Waar we naartoe gaan: het bureau start een eigen caseflow om de aanvaarde rol te vervullen. Die caseflow organiseert het interne werk van het bureau, terwijl de oorspronkelijke case bij de gemeente blijft.

Een gemeente werkt misschien met meerdere ingenieursbureaus. Een bureau werkt voor meerdere gemeenten, en met eigen specialisten en leveranciers: een laboratorium voor een deel van een toets bijvoorbeeld, waar het op precies dezelfde manier een rol bij zou kunnen beleggen.

De ambitie is dat zulke samenwerkingen kunnen groeien zonder een nieuw integratieproject voor elke nieuwe relatie, en zonder dat één partij de hele keten hoeft te bezitten. Iedere organisatie houdt haar eigen verantwoordelijkheden, systemen en werkwijze; open specificaties beschrijven hoe ze samenwerken.

Vandaag ondersteunt CaseFlows het beleggen van een caserol bij een andere organisatie. Dat uitbreiden naar caseflows die zelfstandig over een breder netwerk lopen, is waar we naartoe bouwen.

Het ingenieursbureau kan AI de berekeningen laten nalopen op gaten of een concept laten voorbereiden, terwijl een ingenieur beslist. Hoe het dat werk organiseert, is zijn eigen beslissing.

De gemeente heeft nog steeds te maken met dezelfde caserol, hetzelfde afgesproken resultaat en dezelfde aanspreekbare organisatie. AI verandert hoe het werk gedaan wordt, niet wie verantwoordelijk is voor het resultaat.

Draait vandaag

• Caserollen met een eigen fase, waarbij de server op elk moment afdwingt wat een deelnemer mag zien en doen.
• Een rol die een andere organisatie vervult, met een afspraak die beide platforms bevestigen en een protocol dat de grens bewaakt, van begin tot eind doorgemeten.
• Afspraken over resultaat, termijn, kwaliteit en beëindiging, waarbij de termijn in de caseflow moet staan voordat de rol wordt aangesloten.
• Het eigen systeem van de partner dat zijn rol leest binnen de grenzen van die rol.
• Mensen van een partner die inloggen met het account van hun eigen organisatie.

Waar we naartoe gaan

• Een eigen caseflow achter een rol, gestart door de rol die binnenkomt.
• Een faseovergang die vanzelf het platform van de partner bereikt.
• Een testcase die op de ontwikkelomgeving de grens overgaat en daar verder loopt als testcase van de partner.
• Ketens die verder vertakken, organisatie na organisatie.