AI-compute voor Nederlandse SaaS: drie paden vergeleken

Het is dinsdagochtend in Utrecht. Je runt een B2B SaaS met €4,2M ARR, je inference-rekening van vorige maand was €41.000, en iemand in je engineering-Slack heeft net een link gedropt naar de HN-thread over de AI Compute Extensions-spec. Die thread is 380 reacties diep. De helft zegt dat per-token billing een val is en dat je een Llama-derivaat moet self-hosten op een bak in Falkenstein. De andere helft zegt dat dat fantasie is en dat je een enterprise contract met Anthropic moet tekenen voordat de quota strakker worden. Je CTO wil donderdag je oordeel.

Deze beslissing kent drie paden, en één weekend in december dat er twee van breekt. Dit is de methode die we met klanten gebruiken om te scoren.

De drie paden, zonder marketingverf

Per-token API. Je blijft doen wat je doet — calls naar OpenAI, Anthropic, Google of een mix daarvan, je krijgt een factuur per input- en output-token, en je CFO ziet één regel die lineair meeschaalt met gebruik.

Enterprise contract. Je tekent voor twaalf of vierentwintig maanden minimumbesteding bij een frontier-model vendor. In ruil krijg je gegarandeerde throughput, een zero-data-retention rider, EU-routing en een vaste technical account manager die op zaterdag z'n mail beantwoordt.

Self-host. Je huurt een GPU-bak, haalt een Llama-, Mistral- of DeepSeek-checkpoint binnen, zet 'm achter vLLM of TGI, en hebt de hele stack in eigen beheer, van kernel tot inference-endpoint. De cloud-egress-regel op je factuur gaat naar nul. Je on-call rotatie krijgt er één pageable service bij.

Op het whiteboard ziet elk pad er aantrekkelijk uit. In productie is elk pad bruut. De methode hieronder is hoe we kiezen, gegeven een specifiek omzet- en call-volumeprofiel.

Het kostenplaatje bij 12,4M calls per maand

Ronde getallen, want de echte hangen af van je prompt-vorm. Als kader bruikbaar. Bij 12,4M calls per maand met gemiddeld 600 input-tokens en 250 output-tokens — typisch voor een inbox-triage of facturen-classifier workload — verstook je ongeveer 7,4B input- en 3,1B output-tokens per maand.

Tegen Sonnet-class lijstprijs (~$3/MTok in, $15/MTok uit, op moment van schrijven) zit je op ongeveer $22k plus $46k, dus grofweg $68k per maand, ofwel €63k. Een Haiku-class model brengt dat voor veel van die calls met 4–5x omlaag. GPT-4o-mini en Gemini Flash zitten in dezelfde buurt.

Een enterprise commit levert je doorgaans 15–35% korting op lijstprijs op, plus throughput-garanties en een EU-rider. Reken op €45k per maand met een minimum van 12 maanden: €540k vastgelegd.

Zelf een 70B-class open-weights model hosten op één GPU-bak die je piek-QPS aankan — denk aan een Hetzner GEX of een Lambda Labs node met één of twee H100's — kost je ergens tussen €1.800 en €4.500 per maand aan hardware-huur, plus je ops-tijd. Past je model erop? Dan is het echt goedkoper. Past het niet? Dan koop je een tweede bak en een load balancer, en gaat het spreadsheet er heel anders uitzien.

Waar de bytes daadwerkelijk staan

De AVG-vraag — bewaakt door de Autoriteit Persoonsgegevens — is niet "is de vendor compliant". Elke serieuze vendor heeft een DPA. De vraag die je FG op papier moet beantwoorden: waar wordt de prompt fysiek uitgevoerd, wie kan die via een gerechtelijk bevel opvragen, en wat is je contractuele verhaal als een sub-processor wijzigt?

Per-token API zonder zero-retention rider: prompts en completions worden verwerkt in de regio waar je account naartoe wordt geroute, mogen kort worden bewaard voor abuse-monitoring, en je hebt een standaard DPA. Verdedigbaar voor de meeste B2B-workloads, lastig te verdedigen zodra je gezondheidsdata, juridische correspondentie of loondetails verwerkt.

Enterprise contract met EU-routing en zero retention: bytes draaien in Frankfurt of Dublin, niets wordt bewaard, sub-processors staan vastgepind in het contract. De commerciële voorwaarden van Anthropic en het equivalent van OpenAI en Google ondersteunen deze vorm allebei — je moet erom vragen, niet aanvinken in een checkbox.

Self-host op Hetzner in Falkenstein of Helsinki: bytes verlaten de EU nooit, onder jou bestaat geen sub-processor, jij bent zowel controller als processor. Maximaal verdedigbaar. Ook maximaal van jou.

De kerstweekend-test

Dit is de test die de meeste self-hosting plannen voor bedrijven onder €16M sloopt. We draaien 'm als gedachte-experiment met elke klant die de overstap overweegt.

Het is 27 december. DeepSeek brengt een nieuw open-weights model uit dat acht punten beter scoort dan je huidige checkpoint op de evals waar je klanten om geven. De CTO van een concurrent heeft het zondagavond al ingewisseld. Drie van je grootste klanten zitten midden in een pilot. Je ML-engineer is bij familie in Brabant met WhatsApp op niet-storen.

Wie haalt de weights binnen, herschrijft de prompts, draait je eval-set opnieuw, redeployt de inference server en kijkt naar de error rate op het dashboard?

