"We denken dat het systeem te traag is."

Dat was de opening van een gesprek dat ik onlangs had. En eerlijk gezegd snap ik die opening volkomen. Als iets niet lekker loopt, zoek je het al snel in de techniek.

Een trage server. Een verouderd framework. Een database die opnieuw geïndexeerd moet worden. Iets concreets dat je kunt aanwijzen en repareren.

Alleen, na een uur praten werd duidelijk dat het systeem helemaal niet traag was. Het deed precies wat het moest doen. Wat ontbrak, was iemand die ooit had gezegd: wacht even, klopt dit nog wel als geheel?

In deze blog leg ik uit waarom trage software bijna nooit een snelheidsprobleem is. En vooral: wat je in plaats daarvan moet doen voordat je gaat doorbouwen, vervangen of opnieuw beginnen.

Wat is het verschil tussen technisch traag en gevoelsmatig traag?

Er zijn twee soorten traagheid in software. Ze worden vaak door elkaar gehaald, maar ze vragen om een totaal andere oplossing.

Wanneer is software technisch traag?

  • Symptoom: schermen die seconden nodig hebben om te reageren, software die hangt, processen die uitvallen.
  • Oorzaak: verouderde infrastructuur, trage databasevragen, te weinig rekenkracht.
  • Oplossing: slimmer tijdelijk opslaan van gegevens, snellere databasevragen, meer servercapaciteit.
  • Investering: eenmalig technisch werk.

Wanneer voelt software alleen maar traag?

  • Symptoom: software reageert snel, maar werken erin voelt zwaar.
  • Oorzaak: te veel functies, onlogische workflows, vergeten koppelingen, processen die niet meer kloppen.
  • Oplossing: architectuur opnieuw bekijken en snoeien.
  • Investering: eerst denken, dan pas bouwen.

Snellere techniek onder een onlogisch proces is geen oplossing. Dan werken mensen sneller in een systeem dat niet meer klopt. Het wordt er zelfs erger van. Eerst moet het proces weer kloppen. Lees hoe je bedrijfsprocessen optimaliseert.

Hoe wordt software ongemerkt zwaar?

Vrijwel elke organisatie die ik spreek heeft hetzelfde patroon doorlopen. Het systeem werd ooit gebouwd voor een duidelijk doel. De eerste versie was strak, overzichtelijk, deed wat het moest doen.

En toen begon het leven.

Een nieuwe klant met een afwijkende workflow. Een verkoopkanaal dat erbij kwam. Een wettelijke wijziging die een extra veld vroeg. Een collega die even snel een knop wilde voor een uitzondering die maar één keer per maand voorkomt. Een losse koppeling om een proces te automatiseren waar iedereen achter stond. Een integratie met een tool die inmiddels niet meer gebruikt wordt, maar waarvan de koppeling nog wel actief is.

Stuk voor stuk waren het redelijke beslissingen. Op het moment zelf logisch, soms zelfs noodzakelijk. Maar ze zijn nooit als geheel opnieuw bekeken.

Niemand heeft ooit een dag genomen om te zeggen: als we dit systeem vandaag opnieuw zouden bouwen, wat zou er dan eigenlijk in horen?

Het resultaat: software die technisch prima draait, maar in gebruik aanvoelt als een kast die al twintig jaar niet is opgeruimd. Je weet dat alles wat je zoekt erin zit. Je weet alleen niet meer waar. Voor veel mkb-bedrijven is dit het moment waarop verouderde of legacy software vervangen ineens op de agenda komt. Niet omdat de techniek het opgeeft, maar omdat het werken erin niet meer te doen is.

Waarom doorbouwen het probleem meestal vergroot

Op het moment dat een team dit doorheeft, zie ik vaak dezelfde reflex. Er moet iets nieuws komen.

Een nieuwe module, een nieuwe tool, een nieuw platform. Iets fris, iets modern, iets dat het oude eindelijk overbodig maakt.

Maar dan zie je iets gebeuren wat niemand voorzag. Het nieuwe systeem moet integreren met het oude. Mensen moeten beide kennen. Data moet ergens gesynchroniseerd worden.

En binnen een jaar heb je niet één zwaar systeem, maar twee. Met een koppeling ertussen die ook weer onderhoud vraagt.

Daar komt nog iets bij. In de meeste teams die ik tegenkom, begrijpt het grootste deel van de mensen de huidige architectuur niet eens volledig. Niet omdat ze dom zijn. Wel omdat de architectuur in de loop der jaren impliciet is geworden. Hij staat niet meer op papier. Hij zit in de hoofden van een paar mensen en in de code zelf.

Doorbouwen op iets wat je niet helemaal begrijpt is geen ontwikkeling. Het is hopen dat je geluk hebt.

Welke vragen stel je voordat je iets nieuws bouwt?

Het moment waarop ik in een gesprek meestal zeg "laten we even niets bouwen", is precies hier. Niet omdat ik tegen ontwikkeling ben. Sterker nog, maatwerk software laten maken is precies wat we doen.

Maar bouwen zonder eerst de architectuur scherp te krijgen, is geld uitgeven aan een probleem dat je niet hebt benoemd.

Wat we wél doen, zijn vier fundamentele vragen stellen.

  1. Wat is de kern van wat dit systeem moet ondersteunen? Niet wat het allemaal kan, maar waar het écht voor bedoeld is. Vaak komt daar een verrassend kort antwoord uit.
  2. Welke processen zijn nog actueel? Veel functies in oudere systemen ondersteunen processen die intern allang anders verlopen. De software is achtergebleven, het bedrijf is doorgegaan.
  3. Wat zou je opnieuw zo bouwen en wat niet? Met deze vraag komt het gesprek meestal op gang. Hij dwingt het team om expliciet te maken wat de kern is en wat in de loop der jaren als ballast is meegenomen.
  4. Waar zit het echte gebruikersongemak? Soms is dat een traag scherm. Vaker is het een proces dat in zes klikken kan wat ooit één klik was, omdat er onderweg dingen zijn aangezet die nooit meer zijn uitgezet.

Pas als die vragen beantwoord zijn, weet je waar je écht naartoe wilt. En dan blijkt vaak dat de oplossing niet nieuw bouwen is, maar snoeien. Soms wel een grondige modernisering. Maar bijna nooit het complete vervangingsproject waar het gesprek mee begon.

Wat doet een softwarearchitect dan precies?

Bij Prikr noemen we onszelf softwarearchitect en dit is precies waarom. Een ontwikkelaar bouwt wat je vraagt. Een goede architect vraagt eerst of je wel het juiste vraagt.

Dat klinkt misschien tegenstrijdig voor een softwarebureau. Wij verdienen geld met bouwen, dus waarom zouden we klanten weghouden van bouwen?

Het antwoord is simpel. Omdat we willen dat wat we bouwen, blijft werken. Voor jaren, niet voor maanden. En dat lukt alleen als de basis klopt.

Een goede architectuurfase kan je geld besparen. Niet omdat we minder bouwen, maar omdat we het juiste bouwen. Veel verzoeken om nieuwe functies blijken bij doorvragen niet nodig. Of ze worden overbodig zodra een ander stuk wél goed wordt aangepakt.