Nik Ogura

The best professional compliment I ever got was that I should be writing code for generation ships flying to Alpha Centauri.

A system that only keeps running because a person is continuously holding it up is not working.

A résumé parser matches tokens, not competence.

We are not paid to solve interesting engineering problems.

Most people gamble on success — they assume the thing will work, and they're genuinely surprised when it doesn't.

What's in git is what's in your infrastructure — or alarms are sounding.

Incident response is either an engineering discipline — measured, quantified, repeatable, owned, evaluated — or it is a craft a few heroes practice and nobody else can duplicate.

Larry Wall built Perl around a principle: no unnecessary limitations.

Run terraform plan against infrastructure nobody has touched in a month and watch it propose changes.

The specialize-versus-unify argument feels like a religious war.

An acceptance test run once before deploy proves the data was correct for one instant.

Google OAuth has two surprises that make every internal-service auth story uglier than it should be.

The role-based incident-response model Jesse Robbins brought from the fire service into web operations, written down from memory as I learned it.

You can identify a programmer's native language by the tools they build.

The difference between a system that can fail and a system that does fail is time.

Long-running branches are an anti-pattern.

A control repository is a git repository whose contents declare what should be running, intended to be reconciled by an automated controller.

Everything in Web3 is something you already know.

There is no such thing as a "highly resilient database" in the abstract.

Security and infrastructure are not two disciplines that happen to overlap.

Four observability signals that get thrown around interchangeably.

When something has been failing for a while despite competent people working on it, the problem is almost certainly not competence.

Centralized, imperative orchestration requires centralized coordination, and centralized coordination is a bottleneck that doesn't scale.

OpenTelemetry does not replace Prometheus.

Distributed tracing captures the complete journey of a single request as it passes through multiple services, enabling latency analysis, error propagation tracking, and root cause analysis across complex architectures.

GitOps is not just keeping YAML in git.

A deep comparison of the architectural differences between FluxCD and ArgoCD for experienced Kubernetes platform engineers, covering CRD design, state management, controller models, and where each tool wins.

A reference implementation for GitHub Actions CI/CD pipelines covering automated testing, linting with golangci-lint and namedreturns, semantic versioning, automatic releases, and caching strategies.

A collection of useful shell functions and aliases for Kubernetes debugging and daily operations, from context switching to JWT decoding to Prometheus config extraction.

Security, reliability, and compliance are non-negotiable.

How to provision Kubernetes clusters on Talos Linux with OIDC-based AWS IRSA integration using Terraform, enabling cross-cloud workloads that authenticate to AWS services without static credentials.

A reflection on how learning to program as a small business owner built the FITFO skill -- the ability to figure things out from scratch -- which became the foundation of a DevOps career.

Many of Golang's unwritten rules can be summed up by the Go Proverbs.

A Terraform pattern for automatically selecting the newest AMI that is at least two weeks old, enabling a rolling window approach to AMI updates that avoids deploying untested images to production.

Documentation is like pizza -- when it is good, it is really good, and when it is bad, it is still pizza.

Operational notes on running the Vault Operator in Kubernetes, covering CRD configuration, secrets management, authentication testing, and Cert Manager integration.

TDD is not just about writing tests before code -- it is about alternating between tests and code so that you write code in discrete, testable units and capture every insight as an automated check that lives in your codebase forever.

This is about design philosophy and how to approach your work.

Secrets management is an important job, but it sucks.

Potentially timesaving tips and tricks for Python development on MacOS, covering virtual environments, Homebrew setup, and IDE configuration with JetBrains tools.

A single script that creates a full OpenStack Liberty cloud from nothing, demonstrating an infrastructure-as-code approach to cloud deployment.

A simple trick to link your IDE terminal with your project's virtual environment, so command-line tools automatically use the same Python and libraries as your IDE.

A hands-on guide to spinning up an n-way multi-master LDAP directory for centralized access and identity management, covering server setup, replication, ACLs, and schema configuration.

A system for building self-updating command-line tools that automatically download, verify, and replace themselves with the latest version using checksums and GPG signatures.

A trick for using CircleCI 1.x build artifacts as a Maven repository by fetching dependency artifacts and installing them into the local Maven cache.

How I built a system to impersonate the AWS metadata service on developer laptops, providing passwordless, expiring STS credentials linked to user identities via SSH key authentication.