Hoe een intern script uitgroeide tot een filosofie over kwaliteit, controle en DevOps in Mendix

Wie JAM-IT kent, weet dat wij sterk geloven in structuur, kwaliteit en eigenaarschap. Niet als buzzwords, maar als fundament. Wat minder mensen weten, is dat ons grootste product, JamOps, niet begon als product maar als noodzaak.

In gesprek met Armando en Martijn wordt al snel duidelijk: JamOps is niet bedacht omdat er “nog een tool” nodig was. Het ontstond omdat zij iets fundamenteels misten. 

De grens van handmatige controle 

Voordat JamOps bestond, werd de werkwijze binnen JAM-IT handmatig bewaakt. Conventies, security-afspraken en kwaliteitsregels werden onderling gecontroleerd. In een klein team werkte dat goed.

Maar naarmate projecten groeiden en meer ontwikkelaars betrokken raakten, werd die controle minder vanzelfsprekend. Rapportages gaven inzicht, maar leidden niet altijd tot actie. Afwijkingen bleven liggen en sommige fouten kwamen pas later aan het licht. De afhankelijkheid van handmatige discipline begon te knellen.

Martijn had dit eerder meegemaakt in de Java-wereld. Daar bestaan al jaren tools die code analyseren en kwaliteit controleren. Maar ook daar zag hij hetzelfde patroon: er werd gerapporteerd, maar niet altijd gehandeld; waarschuwingen zonder consequenties.

Dat voelde niet goed. “Als kwaliteit optioneel is, dan wordt het uitgesteld. En wat je uitstelt, stapelt zich op.”

Toen hij bij JAM-IT opnieuw zag dat ontwikkelaars bouwden zonder directe controle op naleving van afspraken, werd het duidelijk: dit moeten we automatiseren. Niet om mensen te controleren, maar om de standaard te bewaken. Binnen de Mendix-wereld bestond zo’n oplossing simpelweg niet. Dus bouwden we het zelf.

Van script naar platform

De eerste versie van JamOps was nog geen platform zoals het nu is. Er was geen dashboard en geen visuele omgeving, maar een verzameling interne scripts die we gebruikten om onze eigen werkwijze te bewaken. Die scripts deden wat ze moesten doen en hielpen ons om controle te houden op kwaliteit en afspraken binnen projecten.

Toch had deze aanpak zijn beperkingen. De oplossing was technisch effectief, maar niet schaalbaar en niet inzichtelijk voor anderen. Dat veranderde toen een klant vroeg hoe concurrenten hun DevOps-structuur hadden ingericht. In dat gesprek werd duidelijk dat wij in de kern al iets hadden ontwikkeld dat verder ging dan een intern hulpmiddel, alleen was het nog niet zichtbaar of toegankelijk als product.

De behoefte aan een visuele laag groeide, zowel intern als bij klanten die transparantie en traceerbaarheid belangrijk vonden. Wat begon als een praktische interne oplossing, kreeg daarmee een bredere betekenis. Vanuit die ontwikkeling ontstond JamOps zoals het vandaag bestaat.

Geen waarschuwingen, maar duidelijkheid

Als je JamOps in één zin zou moeten omschrijven zonder features te noemen, dan is het volgens Armando een Zwitsers zakmes voor Mendix-ontwikkeling. Alles wat we misten, hebben we aangevuld. Maar wat JamOps echt typeert, is de filosofie erachter. Wij geloven niet in waarschuwingen die je kunt negeren. Wij geloven in duidelijkheid. Het is goed of het is niet goed. Geen grijs gebied. Dat klinkt streng, maar in de praktijk blijkt het bevrijdend.

Wanneer een ontwikkelaar commit, krijgt hij of zij direct feedback. Binnen een minuut is duidelijk of de wijziging voldoet aan de afgesproken standaarden. Zit er een security-risico in? Een patroon dat foutgevoelig is? Een afhankelijkheid die kwetsbaar is? Dan stopt de pipeline. Niet om te blokkeren, maar om te beschermen.

“Directe feedback werkt, omdat de ontwikkelaar nog in de context van het werk zit. Het probleem is klein, overzichtelijk en oplosbaar. Niet verstopt in een rapport dat weken later wordt gelezen.”

Waarom kwaliteit niet optioneel is

Voor JAM-IT gaat kwaliteit niet alleen over nette code, maar over toekomstbestendigheid. Wie vanaf het begin volgens duidelijke standaarden werkt, voorkomt dat projecten later vastlopen in technische schuld. Een solide basis geeft ruimte om door te ontwikkelen zonder telkens terug te moeten naar de tekentafel. Daarom is kwaliteit geen voorkeur, maar het uitgangspunt.

