Topics

Every article, grouped by what it is about.

• testing 22

  Tests that fail when the thing they describe breaks, including for infrastructure.

• security 21

  Hardening, boundaries, and being honest about what a control actually protects.

• architecture 18

  Decomposition, boundaries and deciding what should not be built.

• docker 18

  Containers, images, registries and the build tooling around them.

• kubernetes 16

  Running workloads on a cluster: scheduling, storage, networking and the failure modes.

• python 16

  Python services, tooling and the packaging around them.

• performance 15

  Finding the actual bottleneck rather than the one you assumed.

• reliability 15

  Behaving correctly when something is already broken.

• api-design 13

  Response shapes, error models and contracts a client can rely on.

• infrastructure-as-code 12

  Keeping the repository, not the machine, as the source of truth about a system.

• linux 12

  The operating system underneath everything: permissions, systemd, sysctl, and the parts that bite.

• observability 12

  Metrics, probes and models of an estate — knowing what a system is doing.

• ceph 10

  Distributed storage on commodity hardware: placement, failure domains, recovery.

• identity 10

  OIDC, Keycloak, roles and the difference between authentication and authorization.

• storage 10

  Volumes, object stores and the durability questions that decide where data lives.

• llm 9

  Serving language models on your own hardware, and measuring whether they are any good.

• networking 9

  Overlay meshes, routing, MTU, and the layers that fail quietly.

• automation 8

  Removing a task rather than documenting it.

• ci-cd 8

  Pipelines, builds and getting a change from a branch to a running system.

• agents 7

  Automation driven by a model, and the guardrails that make it safe to run.

• fastapi 7

  Building HTTP APIs with FastAPI and Pydantic.

• gitops 7

  Reconciling a cluster toward a repository instead of deploying at it.

• redis 7

  Redis as a pipeline substrate: streams, sorted sets, pub/sub and their limits.

• ansible 6

  Configuration management: roles, handlers, idempotence, and the discipline that makes it worth having.

• dns 6

  Resolution, wildcards, split horizons, and the failures that return success.

• go 6

  Go services: concurrency, HTTP, and shipping a single binary.

• frontend 5

  Angular, TypeScript, and interfaces that show the truth about a system.

• vault 5

  HashiCorp Vault: secret storage, dynamic credentials and unsealing.

• databases 4

  Relational, time-series and the schema decisions that outlive the code.

• embedded 4

  Edge hardware, industrial peripherals and the constraints of small machines.

• secrets-management 4

  Getting a secret to a process without leaving it on disk or in git.

• tls 4

  Certificates, chains of trust, and issuing them without a public endpoint.

• alerting 3

  Deciding what is worth waking someone for, and proving the alerting itself is alive.

• cpp 2

  C++ services and the build systems that make them reproducible.

• documentation 2

  Documentation that is reviewed, tested and therefore still true.