The work

Case study · Platform engineering

Designing the substrate, not just deploying onto it.

I build platforms so application teams don’t have to become infrastructure teams. This is how mine are put together, layer by layer.

  • Talos
  • Pulumi
  • Cilium
  • Flux
  • Kyverno
  • cert-manager

The problem space

A platform extends beyond the cluster.

A production Kubernetes platform is more than a cluster: networking, ingress, certificates, identity, secrets, policy, observability, upgrades, recovery and GitOps reconciliation.

It is also the interface engineers use to consume all of that. A platform can be technically sound and still be hard to use when ownership, defaults and failure behaviour stay implicit.

So I draw hard lines. One owner per resource. Platform concerns on one side, application concerns on the other, written down where both teams can read them.

The design boundaries

Make every layer understand its job.

Drawn the way a platform is built: the foundation at the bottom, everything else resting on it.

  1. 04

    Operations

    OpenTelemetry · Prometheus · restore drills

    Logs, metrics and traces leave every service as OTLP through one Collector. Every stateful workload documents how it is backed up and restored, and a backup only counts after a restore drill has proven it.

  2. 03

    Delivery

    Flux · Helm · three repositories

    One repository bootstraps clusters and wires components together, one holds platform components, one holds products. Platform and applications change at different speeds with different owners, so they live apart. Pulumi owns the machines; Flux owns everything inside the cluster.

  3. 02

    Shared capabilities

    cert-manager · Sealed Secrets · Kyverno

    Certificates come from cert-manager, secrets are sealed before they reach Git, and Kyverno enforces the restricted Pod Security profile and signed images. Teams get all of it by default, without asking.

  4. 01

    Foundation

    Talos · Pulumi · Cilium

    Pulumi in TypeScript owns the machines, Talos, the CNI and the Flux bootstrap. Talos has no SSH and no shell, so nobody hand-patches a node; upgrades go one node at a time through its API. kind runs the same manifests in the lab.

What good looks like

Safe defaults. Visible behavior. Room to debug.

A platform is successful when the common path is safe and boring, the exceptional path is still possible, and operators can understand what the system is doing without relying on folklore.

That means debugging from first principles: DNS before deployment YAML, routes before controllers, certificates before annotations. Follow the request and let the evidence identify the layer.

The useful question is: can another engineer understand, operate, and recover this system?