Een ecosysteem dat met je meegroeit

Netwerken van organisaties komen vaak uit op het platform van één partij, op haar voorwaarden, of op een web van losse koppelingen waarin elke nieuwe relatie een nieuw project is. Het eerste maakt iedereen afhankelijk van één eigenaar; het tweede groeit niet.

Er zijn andere wegen: federatieve netwerken en open standaarden laten al lang zien dat samenwerken geen enkele eigenaar nodig heeft. CaseFlows is een concrete manier om dat voor het werk zelf te doen: autonome organisaties die samenwerken via verantwoordelijkheden die ze afspreken, caserol voor caserol.

Niet iedereen in het ecosysteem doet op dezelfde manier mee. Er zijn drie soorten relaties:

• Werken in de case. De eigenaar voert de case uit op zijn eigen platform. Een partner vervult er een rol in. Een klant of aanvrager doet mee zonder eigen platform.
• Mogelijkheden leveren. Een dienstverlener levert gegevens of een berekening die een rol gebruikt. Hij vervult geen rol; hij is gekoppeld als dienst.
• Anderen helpen bouwen. Een implementatiepartner helpt een organisatie haar werk te beschrijven en haar eerste caseflows te bouwen. Hij werkt op de ontwikkelomgeving, niet in de lopende cases.

• Een klant of aanvrager: nee. Meedoen in een case is gratis.
• Een partner die een rol vervult: niet per se. Hij kan via de rol meedoen in je case, zonder eigen platform en kosteloos.
• Een partner die de rol aan zijn eigen mensen wil toewijzen en zelf beheren: ja, vanaf zijn eigen CaseFlows-platform.
• Een organisatie die eigen caseflows bouwt: ja, een platform met een eigen ontwikkelomgeving.
• Een dienstverlener: nee; hij is gekoppeld als dienst.

Een eigen platform is een abonnement, en eigen caseflows bouwen is het hogere. Tijdens de private beta spreken we de voorwaarden met elke organisatie af voordat er iets vastligt.

Je begint niet met een ecosysteem. Je begint met één case en één partner. De partner neemt een rol op zich, de twee organisaties spreken af wat hij mag zien en doen, en het werk loopt.

De volgende partner is geen nieuw integratieproject. Tussen CaseFlows-platforms is een rol bij een andere organisatie beleggen een afspraak die beide kanten bevestigen, geen code die geschreven moet worden. Een tweede bureau kan dezelfde rol op zich nemen; een bureau dat al voor de ene organisatie werkt, kan een rol voor een andere vervullen. Elke relatie komt er los bij, en geen ervan verandert de andere. Hoe twee organisaties samen aan één case werken, staat in Samenwerken over organisaties heen.

Een ecosysteem is meer dan een verzameling verbindingen. Het wordt waardevol als elke nieuwe deelnemer het de volgende makkelijker maakt.

Een nieuwe samenwerking doet meer dan twee organisaties verbinden. Ze kan iets opleveren wat anderen kunnen hergebruiken: een caserol, een samenwerkingsafspraak, een koppeling met een dienst, een betere manier om het werk te organiseren. Met toestemming van de deelnemers zouden die bouwstenen voor anderen vindbaar kunnen worden: een nieuwe partner hoeft zijn afspraak dan niet van nul te bedenken, en een dienstverlener die de ene organisatie koppelde, kan door de volgende gevonden en gebruikt worden, samen met wat anderen ermee leerden.

Zo willen we het ecosysteem laten groeien: vanuit echt werk, verbinding voor verbinding. Vandaag wordt elke relatie apart opgezet; een gedeelde plek waar zulke bouwstenen te vinden zijn, is onze richting.

Samen groeien betekent niet samen in één platform trekken. Elke organisatie beheert haar eigen platformomgeving: haar caseflows, haar gegevens, haar diensten, haar manier van werken. Die omgevingen kunnen op gedeelde infrastructuur draaien of op aparte servers. Autonomie komt van de grenzen tussen organisaties, niet van een eigen machine voor elk.

Wat gedeeld wordt, blijft klein: een register dat organisaties helpt elkaar te vinden en te herkennen, en waar hun platform staat. Het bezit hun cases niet en beheert hun afspraken niet; elke organisatie blijft verantwoordelijk voor de relaties en rollen die ze aanvaardt.

Hoe vertrouwen tussen platforms werkt. Elk platform heeft een eigen adres en een eigen sleutel, en ondertekent zelf wat het vraagt. Het platform dat gevraagd wordt, controleert die handtekening tegen de afspraak tussen hen. Er wordt geen geheim gedeeld tussen installaties.

