Dienst · Web-ontwikkeling

Applicatiebeheer uitbesteden aan een ontwikkelpartner.

Uw productie-applicatie blijft draaien, ook als de oorspronkelijke ontwikkelaars al lang weg zijn. Wij nemen het 2e- en 3e-lijns beheer over: incidenten, security-updates, kleine wijzigingen en database-monitoring. Voorspelbare maandprijs, vaste contactpersonen, transparante rapportage.

2e/3e-lijnsSecurity-updatesDatabase-monitoringSLA op maat

Beheer is geen bouw — andere ritme, andere kunde.

Een applicatie die in productie staat heeft heel andere zorgen dan een applicatie die nog gebouwd wordt. De vraag is niet "wat bouwen we als volgende feature" maar "wat draait er, hoe stabiel, en wat is er over een jaar nodig om dat zo te houden". Dat vraagt om iemand die het systeem doorgrondt zonder elke week iets nieuws te willen toevoegen.

Veel organisaties komen bij ons aan met een werkende applicatie maar zonder vast team eromheen. De bouwer is verder getrokken, de eigen developer is vertrokken, of er was nooit interne capaciteit. Wij nemen de technische verantwoordelijkheid over — voor applicaties die wijzelf hebben gebouwd én voor applicaties van derden waar de documentatie nog leesbaar is.

Onze focus ligt op het 2e- en 3e-lijns technische beheer: incidenten die voorbij de helpdesk komen, RFC's met impact, security-patches op dependencies, performance-tuning op databases, en het soort kleine wijzigingen waar uw business-team niet op kan wachten. Met daarbij heldere afspraken over wat we wel en niet doen — zie de paragraaf verderop over de vier vormen van applicatiebeheer.

We werken doorgaans samen met uw eigen functioneel beheerder of business-owner, en met de partij die uw infrastructuur draait. Een goede beheerrelatie is een driehoek: de business bepaalt het wat, wij doen de technische uitvoering op de applicatie zelf, en de cloud-provider of MSP zorgt voor de onderliggende infrastructuur. Wij willen geen schaduw-IT zijn maar een transparante partner — u krijgt toegang tot ons ticket-systeem, de monitoring-dashboards en de change-log.

Drie SLA-modellen die u kunt afnemen.

Niet elke applicatie heeft 24/7 monitoring nodig, en niet elke business-flow accepteert acht uur stilstand. We kiezen samen het model dat past bij de impact van de applicatie op uw organisatie.

Lichtgewicht · best-effort

Best-effort beheer

Voor toepassingen waar planbare doorlooptijd voldoende is. We pakken incidenten op binnen normale kantoortijden, doen periodiek onderhoud en security-updates volgens een vast ritme, en rapporteren per kwartaal. Geen piket, geen harde responstijd — wel een vaste contactpersoon en realistische verwachtingen.

KantoortijdenKwartaal-rapportVaste contactpersoonMaandbudget
Standaard · response-time-SLA

SLA met response-time

De meest gekozen variant. Vier prioriteitsniveaus, voor elke prioriteit een afgesproken reactietijd en een doel-doorlooptijd. Maandelijkse service-review waarin we doorlooptijden, incidenten en achterstallig onderhoud bespreken. Service-credits bij structurele afwijking — geen boete-mentaliteit, wel duidelijke meting.

P1-P4 prioriteitenService-creditsMaand-reviewKantoor + bereikbaarheid
Zwaargewicht · 24/7 met piket

Kritische applicatie 24/7

Voor business-kritische applicaties die ook 's nachts en in het weekend gemonitord moeten worden. Piketdienst, escalatieprotocol, monitoring met geautomatiseerde alerts. We adviseren deze variant alleen als de impact-analyse uitwijst dat het ook echt nodig is — vaak is een hybride vorm (kantoor + on-call buiten kantoor) een betere kostenkeuze.

24/7 piketAlert-monitoringEscalatieprotocolRunbook-gestuurd

Wat we concreet doen aan uw applicatie.

