#software-architecture

How I run Laravel as the core of a team-built platform: nodes that hold no state, slow work handed to queued jobs and specialised services, files kept off the server, one internal token for every login, and every request, job, and call observable.

Each endpoint is one procedure that carries a request from start to finish, with its concerns in modules beside it — Fowler's Transaction Script as I shape small one-job Python services, bundled into one binary, until their rules outgrow it.

A stateless Rust service that renders the first page of a PDF into a sharp, uniformly sized WebP thumbnail, reading the PDF and writing the image through two presigned links, so no application streams files or holds storage credentials.

A Rust timestamp authority that stamps a document's hash with a signed, NTP-backed time per RFC 3161, so PDF signatures stay verifiable after their certificates expire — issuing and renewing its own signing certificate, with public OCSP and CRL.

An issuing certificate authority in Rust that gives each PDF signer a certificate of their own, then answers every reader's question — is it still valid? — through a public OCSP responder and revocation list, and hands the signing service each key and chain as PKCS#12.

A Rust service that serves Indonesia's administrative regions — 38 provinces down to 83,768 villages, keyed by the official Ministry of Home Affairs codes — as four cascading lookups with search, so every address form in every project gets the same answer.

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.

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.

The shape I give small tools: one file, one job, sections in a fixed order, an exit-code contract at the top, and three ways in for input — plus its Bash variant for generators, and when a tool outgrows it.

A small Rust service between applications and S3-compatible storage: it hands out presigned links so browsers talk to storage directly, gives each file a lifecycle, copies between buckets on the server, and keeps storage credentials out of every application.

Clean Architecture is one of the architectures I use: why I chose it, the folder and naming conventions every module of mine follows across Rust, Python, Dart, Node.js and C, the questions I check a module against, and where I use something else instead.

My code is read by people who were not there when it was written: colleagues, me months later, or an AI agent that forgets on every reset. The clean code rules from Robert C. Martin I apply in every language, shown in a Rust service.

A 4 GB laptop GPU once sent every heavy job to a borrowed Colab runtime. Deciding per piece of work instead — by a measured number, by reliability, by a change of method — split one project across three places and deleted 9975 lines of machinery on the way home.

Each project began with its interface served from inside the borrowed Colab runtime, through Colab's own proxy — until Colab warned against it. Moving the interface out made the runtime a pure worker, and left two codebases held together by nothing but an agreement.