Wat verandert er in de praktijk?

In de dagelijkse praktijk betekent JamOps vooral dat kwaliteitsbewaking geen losse stap meer is, maar een geïntegreerd onderdeel van het ontwikkelproces. Voor ontwikkelaars fungeert het systeem als een continue controlelaag die meekijkt op het moment dat wijzigingen worden doorgevoerd. Zeker voor minder ervaren developers biedt dat houvast: patronen worden bewaakt, afwijkingen worden direct zichtbaar en de kans dat kleine fouten zich opstapelen wordt aanzienlijk kleiner.

Omdat controles automatisch plaatsvinden vóórdat een wijziging verder gaat in de pipeline, ontstaat er rust in het proces. Deployments volgen uit een gevalideerde build en niet uit handmatige checks achteraf. Dat verkleint de afhankelijkheid van individuele discipline en maakt het proces voorspelbaarder.

Op teamniveau zorgt dit voor consistentie. Conventies worden niet alleen afgesproken, maar ook gehandhaafd. Nieuwe collega’s kunnen instappen in een omgeving waarin structuur al is vastgelegd in tooling. Kwaliteit wordt daarmee minder persoonsafhankelijk en meer onderdeel van het systeem zelf.

Ook op het gebied van security heeft die werkwijze impact. Denk aan het signaleren van verlopen certificaten, ongewenste anonieme toegang, kwetsbare afhankelijkheden of patronen die foutgevoelig zijn. Zulke aandachtspunten zijn vaak klein in het moment, maar kunnen grote gevolgen hebben wanneer ze pas laat worden ontdekt. Door ze vroeg in het proces te ondervangen, blijven projecten beheersbaar.

Meer dan alleen DevOps

Functioneel gezien ondersteunt JamOps onder meer Continuous Integration en Continuous Delivery, voert het statische code-analyses uit, automatiseert het unit tests en controleert het afhankelijkheden binnen Mendix- en Java-componenten. Daarnaast biedt het inzicht in applicaties, modules en configuraties.

Toch ligt de waarde niet alleen in de afzonderlijke onderdelen, maar in de samenhang. Binnen traditionele programmeertalen is het gebruikelijk om tooling in te zetten die kwaliteit en security afdwingt. In low-code omgevingen was dat lange tijd minder vanzelfsprekend. JamOps brengt die mate van controle naar de Mendix-wereld en maakt DevOps daar structureel in plaats van incidenteel.

Voor organisaties die werken met certificeringen zoals ISO 27001 speelt dat een belangrijke rol. Niet alleen omdat processen aantoonbaar zijn vastgelegd, maar omdat naleving technisch wordt ondersteund. Traceerbaarheid en transparantie worden zo onderdeel van het ontwikkelproces zelf, in plaats van een aparte administratieve laag.

Doorontwikkeling zonder de kern te verliezen

Sinds de eerste versie heeft JamOps zich verder ontwikkeld. Waar het aanvankelijk vooral gericht was op het strikt blokkeren van afwijkingen, is het uitgebreid met rapportages, statistieken en overzichten die organisaties helpen om inzicht te krijgen in trends en kwaliteitsontwikkeling. Daarnaast is er een API toegevoegd, zodat gegevens uit JamOps geïntegreerd kunnen worden in bestaande dashboards en interne systemen.

Die uitbreidingen spelen in op verschillende werkwijzen bij klanten, zonder dat de kern verandert. De onderliggende gedachte blijft dat kwaliteit geborgd moet zijn in het proces zelf.

Technisch draait JamOps op het Mendix-platform, waarbij de diepgaande analyses en integraties grotendeels in Java zijn ondergebracht. Automatisering vormt vanaf het begin de basis. Nieuwe technologische ontwikkelingen, waaronder AI, worden ingezet om de onderliggende techniek verder te versterken, maar niet om de menselijke verantwoordelijkheid uit het proces te halen.

Wat JamOps uiteindelijk vertegenwoordigt

JamOps is daarmee geen losstaande tool naast ontwikkelprojecten, maar een verlengstuk van een bepaalde manier van werken. Het ontstond vanuit een interne behoefte aan grip en consistentie en groeide uit tot een platform dat die werkwijze ook voor andere organisaties beschikbaar maakt.

De essentie is niet dat alles wordt gecontroleerd, maar dat afspraken niet vrijblijvend zijn. Kwaliteit en security worden niet achteraf beoordeeld, maar vooraf geborgd.

Daarmee weerspiegelt JamOps in feite hoe JAM-IT naar softwareontwikkeling kijkt: gestructureerd, transparant en met oog voor de lange termijn.