Mijn IT-leerroadmap voor 5 jaar — van sysadmin naar infrastructure engineer

Illustratie van een IT-leerroadmap voor vijf jaar

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

Linux. Windows. Netwerken. Security. Observability. Automatisering. Cloud. Kubernetes. AI.

Maar bovenal:

Inhoud

🧠 Leren systemen te begrijpen — niet alleen ze te bedienen.

Ik heb behoorlijk wat nagedacht over waar ik mijn IT-skills de komende jaren naartoe wil brengen.

Mijn professionele achtergrond geeft me al een vrij brede basis:

  • 🐧 Linux-systeembeheer
  • 📊 Monitoring
  • 🚨 Technisch eventmanagement
  • 📝 Logmanagement
  • 🌐 Netwerken
  • 🔐 Security

Mijn huidige professionele focus ligt steeds meer op Graylog en logmanagement.

Buiten het werk heb ik ook veel interesse in:

  • Windows Server
  • Active Directory
  • Docker
  • Kubernetes
  • Git
  • Automatisering
  • Besturingssystemen
  • AI

Ik heb ook een behoorlijk capabel homelab met drie fysieke servers en twee tower-pc’s.

De vraag is dus eigenlijk niet:

“Welke technologie moet ik nu leren?”

De veel interessantere vraag is:

“Wat voor engineer wil ik de komende vijf jaar worden?”


🎯 Het doel

Mijn langetermijndoel is niet om degene te worden die de meeste commando’s kent.

Het is niet om certificeringen te verzamelen als Pokémon.

En het is al helemaal niet om elke nieuwe technologie te leren die elke dinsdag op Hacker News verschijnt. 😄

Ik wil me ontwikkelen tot iemand die:

  • complexe infrastructuur begrijpt
  • infrastructuur ontwerpt
  • infrastructuur beheert
  • infrastructuur troubleshoot
  • infrastructuur automatiseert
  • infrastructuur beveiligt
  • infrastructuur monitort
  • afhankelijkheden begrijpt
  • storingen analyseert
  • architectuurbeslissingen neemt
  • technologiekeuzes beoordeelt
  • AI effectief inzet als engineeringtool

Met andere woorden:

🏗️ Infrastructure engineering

met een stevige basis in Linux, Windows, netwerken, security, observability, automatisering, cloud en cloud-native technologieën.


🧠 Het belangrijkste deel: hoe ik wil leren

Dit is het fundament van de hele roadmap.

Mijn manier van leren beweegt bewust weg van puur uit het hoofd leren.

Moderne infrastructuur is simpelweg te complex om elk commando, elke API-parameter en elke configuratieoptie te onthouden.

En eerlijk gezegd:

man systemctl
man kubectl
Get-Help
documentation
Google
ChatGPT
Claude

...exist for a reason. 😎

Dus wil ik één abstractielaag omhoog.

❌ De oude aanpak

Problem
   ↓
Remember command
   ↓
Run command
   ↓
Hope

✅ De aanpak die ik wil ontwikkelen

Problem
   ↓
Define the problem
   ↓
Understand the architecture
   ↓
Identify components
   ↓
Understand dependencies
   ↓
Collect evidence
   ↓
Form hypotheses
   ↓
Test hypotheses
   ↓
Find root cause
   ↓
Design solution
   ↓
Automate
   ↓
Document

Het eigenlijke commando wordt maar één onderdeel van het proces.

Het commando is een tool. Het begrip is de skill.


📐 Mijn leermodel: de 20 / 30 / 30 / 20-regel

Voor de grote onderwerpen in deze roadmap wil ik ongeveer deze verdeling:

AandeelFocus
20%Commando’s, syntax, tools en implementatiedetails
30%Architectuur, concepten, lagen en afhankelijkheden
30%Troubleshooting, faalscenario’s en praktijksituaties
20%Automatisering, AI-ondersteunde engineering en validatie

Dit is geen rigide wiskundige formule.

Het is een geheugensteun voor waar de nadruk moet liggen.

Als ik een onderwerp afrond met kennis van 200 commando’s maar niet kan uitleggen hoe het systeem werkt, heb ik waarschijnlijk het verkeerde geleerd.


🔬 De leercyclus

Elke belangrijke technologie moet dezelfde cyclus doorlopen.

1️⃣ Begrijpen

Wat is de technologie?

