Topics

Every article, grouped by what it is about.

• testing 25

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

• architecture 22

  Decomposition, boundaries and deciding what should not be built.

• security 22

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

• docker 21

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

• python 20

  Python services, tooling and the packaging around them.

• reliability 20

  Behaving correctly when something is already broken.

• kubernetes 19

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

• api-design 16

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

• linux 16

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

• performance 16

  Finding the actual bottleneck rather than the one you assumed.

• networking 14

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

• observability 14

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

• infrastructure-as-code 12

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

• storage 11

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

• automation 10

  Removing a task rather than documenting it.

• ceph 10

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

• ci-cd 10

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

• identity 10

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

• llm 9

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

• agents 8

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

• dns 7

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

• embedded 7

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

• 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.

• frontend 6

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

• go 6

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

• databases 5

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

• vault 5

  HashiCorp Vault: secret storage, dynamic credentials and unsealing.

• 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 3

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

• documentation 2

  Documentation that is reviewed, tested and therefore still true.

• bluetooth 1

  BLE links, GATT services, and the stack problems that hide in the host, not the device.

• flutter 1

  Cross-platform mobile apps and the toolchain that builds them on Linux.

• methodology 1

  The repeatable process behind a result: evidence levels, captures, and checks that keep it honest.

• reverse-engineering 1

  Learning how a closed system works by observing it, and documenting what you find.