Legacy modernisering — Oude systemen vernieuwen

Legacy modernisering zonder dat je bedrijf stilvalt: van monoliet naar microservices, stack-upgrades en cloud-native herarchitectuur. Vanaf € 45 per uur.

Wat je krijgt

Legacy modernisering van oude systemen die traag, riskant of duur zijn om aan te passen: monolieten opsplitsen in services, verouderde .NET-, Java- of PHP-stacks upgraden en stap voor stap naar de cloud verhuizen, zodat je bedrijf ondertussen gewoon blijft draaien.

Opleveringen

  • Analyse van het legacysysteem en risicokaart
  • Doelarchitectuur en migratieplan
  • Stapsgewijze herbouw (strangler pattern)
  • Datamigratie met validatie
  • Geautomatiseerde tests rond kritieke processen

Technologieën die we gebruiken

  • .NET
  • Java
  • PHP
  • Node.js
  • Microservices
  • Docker
  • Kubernetes
  • PostgreSQL
  • AWS

Typische opdrachten

2–4 weken

Moderniseringsanalyse

Wat te behouden, te refactoren of te vervangen, met kosten en risico’s.

2–4 maanden

Stack-upgrade

Overstap naar ondersteunde versies van framework en runtime.

4–9 maanden

Van monoliet naar services

Geleidelijk modules afsplitsen achter stabiele interfaces.

Zo verloopt een legacy-moderniseringsproject bij ons

We veranderen oude software terwijl die klanten blijft bedienen. Elke stap hieronder eindigt met iets dat in productie draait, niet met een belofte over een toekomstige herbouw.

  1. 01

    Het systeem in kaart brengen zoals het echt werkt

    We volgen requests door de code, lezen het databaseschema en zetten de geplande cron-taken, koppelingen en rapporten op een rij waarop finance of operations steunt. We kijken ook welke modules het vaakst veranderen. Je krijgt een systeemkaart met per module een oordeel, behouden, refactoren of vervangen, en kiest de eerste slice om te moderniseren.

  2. 02

    Huidig gedrag vastleggen met tests

    Voordat we een regel wijzigen, schrijven we characterisation tests rond de flows die geld opleveren of juridisch gewicht hebben: facturatie, prijsregels, rechten. Waar code niet los te testen is, nemen we productieverkeer op en vergelijken we de uitkomsten. Vanaf dan duiken regressies op in CI in plaats van in supporttickets, en het team tekent de nulmeting af.

  3. 03

    Een naad vóór de oude code leggen

    Een routeringslaag, API-facade of anti-corruption layer komt tussen de aanroepers en de legacy-module, zodat oude en nieuwe implementaties naast elkaar kunnen bestaan. Feature flags bepalen welke van de twee een bepaalde klant bedient. De beslissing in deze stap is de volgorde waarin we onderdelen loshalen, gerangschikt op bedrijfswaarde en op hoe verweven elke module is.

  4. 04

    Eén slice tegelijk vervangen

    Elke slice wordt herbouwd op een ondersteunde stack, bijvoorbeeld actueel .NET in plaats van .NET Framework, of een TypeScript-service in plaats van een PHP-module. Hij draait in shadow mode naast de oude code, de uitkomsten worden vergeleken en klanten gaan in groepen over. De afgedankte code van die slice wordt verwijderd, niet voor altijd als vangnet bewaard.

  5. 05

    De restanten uitfaseren en overdragen

    Zodra de laatste aanroeper een legacy-component niet meer gebruikt, verwijderen we die samen met zijn tabellen, geplande taken en servers, en werken we de runbooks bij. Je team krijgt architecture decision records, een routine om dependencies actueel te houden en een schriftelijke lijst met de schuld die we bewust lieten staan, zodat het systeem niet terugzakt naar waar het begon.

Wat bepaalt de kosten van legacy modernisering?

Modernisering rekenen we af per engineeruur tegen € 45–65, of als vast squad vanaf € 15.000 per maand wanneer het programma over meerdere kwartalen loopt. De factoren hieronder bepalen hoeveel uren het kost.

Hoeveel gedrag nergens is opgeschreven
Bedrijfsregels die verstopt zitten in stored procedures, databasetriggers en enorme classes moeten eerst worden gevonden voordat ze behouden kunnen blijven, en elke regel die laat opduikt, betekent herstelwerk. Vroege sessies met de mensen die het systeem dagelijks gebruiken, zijn de goedkoopste manier om ze boven water te krijgen.
Testdekking op dag één
Een codebase zonder geautomatiseerde tests heeft een vangnet nodig voordat het refactoren begint, en dat vangnet bouwen is echt werk. Systemen die al tests rond facturatie en toegangsbeheer hebben, gaan sneller. Eerst investeren in characterisation tests verlaagt de kosten van elke slice die volgt.
Verwevenheid via de database
Lezen en schrijven veel modules in dezelfde tabellen, dan kan geen enkele slice verhuizen voordat het eigenaarschap van de data is ontward. Gedeelde schema’s, joins over modules heen en logica in de database zelf zijn vaak de grootste losse post in de schatting. Het eigenaarschap tabel voor tabel splitsen houdt het werk stapsgewijs.
Koppelingen en bestandsuitwisseling
Oude systemen praten vaak met partners via SFTP-mappen, bestanden met vaste veldlengtes, SOAP-endpoints of directe databaselinks. Elk daarvan moet tijdens de overgang blijven werken, vaak met een adapter ertussen. Een volledige lijst met koppelingen bij de start voorkomt dure verrassingen halverwege.
Oud en nieuw naast elkaar draaien
Shadow runs, dubbel schrijven en feature flags kosten moeite en wat tijdelijke infrastructuur, maar ze maken een rollback mogelijk. De overlap blijft kort als klanten slice voor slice in groepen overgaan, in plaats van te wachten tot het hele systeem herbouwd is.