2️⃣ Modelleren

Hoe is de architectuur?

3️⃣ Bouwen

Uitrollen in het homelab.

4️⃣ Observeren

Het gedrag monitoren en bekijken.

5️⃣ Breken

Bewust storingen veroorzaken.

6️⃣ Troubleshooten

Systematisch de oorzaak vinden.

7️⃣ Automatiseren

Repetitief werk omzetten in code.

8️⃣ Documenteren

Architectuurdocumentatie en runbooks maken.

9️⃣ Uitleggen

Het systeem aan een andere engineer kunnen uitleggen.

🔟 Valideren

Een certificering, praktijktest of echt project gebruiken als laatste checkpoint.


⏱️ Mijn realistische tijdsbudget per week

Ik wil niet dat deze roadmap nog een fulltime baan wordt.

Een realistisch gemiddelde is:

ActiviteitTijd / week
Gestructureerd leren2–3 uur
Homelab / praktijkwerk2–3 uur
Documentatie / Git0,5–1 uur
AI-ondersteund verkennen0,5–1 uur

Doel: ongeveer 5–8 uur per week.

Vóór een certificering kan dit tijdelijk oplopen.

In drukke periodes kan het afnemen.

Waar het om gaat, is consistentie op de lange termijn.


🗺️ DE VIJFJARIGE ROADMAP

2026
 │
 ├── Linux
 ├── Graylog
 ├── Git
 └── Ansible
       │
       ▼
2027
 │
 ├── Advanced Linux
 ├── Windows Server
 ├── Active Directory
 ├── Security
 └── Infrastructure Architecture
       │
       ▼
2028
 │
 ├── Terraform / OpenTofu
 ├── Infrastructure as Code
 ├── Kubernetes
 └── GitOps
       │
       ▼
2029
 │
 ├── Azure
 ├── Entra ID
 ├── Hybrid Cloud
 ├── Multi-RZ
 └── Disaster Recovery
       │
       ▼
2030
 │
 ├── Observability
 ├── OpenTelemetry
 ├── Platform Engineering
 ├── AI
 └── AIOps

🐧 JAAR 1 — Linux, Graylog, Git & automatisering

📅 Doel: september 2026 – augustus 2027

Hoofddoel: een extreem solide basis in systemen en automatisering opbouwen.

Geschatte inspanning: 5–8 uur/week.


🐧 Fase 1 — Gevorderd Linux / systems engineering

Duur: ongeveer 6–9 maanden

Doel: 120–180 uur

Onderwerpen die ik wil beheersen

  • Linux-architectuur
  • bootproces
  • systemd
  • processen en threads
  • signalen
  • CPU-scheduling
  • geheugenbeheer
  • virtueel geheugen
  • bestandssystemen
  • LVM
  • RAID
  • ZFS
  • netwerken
  • DNS
  • SSH
  • rechten
  • ACL’s
  • journald
  • logging
  • performance-analyse
  • kernel-basiskennis
  • security hardening

Bijzonder belangrijk

Ik wil begrijpen waarom Linux zich gedraagt zoals het zich gedraagt.

Bijvoorbeeld:

Waarom is de server traag?

In plaats van meteen willekeurige commando’s uit te voeren, wil ik leren onderscheiden:

CPU?
RAM?
I/O?
Network?
Filesystem?
Process?
Kernel?
Application?
Dependency?
Configuration?

Certificeringsmijlpaal

🎓 LFCS — Linux Foundation Certified System Administrator.

Alternatief:

🎓 RHCSA, vooral als het Red Hat-ecosysteem professioneel belangrijker wordt.

Einddoel

Geef me een kapotte Linux-server en ik vind systematisch de root cause.


📊 Fase 2 — Graylog & logmanagement

Duur: doorlopend gedurende jaar 1

Prioriteit: ZEER HOOG

Dit is mijn huidige professionele specialisatie.

Onderwerpen

  • Graylog-architectuur
  • Graylog-nodes
  • Data Nodes
  • OpenSearch
  • shards
  • replica’s
  • index sets
  • streams
  • pipelines
  • parsers
  • verwerking
  • retentie
  • journal
  • Fluent Bit
  • syslog
  • GELF
  • Fluent Forward
  • relays
  • HA
  • capaciteitsplanning
  • performance
  • security logging
  • eventdetectie

Architectuurdoel

Thousands of Servers
        │
        ▼
