OLD SCHOOL ENGINEERING.
MODERN INFRASTRUCTURE.
Unix. Linux. FreeBSD. Networking. Automation. Infrastructure as Code. Kubernetes. Platform Engineering.
Technology changes.
Good engineering doesn't.
ROOT // SYSTEMS is about understanding the systems underneath the abstractions.
Learn Unix before containers. Learn Linux before Kubernetes. Learn networking before service meshes. Learn systems before platforms.
The tools change. The fundamentals remain.
Build from first principles.
Understand the system.
Abstractions are useful, but they should never hide the mechanisms that make a system work.
Automate the repeatable.
If a process is predictable, document it. If it happens repeatedly, automate it. If it matters, make it observable.
Design for failure.
Servers fail. Networks fail. Disks fail. Applications fail. People make mistakes. Good systems assume this.
Keep it observable.
If you cannot see what the system is doing, you are operating it by assumption.
The infrastructure timeline
From operating systems and networks to cloud platforms and Kubernetes.
Start with the fundamentals.
The operating systems, networks and engineering practices behind modern infrastructure.
The philosophy.
Processes, filesystems, permissions, shells, signals, IPC and the principles that shaped modern systems.
The kernel that changed everything.
Kernel architecture, boot, systemd, storage, networking, security, performance and containers.
A complete operating system.
The base system, rc.d, jails, ZFS, PF, networking, ports, packages and kernel architecture.
Packets don't lie.
Routing, switching, DNS, TCP/IP, firewalls, load balancing and the mechanics of moving data.
If you do it twice, automate it.
Shell scripting, configuration management, repeatability, orchestration and operational automation.
Infrastructure becomes code.
Terraform, OpenTofu, Ansible, state, modules, immutable infrastructure and GitOps.
The operating system for distributed systems.
Control planes, scheduling, networking, storage, controllers, operators, Helm and GitOps.
Production teaches differently.
Real failures, strange behaviour, debugging, root causes, recovery and lessons learned.
From server to platform.
The old world
- Physical servers
- Manual configuration
- Shell scripts
- Static networks
- Ticket-driven operations
- Configuration drift
- Hand-maintained environments
The modern world
- Cloud infrastructure
- Infrastructure as Code
- Automated delivery
- Containers
- Kubernetes
- GitOps
- Internal Developer Platforms
The modern platform is not a replacement for systems engineering. It is systems engineering expressed through higher-level abstractions.
The abstraction is the platform.
Platform engineering exists to make infrastructure easier for engineers to consume without making the underlying system less reliable.
The goal is not to hide complexity. The goal is to manage complexity deliberately.
Infrastructure + automation + security + observability + developer experience.
Reliable paths to production without requiring every developer to become a systems engineer.
Production is the final exam.
The systems that taught the lessons the documentation didn't.
The Server That Wouldn't Die
When a machine refuses to behave like the lifecycle you designed for it.
When DNS Wasn't DNS
The request looked like a DNS problem. The root cause was somewhere else.
The Friday Kernel Upgrade
Because sometimes production teaches you why maintenance windows exist.
rm -rf: A Career Development Program
A reminder that permissions are a security boundary and the shell is extremely literal.
Know what layer you're debugging.
HARDWARE
CPU · RAM · Storage · NIC · Firmware
OPERATING SYSTEM
Kernel · Processes · Filesystems · Memory · Services
NETWORK
Ethernet · IP · TCP · DNS · Routing · Firewall
PLATFORM
Virtualisation · Cloud · Kubernetes · Storage · IAM
AUTOMATION
CI/CD · IaC · Configuration · GitOps
APPLICATION
Services · APIs · Databases · Dependencies · Runtime
Do not start at the application layer simply because that is where the error appeared.
Work down the stack until you find the first broken assumption.
22+ years of systems engineering.
ROOT // SYSTEMS is built around the practical side of infrastructure engineering: understanding systems, designing reliable platforms, automating operations and knowing what happens when things break.
The journey runs from traditional UNIX and Linux systems through networking, automation, cloud infrastructure, Kubernetes and platform engineering.
SYSTEMS → AUTOMATION → CLOUD → KUBERNETES → PLATFORM
Choose a system.
LINUX
FREEBSD
NETWORKING
AUTOMATION
IaC
KUBERNETES
WAR STORIES
Use the terminal above or select a system from the archive.
There is always another layer.
Read the documentation. Trace the packet. Inspect the process. Check the logs. Question the assumption.