Beheer is niet alleen "wachten tot er iets stuk gaat". Een goed beheercontract bevat een mix van reactief werk (incidenten oplossen), proactief werk (vóór zijn dat iets stuk gaat) en planbaar werk (klein onderhoud, kleine wijzigingen).

Hieronder de werkzaamheden die we standaard meenemen in een beheercontract. Combinaties zijn mogelijk: u kunt bijvoorbeeld alleen security-updates en database-monitoring afnemen als u zelf een ontwikkelaar heeft voor de rest.

  • Incident- en RFC-afhandelingStoringen oplossen, bugs fixen, en kleine wijzigingen doorvoeren via een lichte change-procedure. Eindgebruikers melden via uw eigen helpdesk; wij pikken de 2e en 3e lijn op.
  • Security-patches en dependency-updatesCVE-monitoring op uw stack, urgente patches direct doorvoeren, niet-kritieke updates in een vast cadans. Inclusief framework- en library-upgrades als die security-relevant zijn.
  • Database-monitoring en performance-tuningQuery-performance, indexen, opslaggroei, connectie-pool gezondheid. Slow-query logs maandelijks doorlopen, problemen oplossen voordat ze de gebruiker raken.
  • Backup-strategie en DR-testBackup-rotatie en retentie-beleid afspreken, en jaarlijks daadwerkelijk een restore uitvoeren op een staging-omgeving. Een backup die nooit getest is, is geen backup.
  • Versie-upgrades van framework en OSMajor-versies van uw framework, runtime en OS doorvoeren voor end-of-life. We plannen dit ruim van tevoren in zodat het niet onder tijdsdruk hoeft.
  • Compliance-rapportageRapportages voor AVG, BIO en ISO 27001-trajecten waar relevant: change-log, security-incidenten, toegangslog, patch-status. Klaar voor uw auditor.
  • Documentatie-onderhoudRunbooks, architectuurschets, ADR's en operationele handleidingen actueel houden. Zodat de volgende beheerder (wij of een opvolger) niet vanaf nul begint.
  • Klein-onderhoud en configuratieTekstwijzigingen, instellingen, e-mailtemplates, koppelingsparameters — de kleine wijzigingen waar uw business-team om vraagt en die niet door een functioneel beheerder zelf in de UI gedaan kunnen worden.

Vier vormen van applicatiebeheer — wat doen wij wel en niet.

Het BiSL- en ASL-frame onderscheidt vier rollen rond een applicatie. Het helpt om vooraf duidelijk te zijn welke rol u bij ons belegt, en welke u zelf of bij een andere partij houdt.

Wij doen dit

Applicatiebeheer (technisch-functioneel)

Technische aanpassingen aan de applicatie, configuratie, integraties met andere systemen, bug-fixes en kleine functionele wijzigingen. Dit is onze kerntaak in een beheercontract.

Vaak intern

Functioneel beheer (business-zijde)

Process-eigenaarschap, releaseplanning vanuit business-perspectief, prioriteiten stellen, gebruikersondersteuning bij hoe-vragen. Past beter bij uw eigen organisatie omdat het over uw werkproces gaat.

Cloud-provider of MSP

Technisch beheer (infrastructuur)

Servers, netwerken, OS-patches op infrastructuur-niveau, fysieke databases. Op moderne stacks ligt dit grotendeels bij uw cloud-provider (AWS, GCP, Azure) of bij een MSP. We werken graag samen met die partij.

Helpdesk of intern

Service-desk / eerste lijn

Gebruikersvragen, wachtwoord-resets, telefonisch contact, ticketregistratie. Wij zijn geen eerste-lijns helpdesk. Vaak doet uw eigen IT-afdeling dit, of een gespecialiseerde service-desk-partij.

Hoe een overname van het beheer eruit ziet.

1

Intake en risico-scan

Een gesprek over de applicatie: stack, business-impact, huidige situatie, openstaande issues en geplande wijzigingen. We bekijken codebase en infrastructuur op afstand om in te schatten wat de overname concreet inhoudt.

2

Transitiefase met kennisoverdracht