Agents / Syslog
        │
        ▼
Relay Tier
        │
        ▼
Graylog
        │
        ▼
OpenSearch
        │
        ▼
Hot / Cold Storage

Ik wil kunnen berekenen

  • dagelijkse ingestie
  • opslagbehoefte
  • replicatie-overhead
  • retentie
  • hot storage
  • cold storage
  • clustersizing
  • faalscenario’s

Professionele mijlpaal

Een productierijpe, gecentraliseerde logging-architectuur kunnen ontwerpen en verdedigen.


🌱 Fase 3 — Git & Ansible

Duur: 4–6 maanden

Git

  • repositories
  • branching
  • merging
  • rebasing
  • tags
  • pull requests
  • GitLab
  • basis van CI/CD

Ansible

  • inventory
  • roles
  • collections
  • variabelen
  • templates
  • Jinja2
  • Vault
  • handlers
  • idempotentie
  • testen
  • AWX

Doel

Manual configuration
       ↓
Ansible
       ↓
Git
       ↓
Version-controlled infrastructure
       ↓
Repeatable infrastructure

Ik wil op het punt komen waarop ik denk:

“Als ik dit twee keer handmatig moet configureren, doe ik het verkeerd.”


🪟 JAAR 2 — Windows Server, Active Directory & architectuur

📅 Doel: september 2027 – augustus 2028

Hoofddoel: uitbreiden van Linux-beheer naar enterprise-infrastructuur.


🪟 Fase 4 — Windows Server

Duur: 4–6 maanden

Onderwerpen

  • Windows Server-architectuur
  • roles en features
  • PowerShell
  • Windows-netwerken
  • Windows-opslag
  • Windows-clustering
  • Windows Event Logs
  • WinRM
  • services
  • performance-analyse
  • security

🔐 Fase 5 — Active Directory

Duur: 5–7 maanden

Onderwerpen

  • AD DS
  • Forest
  • Domain
  • OU-ontwerp
  • Domain Controllers
  • FSMO-rollen
  • AD-replicatie
  • Sites & Services
  • DNS
  • Group Policy
  • Kerberos
  • LDAP
  • SPN’s
  • serviceaccounts
  • gMSA
  • AD CS
  • PKI
  • AD-security

Belangrijke koppeling met Linux

                 Active Directory
                        │
             ┌──────────┼──────────┐
             │          │          │
            DNS      Kerberos     LDAP
             │          │          │
             └──────────┼──────────┘
                        │
              ┌─────────┴─────────┐
              │                   │
           Windows              Linux
              │                   │
             GPO             SSSD / PAM
          PowerShell          Kerberos
             WinRM               LDAP

Het doel is niet om Windows-beheerder te worden in plaats van Linux-beheerder.

Het doel is beide werelden en de interfaces daartussen te begrijpen.

Certificeringsmijlpaal

🎓 Microsoft-certificeringstraject Windows Server / Hybrid Administration.

Het precieze examen kies ik bij de start van de fase, omdat Microsoft zijn certificeringsportfolio regelmatig bijwerkt.


🏗️ Fase 6 — Infrastructuurarchitectuur

Duur: 6–12 maanden

Dit is een van de belangrijkste fases van de hele roadmap.

Onderwerpen

  • architectuurpatronen
  • hiërarchie
  • afhankelijkheden tussen services
  • failure domains
  • HA
  • redundantie
  • load balancing
  • opslagarchitectuur
  • netwerkarchitectuur
  • Multi-RZ
  • disaster recovery
  • RPO
  • RTO
  • capaciteitsplanning
  • schaalbaarheid
  • back-uparchitectuur
  • security-architectuur
  • documentatie

Groot project

Een fictieve enterprise-infrastructuur ontwerpen voor:

  • 5.000 servers
  • Linux + Windows
  • twee datacenters
  • centrale logging
  • centrale monitoring
  • identity services
  • security monitoring
  • back-up
  • HA
  • DR

Opleveren:

  • architectuurdiagrammen
  • netwerkontwerp
  • afhankelijkhedenkaart
  • HA-concept
  • DR-concept
  • capaciteitsberekening
  • securityconcept
  • monitoringconcept
  • loggingconcept

Deze oefening is bewust groter dan een normaal homelabproject.

Het doel is te leren denken als een infrastructuurarchitect.


