The Nonagon Manifesto

Twenty years of infrastructure experience distilled into four principles. This is what we believe, why we share our work, and what you can expect from this blog.

Infrastructure as an Artifact

Twenty years ago, a "server" was a physical box you could touch, name, and—when things went sideways—manually resurrect at 3am while half-asleep and running on coffee fumes. Today, infrastructure is ephemeral, defined by code, and orchestrated by systems that can spin up a hundred nodes before you finish your morning standup.

But here's what hasn't changed: the mission is still reliability. Systems that work. Systems that stay working. Systems that don't page you at midnight because someone forgot to renew a certificate or a disk filled up silently.

At Nonagon Media, we believe the gap between a "Junior Sysadmin" and a "Senior SRE" isn't measured in certifications or years on a resume. It's measured in perspective on predictability. The senior engineer has been burned enough times to know that hope is not a strategy, and "it works on my machine" is not a deployment plan.

Our Technical North Star

This blog is not a collection of news aggregation or vendor-sponsored hot takes. It's not thought leadership divorced from implementation.

This is a battle-tested roadmap for building modern infrastructure from the ground up—written by someone who has actually built it, broken it, debugged it at 2am, and rebuilt it better.

Our approach is defined by four core principles:

1. Automation by Default

If a task must be done twice, it belongs in an Ansible playbook, a chef recipe, or a Terraform module. If it must be done three times, it belongs in a pipeline.

Manual intervention is not a workaround. Manual intervention is a bug.

We don't click through consoles. We don't SSH in and edit config files by hand. We write code that configures systems, and we version control that code so we can reproduce any environment from scratch.

2. Linux at the Core

Whether it's a K3s cluster humming in a homelab closet or a production EKS deployment serving millions of requests, deep Linux knowledge is the foundation that makes everything else possible.

Containers are Linux. Kubernetes is Linux. The cloud is someone else's Linux. When the abstraction leaks—and it always leaks—you need to understand what's happening underneath.

We know the difference between systemd and SysV init. We've debugged cgroup mounting issues. We've traced network packets through iptables rules that made no sense until they suddenly did.

3. Right-Sized Engineering

We don't deploy enterprise bloat to pad a resume or justify a budget. Complexity is not a badge of honor—it's a liability.

We value lean, efficient solutions: K3s instead of full Kubernetes when the workload fits. Docker execution environments instead of bloated CI runners. Fluxbox instead of GNOME when all you need is a window manager.

The right tool is the simplest tool that solves the problem. Over-engineering is just technical debt with better marketing.

4. Radical Transparency

We share our failures. The NFS permission nightmares that cost us a weekend. The DNS resolution bug that only manifested under load. The cgroup mounting failure on MX Linux that had us questioning our career choices.

The best engineering happens when we stop pretending things work the first time.

Every "Lessons Learned" post on this blog is a scar we earned. We share them because debugging in isolation is slower than debugging as a community, and because the engineer who admits their mistakes is the engineer you can trust with your production systems.

What to Expect

We're building a comprehensive library of deep-dive tutorials covering the full spectrum of modern DevOps, cloud engineering, and infrastructure automation.

Infrastructure Foundations

K3s multi-cluster architecture from first principles
NFS storage patterns for Kubernetes workloads
Docker execution environments for consistent tooling

CI/CD & Automation

Jenkins pipeline mastery for multi-tool orchestration
Terraform plan/apply workflows with artifact storage
Container image builds from Dockerfile to ECR to deployment
Ansible at scale: cross-platform support and patterns

Production Applications

Centralized logging with Vector, Loki, and Grafana
Self-hosted graphics suite: Kroki, Penpot, Excalidraw
Production Django and Wagtail on Kubernetes
Remote access at scale with VNC and Guacamole

AWS Cloud Services

Transactional email with SES
Secrets Manager for infrastructure credentials
S3 patterns for DevOps workflows
IAM for automation and least-privilege access

AWS Fundamentals Curriculum

Complete CloudFormation from zero to nested stacks
VPC networking: subnets, gateways, peering, endpoints
EC2, Auto Scaling, and Load Balancing deep dives
Lambda, API Gateway, and serverless patterns
ECS, EKS, and container orchestration on AWS
CodePipeline, SAM, and Step Functions

The Hard-Won Lessons

Linux platform challenges that don't show up in tutorials
The debugging sessions that taught us more than any certification

This isn't a tutorial site that shows you how to install a tool and walks away. We're showing you how these tools integrate into a cohesive, production-ready ecosystem—the same ecosystem we use to run our own infrastructure.

Whether you're starting from scratch or leveling up existing skills, we've mapped out a path from fundamentals to advanced production patterns.

Why Share All of This?

Because talk is cheap. Credentials are easy to claim. The work speaks.

The best way to prove twenty years of experience is to show what twenty years of experience actually builds. Not slides. Not architecture diagrams drawn in a meeting. Real configurations. Real playbooks. Real cluster manifests that we run in production.

Whether you're a developer trying to understand the "black box" of Ops, a junior engineer looking for patterns that actually work, or a seasoned SRE looking for a battle-hardened K3s config to compare against your own—this space is for you.

The Name

Why "Nonagon"?

A nonagon is a nine-sided polygon. It's uncommon. Most people can't picture one without thinking about it. It doesn't tile neatly or fit into obvious patterns.

That's the point.

We're not here to follow the herd into whatever tool is trending on Hacker News this week. We're here to build infrastructure that works—even when it means choosing the unfashionable path, the unsexy tool, the solution that doesn't make for good conference talks but runs for years without intervention.

Nine sides. No shortcuts.

Let's Build

Infrastructure should be an artifact—something you can point to and say, "I built that, and it works."

Not a collection of manual fixes held together by tribal knowledge. Not a production environment that only one person understands. Not a system that requires heroes to keep it running.

An artifact. Versioned. Reproducible. Documented. Reliable.

That's what we're building here. That's what we'll teach you to build.

Welcome to Nonagon Media.

Let's build something that doesn't need us at 3am.