Als er nog een vorige beheerder of bouwer is, plannen we een overdracht. Geen overdracht beschikbaar? Dan reverse-engineeren we de applicatie aan de hand van code en documentatie, en schrijven we de runbooks zelf. Aan het eind van de transitiefase is helder welk werk in scope zit.

3

SLA en contractvorm afspreken

We kiezen het SLA-model dat past bij de impact van de applicatie. Best-effort, response-time-SLA, of 24/7-piket — of een hybride vorm. Ook de scope: alleen wij, of in een gedeelde verantwoordelijkheid met uw interne team of een andere partij.

4

Doorlopend beheer met service-review

Vanaf moment één: incidenten registreren, RFC's afhandelen, monitoring inrichten. Maandelijks of per kwartaal een service-review waarin we doorlooptijden, achterstallig onderhoud, en doorontwikkelopties bespreken. Geen lock-in: opzegtermijn redelijk en transitie-uit ook netjes geregeld.

Voordelen ten opzichte van een eigen developer.

Een eigen ontwikkelaar in dienst is geweldig — tot het moment dat die op vakantie gaat, ziek wordt, of vertrekt. Een beheercontract bij een ontwikkelpartner werkt anders en heeft op een aantal punten een sterk voordeel.

Continuïteit

Geen kennis op één persoon

Bij ons werken meerdere mensen aan uw applicatie. Bij vakantie, ziekte of vertrek loopt het beheer door — geen paniek-gesprek met de IT-manager omdat de enige developer net is opgezegd.

Specialistische kennis

Toegang tot specialisten

Database-tuning, security-audit, performance-optimalisatie: deze specialisaties hebben we in huis. Bij een eigen developer hangt het ervan af welke achtergrond die persoon toevallig heeft.

Schaalbaarheid

Capaciteit bij pieken

Een grote release, een security-incident of een onverwacht complex probleem vraagt soms om extra handen. Wij schalen op vanuit ons team — een eigen developer kan dat niet alleen aan.

Kostenbeheersing

Voorspelbaar maandbudget

Een vaste maandprijs in plaats van uurtje-factuurtje plus de werkgeverskosten en overhead van een eigen ontwikkelaar. Bij rustige maanden bouwen we geen achterstand op; bij drukke maanden geen onverwachte facturen.

Best-practices

Lessen uit andere klanten

Doordat we voor verschillende organisaties applicaties beheren, zien we patronen die een geïsoleerde developer mist. Een postgres-tuning die op de ene applicatie werkt, een dependency-strategie die ergens anders een security-incident voorkomen heeft — die kennis nemen we mee.

Eerlijk advies

We zeggen het als beheer niet meer loont

Als blijkt dat een applicatie zoveel achterstallig onderhoud heeft dat verder beheren weggegooid geld is, zeggen we dat. Liever een eerlijk gesprek over vervanging of modernisering dan jarenlang een patch-architectuur in stand houden.

Veelgestelde vragen.

De vragen die we het vaakst krijgen voordat we een beheercontract afsluiten.

