Technical notes, projects, modules, tools, workflows, and architecture on electronics, software engineering, and DevOps.
An interactive Python script that proves an identity provider is ready for a client: it rehearses a full PKCE sign-in and sign-out like an application, then checks the tokens it receives against the provider's keys the way an application must.
The procedure that gives a new project its whole infrastructure from generators, in the order the stacks depend on each other: log first, then storage and broker, then the gateway, then the application — with the public steps kept manual.
Templates come from real stacks, and copies quietly carry their data, keys, open databases and root-owned paths. My database, object storage and application generators leave the old data, keys and access behind, and read each application's facts from the application itself.
Every project gets its own OpenTelemetry Collector, Elasticsearch and Kibana from one command, showing data on dashboards from the first start, by owning the data directory, starting services in the order they need, and keeping the official mappings on one node.
Opening a broker to browsers and devices on the internet is less about encryption than identity. Each entrance now accepts one kind of credential, every token is bound to its own name and addressed to this broker, and TLS ends in nginx.
Every new project needs a gateway, sign-in, and a first administrator before its backend exists. One generator command now builds that stack, working on first boot, by handling the values that fail silently when set by hand and a rerun that would keep the old database.
The procedure that turns a month of commits into a report a non-technical reader can follow: an AI agent reads, groups, drafts, and captures code evidence behind checks, while I sign in to the code hosts and review the result.
The procedure that turns each new chapter of a story into a narrated video: an AI agent runs every stage behind gates that refuse unfinished work, while I start each stage, review the chapter, and render it myself.
Feature-Based Frontend Architecture is one of the architectures I use: the shape I give Vue web interfaces — one folder per feature, shared code in a few global folders by kind, data flowing one way through stores and services to one HTTP client, and my own design system pinned by version.
One folder per kind of code at a single level, a short path from route to repository, one file per operation — the shape I give a Rust service that must work fast or fit a local AI agent's context, before it grows into Clean Architecture.
Get an email when a new article is published.