Vragen voor een partner in legacy modernisering

Moderniseringsprojecten mislukken zelden op codekwaliteit. Ze mislukken op de volgorde, en op gedrag dat niemand heeft gedocumenteerd. Deze vragen toetsen een leverancier op beide.

Welk deel zouden jullie als eerste moderniseren, en waarom juist dat?
Een goed antwoord koppelt de eerste slice aan een concrete pijn, zoals trage releases of een component zonder ondersteuning van de leverancier, en houdt hem klein genoeg om snel productie te halen. Een leverancier wiens eerste oplevering een plan voor een volledige herbouw is, heeft niet goed genoeg gekeken.
Hoe leggen jullie gedrag vast dat niet gedocumenteerd is?
Zoek naar characterisation tests, opgenomen verkeer, vergelijking van oude en nieuwe uitkomsten naast elkaar en gestructureerde sessies met gebruikers die het systeem al lang kennen. Alleen de code lezen mist regels die in configuratietabellen, geplande taken en handmatige omwegen van medewerkers zitten.
Hoe draaien we een slice terug die zich misdraagt?
Het antwoord hoort het mechanisme te noemen, zoals een feature flag, een routeringsschakelaar of het oude pad een vaste periode warm houden, en uit te leggen hoe data die de nieuwe code heeft geschreven achteraf wordt afgestemd. ‘We testen grondig’ is geen rollbackplan.
Wat gebeurt er met het datamodel?
De code moderniseren en een verknoopt schema laten staan, verplaatst het probleem alleen. Vraag hoe het eigenaarschap van tabellen wordt verdeeld, hoe schemamigraties draaien zonder drukke productietabellen te vergrendelen en hoe rapporten op de oude structuur blijven werken.
Wanneer gaat het oude systeem uit?
Modernisering betaalt zich pas terug als legacy-componenten echt verdwijnen. Een geloofwaardige leverancier stelt per component criteria voor uitfasering op en begroot tijd voor het verwijderen van oude code, batchscripts en servers, in plaats van je met twee systemen te laten zitten.

Waarom bedrijven voor elitics kiezen

De vragen die je juridische, security- en financeteams gaan stellen, beantwoord nog voor de eerste regel code.

Intellectueel eigendom
De NDA en de overdracht van IP worden getekend voordat het werk begint. Alle code, ontwerpen en documentatie zijn van jou.
Jouw omgeving
Engineers werken in je eigen repositories, ticketsystemen en communicatietools, volgens jouw toegangsbeleid.
Kwaliteitscontrole
Code review bij elke wijziging, en geautomatiseerde tests en CI/CD in elk project.
Inzicht
Wekelijkse sprintdemo’s en voortgangsrapportages, met een vaste lead die verantwoordelijk is voor de oplevering.
Continuïteit
Past een engineer niet goed bij je team, dan vervangen we hem of haar zonder extra kosten.
Flexibiliteit
Schaal het team per maand op of af wanneer je roadmap verandert.

Veelgestelde vragen

Moeten we alles herschrijven?

Zelden. Meestal vervangen we het systeem stukje bij beetje achter de bestaande interfaces, zodat de waarde vroeg komt en het risico laag blijft.

Is er downtime?

We plannen migraties zo dat die er niet is, met parallelle runs, feature flags en gefaseerde datamigratie met mogelijkheden om terug te draaien.

Kunnen jullie werken met oude, ongedocumenteerde code?

Ja. We brengen eerst het systeem in kaart en voegen tests toe rond kritiek gedrag voordat we iets veranderen.

Is legacy modernisering hetzelfde als cloudmigratie?

Nee. Modernisering verandert de applicatie zelf: code, framework, architectuur en datamodel. Cloudmigratie verhuist workloads naar een andere hostingomgeving, soms zonder de code aan te raken. De twee komen vaak samen, maar een gemoderniseerd systeem kan op je eigen servers blijven, en een gemigreerd systeem kan onderhuids nog steeds legacy zijn. We bepalen de scope apart, zodat elk budget helder blijft.

Kan modernisering samengaan met werk aan nieuwe functies?

Ja, en meestal hoort dat ook. We spreken af hoe de capaciteit wordt verdeeld tussen moderniseringsslices en roadmapfuncties, en leiden nieuwe functies waar mogelijk naar de delen die al gemoderniseerd zijn, zodat niets twee keer wordt gebouwd. Product owners zien beide stromen op één bord en kunnen de verhouding bij elke sprintplanning bijstellen.

Hoe begroten we legacy modernisering?

Begroot per fase in plaats van voor het hele programma in één keer. Het moderniseringsonderzoek duurt twee tot vier weken en eindigt met een plan in volgorde en een schatting per slice. Daarna loopt het werk tegen € 45–65 per engineeruur of met een vast squad vanaf € 15.000 per maand, en kun je tussen slices pauzeren zonder te verliezen wat al in productie staat.

Laten we bouwen wat hierna komt.

Vertel ons wat je wilt bouwen of opschalen. Binnen 24 uur ontvang je een voorstel met een inschatting.

Of mail ons direct

hello@elitics.io+383 49 171 069

Dukagjini Center, Prishtina, Kosovo