Wat is het verschil tussen functioneel beheer en applicatiebeheer uitbesteden?
Functioneel beheer gaat over de business-zijde van de applicatie: welke processen lopen erover, welke prioriteiten zet u, welke gebruikersondersteuning is er bij hoe-vragen. Dat past meestal bij uw eigen organisatie. Wat wij doen is technisch applicatiebeheer: bugs fixen, integraties onderhouden, security-patches doorvoeren, kleine wijzigingen in de code. De twee rollen werken nauw samen — uw functioneel beheerder bepaalt het wat, wij doen het hoe. Het uitbesteden van functioneel beheer raden we zelden aan; het uitbesteden van applicatiebeheer aan een ontwikkelpartner is juist een hele logische keuze.
Doen jullie ook beheer van applicaties die jullie zelf niet hebben gebouwd?
Ja, dat doen we regelmatig. Voorwaarden zijn dat de codebase op een gangbare moderne stack staat (PHP/Symfony, Node.js, .NET, Python, Java) en dat er minstens basale documentatie of leesbare code is. We doen altijd eerst een transitiefase waarin we de applicatie verkennen, runbooks schrijven en risico's in kaart brengen. Soms blijkt dan dat een legacy-applicatie aan vervanging toe is — daar zijn we eerlijk over. Lees ook onze pagina over legacy-software vervangen als uw applicatie aan het einde van de levensduur zit.
Welke SLA-vormen bieden jullie aan?
We werken met drie hoofdvarianten: best-effort (binnen kantoortijden, geen harde reactietijd), een response-time-SLA met vier prioriteitsklassen en service-credits, en 24/7 met piket voor business-kritische applicaties. Een hybride is ook mogelijk — bijvoorbeeld response-time-SLA tijdens kantoor en alleen alert-monitoring buiten kantoor. We adviseren altijd op basis van een korte impact-analyse: voor welke applicatie is welk niveau écht nodig.
Bieden jullie ook 24/7-piket voor kritische applicaties?
Ja, voor applicaties waar de business-impact 24/7-piket rechtvaardigt. We werken dan met een piketrooster, een geautomatiseerd alerting-systeem (Datadog, Grafana, Sentry of vergelijkbaar), en een escalatieprotocol. We adviseren deze variant alleen als de impact-analyse uitwijst dat het ook echt nodig is — voor veel applicaties is response-time tijdens kantoor en alert-monitoring 's nachts een betere prijs-kwaliteit-verhouding.
Hoe ziet de transitiefase eruit als we overstappen?
De transitiefase begint met een intake en risico-scan op de codebase en infrastructuur. Als er nog een vorige beheerder is, plannen we een directe kennisoverdracht. Is die er niet meer, dan reverse-engineeren we via code, documentatie en monitoring-data. We schrijven runbooks, leggen toegang en wachtwoorden vast, en zetten ons eigen alerting in. Tegen het einde van de transitie is er een duidelijk overzicht van wat we overnemen, welke risico's er liggen, en wat de eerste prioriteiten zijn. De duur hangt af van complexiteit en beschikbare documentatie — een paar sprints is typisch.
Wat bepaalt de kosten van een beheercontract?
De belangrijkste factoren zijn het SLA-niveau (24/7 is fors duurder dan kantoortijden), de omvang van het maand-budget aan klein-onderhoud, en de complexiteit van de stack en integraties. Een kleine applicatie op een moderne stack met weinig integraties is een ander gesprek dan een gegroeid platform met tien koppelingen en een eigen database-cluster. We werken met een vaste maandprijs zodat u niet voor verrassingen komt te staan — geen uurtje-factuurtje voor regulier werk.
Doen jullie ook database-monitoring en performance-tuning?
Ja, dat is een vast onderdeel van onze beheercontracten. We monitoren query-performance, indexgebruik, opslaggroei en connection-pool gezondheid. Op aanvraag doen we periodieke deep-dive sessies waarin we slow-query logs doorlopen, indexen herzien en zware queries herschrijven. Voor organisaties die alleen database-zorgen hebben en de rest zelf doen, kunnen we ook losse database-monitoring aanbieden.
Wat als we tijdens het beheer aan grotere doorontwikkeling toe zijn?
Beheer en doorontwikkeling zijn voor ons twee budgetten naast elkaar. Klein-onderhoud (uren of dagen werk) zit in het beheercontract; grotere features of nieuwe modules schatten we apart in als een mini-project. Soms wordt duidelijk dat de applicatie fundamenteel aan vervanging of modernisering toe is — dan adviseren we open over platform-modernisering of een traject richting een nieuw cloud-native platform. We blijven dan beheren tot het oude systeem netjes afscheid heeft genomen.

Praat met ons over uw applicatiebeheer.

Een vrijblijvend gesprek van een half uur. We vragen door op de stack, de business-impact en de huidige zorgen — en geven u richting over welke vorm van beheer past, ook als dat uiteindelijk niet bij ons is. Voor grotere enterprise-software trajecten denken we vanaf dag één in beheer-scenario's mee.

Edit Content