☁️ JAAR 3 — Infrastructure as Code & Kubernetes

📅 Doel: september 2028 – augustus 2029


🏗️ Fase 7 — Terraform / OpenTofu

Duur: 4–6 maanden

Onderwerpen

  • providers
  • resources
  • state
  • modules
  • variabelen
  • outputs
  • remote state
  • secrets
  • CI/CD
  • levenscyclus van infrastructuur

Doel

Git
 ↓
Infrastructure as Code
 ↓
Provisioning
 ↓
Ansible
 ↓
Configuration
 ↓
Monitoring
 ↓
Logging

Ik wil het verschil helder begrijpen tussen:

  • provisioning
  • configuratiemanagement
  • orchestratie
  • applicatie-deployment

☸️ Fase 8 — Kubernetes

Duur: 8–12 maanden

Prioriteit: HOOG

Onderwerpen

  • control plane
  • API Server
  • etcd
  • scheduler
  • controllers
  • kubelet
  • container runtime
  • netwerken
  • DNS
  • Services
  • Ingress
  • opslag
  • PVC’s
  • RBAC
  • Secrets
  • Helm
  • Operators
  • GitOps
  • Flux
  • security
  • troubleshooting

Certificeringsmijlpalen

🎓 CKA — Kubernetes-beheer.

Later:

🎓 CKS — Kubernetes-security.

De CKS is extra aantrekkelijk omdat die Kubernetes combineert met mijn bestaande securityachtergrond.


☁️ JAAR 4 — Azure, hybride cloud & Multi-RZ

📅 Doel: september 2029 – augustus 2030


☁️ Fase 9 — Azure

Duur: 6–9 maanden

Onderwerpen

  • Azure-architectuur
  • VNets
  • subnetten
  • routing
  • NSG’s
  • load balancing
  • VM’s
  • opslag
  • identiteit
  • security
  • monitoring
  • logging
  • governance
  • beschikbaarheid
  • DR

Certificeringsmijlpaal

🎓 AZ-104 — Azure Administrator Associate

Die past goed in de roadmap, omdat hij Azure-compute, opslag, netwerken, identiteit en beheer combineert.


🔑 Fase 10 — Entra ID & hybride identiteit

Duur: 3–5 maanden

On-Prem AD
    │
    │ Hybrid Identity
    ▼
Microsoft Entra ID
    │
    ▼