Op het API-pad: niemand. Je leest de release notes in januari, draait een eval in week 2, switcht in week 3. Je on-call rotatie wordt nooit gepaged.

Op het enterprise contract: je TAM mailt je de migration guide. Jij dient een ticket in. Zelfde januari-timeline, minder druk.

Op self-host: jij. Of het is diezelfde ene engineer die de bak heeft opgezet, en die je je niet kan veroorloven te verliezen. De opportunity cost van niet upgraden is reëel — zo nam je concurrent immers de deal — maar de prijs van upgraden is het vakantieweekend van één engineer, telkens als de open-source frontier opschuift.

Een score-matrix om te kopiëren

Dit is de matrix die we met klanten doorlopen. Geef elk pad een score 0–5 per as, weeg op wat je business echt belangrijk vindt, tel op.

axes:
  cost_at_12_4M_calls:    # €/month at projected volume
    weight: 3
  cost_at_3x_spike:       # what happens when traffic triples on a Tuesday
    weight: 2
  avg_defensibility:      # would your DPO sign this without notes?
    weight: 4
  time_to_model_swap:     # hours from new SOTA released to deployed
    weight: 3
  ops_burden:             # incremental on-call surface area
    weight: 4
  vendor_lock:            # cost in weeks to swap providers
    weight: 2
  capability_ceiling:     # can you serve your hardest workload?
    weight: 3

paths:
  per_token_api:
    cost_at_12_4M_calls: 2
    cost_at_3x_spike: 5
    avg_defensibility: 3
    time_to_model_swap: 5
    ops_burden: 5
    vendor_lock: 4
    capability_ceiling: 5

  enterprise_contract:
    cost_at_12_4M_calls: 3
    cost_at_3x_spike: 4
    avg_defensibility: 5
    time_to_model_swap: 4
    ops_burden: 5
    vendor_lock: 2
    capability_ceiling: 5

  self_host_llama:
    cost_at_12_4M_calls: 5
    cost_at_3x_spike: 1
    avg_defensibility: 5
    time_to_model_swap: 2
    ops_burden: 1
    vendor_lock: 5
    capability_ceiling: 3

Voor het founder-profiel uit de vraag — Nederlandse B2B SaaS onder €16M ARR, 12,4M calls per maand, AVG-gevoelig maar niet op zorg- of juridisch niveau — landt deze matrix doorgaans op enterprise contract als eerste, per-token API als tweede, self-host als derde. Draai de gewichten om voor een gereguleerde-data omgeving en self-host klimt. Draai ze om voor een bedrijf op €1M ARR dat nog product-market fit zoekt, en per-token API wint zonder twijfel.

De ACE-spec verandert één variabele, niet het antwoord

Waarom de HN-thread over de ACE-spec ertoe doet: als compute-quota-standaarden echt en portable worden, gaat de vendor-lock score op het enterprise-pad van een 2 naar een 3 of 4. Je kan een committed spend midden in het contract verplaatsen naar een andere provider, zonder je inference-laag te herschrijven. Dat is significant. Het maakt self-hosting niet goedkoper, niet sneller te patchen en niet makkelijker te draaien. Het maakt een enterprise contract simpelweg minder eng om te tekenen. Laat één HN-thread je niet wegtrekken uit een beslissing waar je kostenmodel en je FG het al over eens zijn.

Wanneer self-hosting wel het juiste antwoord is

Drie signalen zeggen self-host, ongeacht je bedrijfsgrootte:

1. Je workload is smal en stabiel. Je doet één ding — classificeren, extraheren, samenvatten — en de prompt is in zes maanden niet veranderd. Eén keer fine-tunen, eeuwig serveren.
2. Je data is echt radioactief. Patiëntendossiers, ruwe juridische discovery, broncode van klanten onder zware NDA. Het AVG-gesprek gaat niet over "verdedigbaar", het gaat over "niet onderhandelbaar".
3. Je hebt al een ML-engineer die dit wil doen en het eerder heeft gedaan. Niet "zou het kunnen leren". Heeft het gedaan. Twee keer.

Twee van de drie: misschien. Eén: niet doen.

Onze default voor dit profiel

Voor een Nederlandse B2B SaaS onder €16M ARR met 12,4M calls per maand zetten we klanten standaard op een 12-maanden enterprise contract met EU-routing en zero-retention, plus een klein fine-tuned open-source model op een Hetzner-bak voor die 5–10% van het verkeer waar je een smalle, stabiele, AVG-gevoelige workload hebt geïdentificeerd. Je pakt het kostenvoordeel daar waar het echt loont, en je hebt ops-dekking daar waar het vakantierisico zit.

Toen we de inbox-triage agent bouwden voor een Rotterdamse logistieke klant met zo'n 9M calls per maand, landden we op precies die hybride: een tuned 8B-model op eigen hardware voor de smalle extractor die referentienummers van gescande vrachtbrieven plukt, en al het andere op de frontier API onder een enterprise rider. De langere uitschrijving van hoe die splitsing zich in productie houdt, staat bij ons AI-agents werk.

De vijf-minuten versie: pak de factuur van vorige maand, deel die door je aantal calls per maand voor je echte kosten-per-call, en stel je FG dan één vraag — "zou je deze DPA vandaag zonder opmerkingen tekenen?" Is het antwoord ja en de prijs per call onder €0,006, dan hoef je dit kwartaal geen beslissing te nemen.