How this is built
The Stack
This site is written, researched and largely operated by AI sessions working against rules kept in version control. This page is the machine that makes that possible — one rented box, one application, and the harness around it.
It is published for one reason: nearly every account of running AI this way is a demo. This one is load-bearing, it has been wrong in public, and the interesting part is not the diagram — it is what each piece cost to learn. Those are the paragraphs worth your time. Take them; you should not have to pay for them twice.
How well I actually know each of these
Every row below says which of these three it is. A stack page with no gaps is a brag, so the gaps are labelled rather than left off.
- I run thisIn production, by me, long enough to have been bitten by it.
- I have done something closeI have run the neighbouring thing, or run this somewhere that is not production.
- I have only read about itOn the map because it belongs there. Not because I have earned an opinion on it.
Right now that is 23 run in production, 1 close, and 1 read about — as of 28 August 2026.
For what has shipped, see the build log; for what is coming, what’s next.
The machine it runs on
One box, rented. Nothing here is exotic, and that is the point.
- I run thisOne rented Hetzner box
A single mid-size server runs the website, the background worker, and the scheduled jobs.
A site this size does not need a cluster. One box you understand completely beats an autoscaling group you do not, and it costs about what one seat of most SaaS costs.
What it cost to learn
The failure you actually get is not the one the architecture diagram warns about. The database stayed up and answered queries while the web container was dead and the whole site served 503 — so "is the server up" and "is the site up" are two different questions, and only one of them has an alarm on it.
- I run thisCoolify, not Kubernetes
Pushing to the main branch rebuilds and redeploys the site automatically.
It is the smallest thing that does deploys, rollbacks and logs. Kubernetes solves a coordination problem one box does not have.
What it cost to learn
The deploy runs database migrations before it starts the app, and exits if they fail. That single ordering choice means a broken migration leaves the previous version serving instead of taking the site down.
- I run thisPostgres behind PgBouncer
The database, with a connection pooler in front of it.
Serverless-style request patterns open far more connections than Postgres wants. The pooler is what makes one database survive that.
What it cost to learn
Schema changes and normal queries need different doors. Migrations go direct to Postgres; everything else goes through the pooler. Pointing a migration at the pooler is a confusing failure you will spend an afternoon on.
- I run thisA private network, not a public database port
The database has no address on the public internet. Reaching it requires being on a private network.
The cheapest security posture available: a port that does not exist cannot be brute-forced. It costs one piece of setup on each machine that needs access.
What it cost to learn
This is the decision that most shapes how the agents work. Anything automated that needs the database has to be inside the network — which quietly rules out a whole class of convenient, careless tooling.
- I run thisObject storage for every image
All images and files live in one bucket on a CDN, never hotlinked from somewhere else.
Borrowed images rot, get rate-limited, or change under you. Owning the bytes is the only version that still works in a year.
The application
One Next.js monolith and one worker, sharing a database. No microservices, no queue service, no second repo.
- I run thisOne Next.js monolith
Every public page, the admin console, and the API are one application.
One person cannot staff a service mesh. A monolith has one deploy, one log, one place a bug can be.
What it cost to learn
Monoliths rot through tangled imports, not through size. Each feature folder is a sealed box: other features may use only its front door, and the linter fails the build on a reach into its internals. That single rule is what keeps a large codebase legible to a person and to a model.
- I run thisA typed database layer
The database shape is written down in one file, and the code that queries it is generated from that file.
Typos in query code become build failures instead of production failures.
What it cost to learn
The generator is not safe by default. Asked to sync the schema it will happily write a plan that drops every table it does not know about — and this database has tables it does not know about. Every migration here is read first and hand-written second. That is not paranoia; it was measured.
- I run thisA background worker beside the website
Slow work — emails, image processing, publishing steps — runs in a second process, not inside a web request.
A reader should never wait for an email to send. It also means retries are automatic instead of a person noticing.
- I run thisRedis doing three jobs
The same server holds the cache, the job queues, and the live-updates channel.
Three separate services would be three things to run. One is enough at this size and the failure mode is easy to reason about.
What it cost to learn
Everything that touches it is written so that losing it degrades the site rather than stopping it. If the cache is gone the pages are slower; they still render.
- I run thisAccess decided in one function
Whether a paying member can see a paid thing is answered in exactly one place.
The obvious version — checking an "is this person a subscriber" flag on the account — is wrong, and wrong in the direction that gives away the product.
What it cost to learn
That flag stays switched on while a card is failing. Read it directly and someone whose payment bounced keeps full access indefinitely. The one function combines the flag with the live payment status, so a failed payment closes the door on its own.
The agent harness
The part that is genuinely unusual: the site is operated by agents against a written contract, not by hand.
- I run thisThe site is operated by agents, against a written contract
Most work here — research, drafting, code changes, the daily sweep — is done by AI sessions following instructions committed to the repository.
The instructions live in version control for the same reason the code does: so a change to how the machine behaves is reviewable, and so every session starts from the same rules instead of from whatever was said last time.
What it cost to learn
The contract is load-bearing and it decays. Instructions that describe a surface which has since been deleted do not fail loudly — the session simply acts on a world that is gone. Keeping the written rules true is ongoing work, not setup.
- I run thisNamed jobs instead of one general assistant
The repository carries a large set of named procedures — one for the daily news sweep, one for drafting, one for company research, one for shipping code — and a session runs the right one.
A single general prompt gets worse as it grows, because everything competes for attention. A named procedure only has to be right about one job.
What it cost to learn
The failure is duplication, not capability. Two procedures with overlapping names get invoked by phrasing rather than by intent, and which one runs becomes a coin toss. Merging or deleting them is more valuable than adding another.
- I run thisSeparate sessions with separate jobs
Different work runs in different sessions — one holds the day’s shape and the decisions, others take research, markets, and code.
Context is the scarce resource. A session that has read the whole world is worse at the specific job than one that read only what the job needs.
What it cost to learn
Two sessions writing to the same file is a merge conflict on the record of what happened. Exactly one writer per document, always — this was learned by having two, twice.
- I run thisA tool surface the agents talk to, instead of database access
Sessions read live business state — what is queued, what published, what is failing — through a small set of named, read-only tools.
Handing an automated session a database password is how a bad afternoon becomes a permanent one. A fixed list of questions it may ask cannot be talked into a different question.
What it cost to learn
The important half is what does not exist. There is no tool that publishes, deletes, or sends, at any permission level — so no amount of clever instruction can reach those. Absent beats forbidden.
- I run thisPublishing stays behind a person
Agents can draft, research, file and queue. Nothing they produce goes live without a human pressing publish.
Drafting is reversible and review is cheap. Publishing is neither.
- I run thisUntrusted pages read on the same machine that holds the keys
The session that reads the open web is the same one holding real credentials.
It was split in two for exactly this reason, and the split was removed — because the rule separating them was a printed warning nothing enforced, and it cost a routing decision on every job.
What it cost to learn
Stated plainly because it is the honest weak point rather than a solved problem: a hostile web page is read by something that can reach production. What actually bounds it is that the credentials for sending email and taking money are simply absent from that machine — a limit made of missing keys, not of good intentions.
What stops bad work shipping
There is no CI. Everything here is a gate somebody has to run — which is exactly why the gates are shaped to be unfakeable.
- I run thisCoverage measured on what you touched, not on the repository
A change is graded on the test coverage of the files it changed — new files held higher than edited ones — rather than on a whole-project percentage.
The project-wide number is about six percent. A global threshold at that level constrains nobody, so it is theatre. The per-file version binds on every single change.
What it cost to learn
The floor only ever ratchets up, and lowering it by hand is the one edit that defeats the entire harness. Writing that down as a rule is the cheap part; the useful part is that the rule names the specific move somebody would reach for at 11pm.
- I run thisGates that fail loudly instead of passing quietly
The coverage check grades committed work against the main branch, and says so explicitly when it graded nothing.
A check that exits successfully because it found nothing to look at is worse than no check: it reports safety it did not verify.
What it cost to learn
On a fresh machine with a shallow copy of the repository there is nothing to compare against, so the gate silently graded zero files and passed. Every gate here now has to announce that it skipped.
- I run thisA design system a script can check
Colour, type and spacing come from named tokens, and a script fails the build on a hard-coded colour anywhere in the application.
Design consistency held by discipline decays the first busy week. Held by a script, it does not.
What it cost to learn
This is what makes visual work safe to delegate to an agent. A model that invents a slightly-off grey is caught by the script, not by somebody noticing three months later.
- I run thisNo continuous integration, and no pretending otherwise
The automated pipeline was switched off. The full check suite is a command a person runs before pushing.
It was removed deliberately. What matters is that the documentation says so plainly instead of describing a robot that no longer exists.
What it cost to learn
A gate nobody runs is not enforcing anything. The honest version of this row is that the harness is now only as good as the habit — and writing that down is more useful than a green badge that means nothing.
What it exposes to the outside
What a stranger, a reader, or somebody else’s agent can actually reach.
- I run thisCalculators instead of opinions
The reasoning behind the writing is published as instruments a reader can put their own numbers into.
An article says what something costs for the writer. A calculator says what it costs for the reader, which is the only figure they can act on.
What it cost to learn
The hard part is not the arithmetic, it is refusing to guess an input. One of these was wrong by a factor of seventy-six because it estimated a number it should have looked up. The fix was a table of real values with the date they were read printed beside them.
- I run thisA build log and a roadmap, both public
What shipped is dated and listed; what is coming next is stated before it exists.
Publishing the roadmap before the work is the cheapest commitment device there is.
- I run thisMachine-readable for other people’s agents
The site publishes a plain description of itself for AI agents, plus a tool interface and a normal API.
A growing share of readers arrive as somebody else’s assistant. A site that only renders for browsers is invisible to them.
- I have done something closeRunning models on my own hardware
Open-weight models served locally, on a machine here, for the work that should not leave the building.
It is the subject the writing is pointed at, and the arithmetic for it is already published as a calculator.
What it cost to learn
Listed at its real standing rather than quietly left off. The maths is worked, verified against other people’s published runs, and shipped as a tool — but the tool was built from specifications and other operators’ numbers, not from a machine humming here. That gap is the honest state, and it is the next thing to close.
- I have only read about itFine-tuning a model on a private task
Training an open model on one narrow job so it stops needing a long prompt.
It is the second of the three things sold on the services page, and the one with the least evidence behind it here.
What it cost to learn
On the map because it belongs on the map. Everything published about it is a reading of other people’s work, and it says so.
If you want this for your own work
Everything above is either free to copy or already published as a tool. That is deliberate — the writing and the instruments are the whole of what most people need, and they cost nothing.
There are two ways to get more than that: a monthly membership where I give direction and review on the build you are doing, and three fixed-price builds where I do the work and hand it over. The prices are printed, the scope is fixed, and there is no hourly rate behind either.
What the two of them cost →