Twee organisaties moeten een nieuwe samenwerking kunnen verkennen voordat echte cases ervan afhangen. In CaseFlows doen ze dat op de ontwikkelomgeving: ze spreken de verantwoordelijkheden af, lopen testcases door, zien wat elke deelnemer mag zien en doen, en vinden waar het proces bijgesteld moet worden, voordat er een echte aanvraag met echte persoonsgegevens doorheen loopt.

Pas als beide organisaties de regeling aanvaarden, gaat hij naar productie; productie voert alleen een samenwerking uit die beide kanten hebben doorgezet. Mensen van een partner loggen in met het account van hun eigen organisatie, zodat niemand de gebruikers van de andere kant hoeft te beheren.

Waar we naartoe gaan: een testcase die de grens overgaat en aan de kant van de partner verder loopt als eigen testcase, zodat beide organisaties de hele samenwerking, van binnen en van buiten, kunnen ervaren voordat hij bestaat.

Sommige samenwerkingen zijn te belangrijk om af te hangen van de regels van één organisatie. Een groep deelnemers kan ervoor kiezen samen gedeelde specificaties te onderhouden: de rollen, verantwoordelijkheden en afspraken die hun samenwerking laten werken. Daarvoor hoeft niet gewacht te worden tot veel organisaties toevallig hetzelfde werken; gemeenten en zorgaanbieders, of een groep energiecoöperaties, kunnen er bewust voor kiezen.

Elke organisatie blijft verantwoordelijk voor haar eigen cases en systemen. De gedeelde specificatie wordt samen bestuurd, en dat roept een eigen vraag op: wie mag een gedeelde specificatie veranderen, en hoe werken deelnemers op verschillende versies door terwijl een nieuwe wordt overgenomen? Dat is een andere vraag dan wie de caseflow van één organisatie mag veranderen, en de deelnemers beantwoorden hem samen.

Een manier om de groei voor te stellen:

1. Samenwerking: twee organisaties spreken een caserol af en werken samen.
2. Netwerk: meer organisaties gaan relaties aan, en hergebruiken rollen, diensten en specificaties.
3. Commons: een groep organisaties onderhoudt samen de specificaties en afspraken die hun samenwerking regelen.

Het eerste draait vandaag. De bouwstenen voor de andere bestaan: een gedeelde laag die meerdere platforms volgen, zoals onze eigen platforms hun concepten al delen, en afspraken die elk platform zelf bevestigt. De eerste commons die onafhankelijke organisaties echt samen draaien, is de volgende stap. Meer over gedeeld beheer in Open specificaties, meeneembare processen.

Als niemand het hele ecosysteem bezit, is het een terechte vraag wat CaseFlows dan wel bezit en beheert. Vandaag:

• We draaien het register waarin organisaties en hun platforms elkaar vinden.
• We onderhouden het protocol waarmee platforms rollen aan elkaar geven, en bepalen hoe het zich ontwikkelt.
• We leveren de enige runtime voor de specificaties, en we hosten de platforms.

Wat hoe dan ook van jou blijft, zijn je specificaties, als open bestanden die je kunt lezen en bewaren, en je afspraken met je partners. Een federatief ontwerp is nog geen onafhankelijkheid van de leverancier die het bouwde; dat zeggen we liever dan dat we het suggereren. Onze richting is hier meer van over te dragen: het beheer van de gedeelde regels aan de deelnemers van een commons, en een tweede runtime voor dezelfde open formaten.

Een ecosysteem heeft ook mensen nodig die anderen helpen aansluiten. Implementatiepartners doen dat: een adviesbureau dat een sector kent, werkt met de proceseigenaar van een organisatie, helpt het werk te beschrijven en bouwt samen de eerste caseflows op de ontwikkelomgeving. Iets naar productie brengen blijft de beslissing van de klant. Dat partnermodel zetten we nu op, met onze eerste partners. Meer bij Implementatiepartners.

Draait vandaag

• Een caserol die een andere organisatie vervult, met een afspraak die beide platforms bevestigen.
• Samenwerkingen eerst ontworpen en beproefd op de ontwikkelomgeving; productie voert alleen uit wat beide kanten doorzetten.
• Platforms met een eigen adres en sleutel, op gedeelde of aparte servers, zonder gedeeld geheim.
• Mensen van een partner die inloggen met het account van hun eigen organisatie.
• Klanten, aanvragers en partners die zonder platform meedoen in een case, kosteloos.
• Een gedeelde laag van concepten die meerdere van onze eigen platforms volgen.

Waar we naartoe gaan

• Een plek waar herbruikbare rollen, afspraken en diensten te vinden zijn, met toestemming van de deelnemers.
• Een testcase die de grens overgaat en verder loopt als eigen testcase van de partner.
• Ketens van organisaties die rollen doorgeven, van begin tot eind gemeten.
• De eerste commons die onafhankelijke organisaties samen draaien, en het beheer van gedeelde regels in handen van de deelnemers.
• Het partnermodel, met de eerste implementatiepartners.