Azure
```

Onderwerpen:

    • identiteitsarchitectuur
    • authenticatie
    • autorisatie
    • federatie
    • hybride identiteit
    • conditional access
    • RBAC
    • service-identiteiten
    • security

🏢 Fase 11 — Multi-RZ / datacenterarchitectuur

Duur: 4–6 maanden

Deze fase combineert veel eerdere onderwerpen.

                    Global Services
                           │
             ┌─────────────┴─────────────┐
             │                           │
            DC1                         DC2
             │                           │
      ┌──────┼──────┐             ┌──────┼──────┐
      │      │      │             │      │      │
   Compute Network Storage      Compute Network Storage
      │                           │
      └──────────────┬────────────┘
                     │
                 Services
                     │
          Monitoring / Logging / IAM

Onderwerpen

  • failure domains
  • siteredundantie
  • load balancing
  • replicatie
  • back-up
  • RPO
  • RTO
  • DR
  • split brain
  • quorum
  • netwerkpartitionering
  • afhankelijkheden tussen services
  • capaciteitsplanning

Hier wordt het eerdere architectuurwerk praktisch.


📡 JAAR 5 — Observability, platform engineering & AI

📅 Doel: september 2030 – augustus 2031


📊 Fase 12 — Moderne observability

Duur: 4–6 maanden

                 Observability
                      │
          ┌───────────┼───────────┐
          │           │           │
       Metrics       Logs       Traces
          │           │           │
     Prometheus     Graylog   OpenTelemetry
          │           │           │
          └───────────┼───────────┘
                      │
                    Grafana

Onderwerpen

  • metrics
  • logs
  • traces
  • correlatie
  • gedistribueerde systemen
  • Prometheus
  • Grafana
  • Graylog
  • OpenTelemetry
  • alerting
  • incidentanalyse

Het doel is om te gaan van:

“De server is rood.”

naar:

“De klantgerichte service degradeerde omdat afhankelijkheid X latency had nadat component Y resource Z had uitgeput.”


🤖 Fase 13 — AI & AIOps

Duur: doorlopend

Onderwerpen

  • LLM’s
  • prompt engineering
  • AI-API’s
  • RAG
  • embeddings
  • vectordatabases
  • lokale LLM’s
  • AI-agents
  • MCP
  • AI-ondersteund troubleshooten
  • AI-ondersteunde documentatie
  • AI-ondersteunde automatisering
  • incidentcorrelatie
  • AIOps

Voorbeeld

Monitoring Alert
       │
       ▼
Context Collection
       │
       ▼
AI Analysis
       │
       ▼
Possible Causes
       │
       ▼
Diagnostic Tests
       │
       ▼
Human Validation
       │
       ▼
Automation

AI moet me sneller maken.

Het mag me niet intellectueel lui maken.


🏠 Het homelab — mijn praktische trainingsomgeving

Het homelab is een belangrijk onderdeel van de roadmap, maar heeft bewust minder prioriteit dan de eigenlijke leerdoelen.

Het leerplan komt eerst.

Het homelab bestaat om theorie om te zetten in praktijkervaring.

Mijn hardware:

  • 🖥️ 3 fysieke servers
  • 🖥️ 2 tower-pc’s

Dat is ruim genoeg voor een verrassend capabel infrastructuurlab.


🧪 Homelab-regel #1

Draai niet alleen services. Bouw scenario’s.

In plaats van:

“Ik heb een Kubernetes-cluster.”

wil ik:

“Ik heb een Kubernetes-cluster gebouwd, bewust een node gekild, de storing geobserveerd, het gedrag geanalyseerd en het herstel gedocumenteerd.”

Dat is een compleet andere leerervaring.


🖥️ Gebruik van het homelab per leerfase

LeergebiedHomelab-oefening
LinuxPerformance- en storingsanalyse
GraylogCentraal loggingplatform
WindowsWindows Server-omgeving
ADActive Directory met meerdere DC’s
NetwerkenScenario’s met VLAN / routing / firewall
AnsibleDe hele omgeving automatiseren
GitInfrastructuurrepository
IaCReproduceerbare infrastructuur
KubernetesCluster met meerdere nodes
ObservabilityMetrics + logs + traces
SecurityHardening en aanvalssimulaties
DRServices vernietigen en herstellen
AIAI-ondersteunde incidentanalyse

💥 Het “breek het expres”-programma

Een van de belangrijkste onderdelen van het homelab wordt het bewust veroorzaken van storingen.

Voorbeelden:

  • DNS breken
  • een bestandssysteem vol laten lopen
  • kritieke services stoppen
  • certificaten breken
  • netwerkconnectiviteit weghalen
  • opslagstoringen simuleren
  • Kubernetes-nodes killen
  • RBAC breken
  • Active Directory-replicatie breken
  • Graylog-ingestie breken
  • buitensporig veel logs genereren
  • latency introduceren
  • pakketverlies simuleren

Daarna:

Failure
  ↓
Symptoms
  ↓
Evidence
  ↓
Hypotheses
  ↓
Tests
  ↓
Root Cause
  ↓
Fix
  ↓
Prevention
  ↓
Documentation

Hier verwacht ik dat een groot deel van het echte leren gebeurt.


📚 Het homelab moet documentatie opleveren

Elk serieus project moet iets achterlaten.

homelab/
│
├── ansible/
├── terraform/
├── opentofu/
├── kubernetes/
├── monitoring/
├── logging/
├── security/
├── networking/
│
├── architecture/
│   ├── network.md
│   ├── storage.md
│   ├── logging.md
│   ├── kubernetes.md
│   └── disaster-recovery.md
│
└── incidents/
    ├── dns-failure.md
    ├── storage-failure.md
    ├── ad-failure.md
    └── kubernetes-node-failure.md

Zo wordt het homelab een praktisch portfolio van engineeringwerk.


🤖 AI als onderdeel van het leerproces

ChatGPT en Claude worden alle vijf jaar onderdeel van de workflow.

Maar de workflow is belangrijk.

Slechte workflow

Problem
 ↓
Ask AI
 ↓
Copy solution
 ↓
Done

Betere workflow

Problem
 ↓
My own hypothesis
 ↓
AI challenge
 ↓
Alternative hypotheses
 ↓
Diagnostic tests
 ↓
Evidence
 ↓
My decision
 ↓
Implementation
 ↓
Validation

Een paar vragen die ik regelmatig wil gebruiken:

“Wat mis ik?”

“Wat zijn drie aannemelijke root causes?”

“Welke test zou deze hypotheses van elkaar onderscheiden?”

“Beoordeel je vorige antwoord kritisch.”

“Welke aannames doe je?”

Zo moet AI een technische sparringpartner worden in plaats van een commandogenerator.


🏆 Certificeringsstrategie

Certificeringen zijn nuttig, maar ze moeten de roadmap valideren en niet dicteren.

Ong. periodeDoelWaarom
2026/27LFCSPraktische Linux-basis
2026/27RHCSA — optioneel alternatiefEnterprise Linux
2027/28Windows Server / Hybrid AdministrationWindows + AD + hybride
2028/29CKAKubernetes-beheer
2028/29CKSKubernetes-security
2029/30AZ-104Azure-beheer
2030/31AI- / security- / cloud-certificaatAlleen als het echt nuttig is

De regel is simpel:

Geen certificering alleen omdat die bestaat.

Een certificering moet:

  • een echt kennisgat vullen
  • structuur bieden
  • praktische vaardigheden valideren
  • professioneel nuttig zijn

Anders is het project zelf waarschijnlijk waardevoller.


📈 De vaardigheidsniveaus

Ik wil voortgang ook meten aan vaardigheid in plaats van alleen aan certificaten.

Niveau 1 — Operator

Ik kan documentatie volgen en het systeem bedienen.

Niveau 2 — Beheerder

Ik begrijp de configuratie en kan veelvoorkomende problemen oplossen.

Niveau 3 — Engineer

Ik begrijp architectuur, afhankelijkheden en faalscenario’s.

Niveau 4 — Ontwerper

Ik kan het systeem ontwerpen en architectuurbeslissingen onderbouwen.

Niveau 5 — Architect

Ik kan complexe systemen ontwerpen over meerdere technologieën en failure domains heen.

De vijfjarige roadmap gaat in wezen over de weg van:

Operator
   ↓
Administrator
   ↓
Engineer
   ↓
Designer
   ↓
Architect

🧠 Wat ik na vijf jaar wil kunnen

Stel dat iemand me dit probleem voorlegt:

“We beheren enkele duizenden Windows- en Linux-systemen verspreid over meerdere datacenters. We hebben gecentraliseerde identiteit, monitoring, logging, security, automatisering, high availability en disaster recovery nodig. Ontwerp het platform.”

Dan wil ik kunnen redeneren over:

  • Linux
  • Windows
  • Active Directory
  • DNS
  • netwerken
  • security
  • opslag
  • logging
  • monitoring
  • observability
  • Kubernetes
  • cloud
  • identiteit
  • automatisering
  • HA
  • DR
  • capaciteit
  • afhankelijkheden
  • failure domains

En het allerbelangrijkste:

Ik wil begrijpen waarom de architectuur eruitziet zoals ze eruitziet.


🚀 De uiteindelijke filosofie

Er komt altijd weer een nieuwe technologie.

Weer een Kubernetes-release.

Weer een cloudplatform.

Weer een Linux-distributie.

Weer een monitoringsysteem.

Weer een AI-framework.

Weer een certificering.

En weer een commando dat ik morgenochtend vergeten ben.

Dat is oké.

Technologieën veranderen.

Engineeringprincipes veranderen veel langzamer.

Systemen hebben nog steeds:

  • afhankelijkheden
  • interfaces
  • faalscenario’s
  • securitygrenzen
  • capaciteitslimieten
  • beschikbaarheidseisen
  • datastromen
  • operationele beperkingen

Daar wil ik mijn leerinspanning in steken.

🐧 Minder commando’s stampen.

🏗️ Meer architectuur.

🔍 Meer troubleshooting.

🤖 Meer automatisering.

☁️ Meer denken in infrastructuur.

🧠 Meer begrip.

En ja...

Ik heb nog steeds tegelijk een terminal, een spiekbriefje, documentatie, ChatGPT en Claude open.

Want:

Een goede infrastructure engineer zijn betekent niet alles onthouden.

Het betekent weten wat ertoe doet, weten hoe je de rest vindt en weten hoe je bepaalt of het antwoord echt klopt.

😎 Laten we het nu bouwen. En af en toe breken.

Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details