Case study
In five months, working entirely through an AI coding agent, I built and now operate a multi-machine private cloud: dozens of custom apps built (a majority live in production), a suite of native iOS companions, a couple dozen self-hosted services, full push-to-deploy CI/CD, centralized secrets, an AI control plane with cost governance, retrieval-augmented search over my own docs, fleet monitoring, and tested backups. All of it runs at zero recurring cloud cost for the stack.
One spare, aging laptop, pulled out of a drawer. Before any purpose-bought hardware existed, it ran the entire lab: a self-hosted backend stack, a home-automation platform, local LLMs, and the first custom app: a personal AI chat interface.
The unusual part is the operator. I'm not a hands-on coder: I build exclusively through an AI coding agent and judge the work in plain-English outcomes, not code review. Every structural decision that follows (the process discipline, the documentation system, the graduated-autonomy model) exists to make that safe.
The goals, written down at the start: run a real self-hosted backend with zero recurring cloud costs, build and host my own apps, develop engineering judgment, and explore private local AI.
Era 1: Foundation (March). A modest mini-PC became the production node; everything migrated off the laptop with zero downtime: database dumps per schema, auth keys re-derived. A second budget machine followed. By mid-March the three-tier shape was locked deliberately: a private production cloud kept dark to the internet, one designated public-facing box, and the old laptop as the dev machine. A self-hosted Git server went in (one repo per app, dev/production branches), the first full security audit ran in week two (audits became a cadence, not an event), and the app factory opened: a batch of apps scaffolded in about two weeks, including the seed of what became the AI control plane.
Era 2: CI/CD and promotion discipline (April). A self-hosted CI runner turned every push into an automatic build-and-deploy on the dev box, and manual copying ended for good. Centralized secrets services replaced per-app credential files, with per-app-per-machine keys and a strict rotation order (add the new key, switch the code, verify, only then delete the old; reversing that order crashes services, which is exactly the kind of lesson that got written into procedure). The first apps were promoted to production through a formal numbered gate: security audit, auth checks, credential rotation, monitoring. And the program learned to subtract: the first deliberate decommission batches retired apps that weren't earning their keep.
Era 3: A source of truth, a bank integration, and real backups (May). The spec system, until then a many-revision Word document, was migrated into a proper docs repo (a growing set of markdown files, static-site published, auto-rebuilt on every merge). From then on, the docs are the single source of truth: the AI greps them before making claims, and every infrastructure change updates them in the same session. The same month: a complete bank-account integration on my personal-finance app (link flow, atomic token exchange, nightly transaction sync, net-worth aggregation), a non-coder shipping bank-data plumbing end-to-end; a dedicated storage appliance joined as the backup tier and the whole fleet got nightly backups with documented restore tests (the dev box had run two months with none: found, fixed, procedure updated); and an AI-strategy session produced the single most load-bearing rule in the lab: all application AI traffic routes through one self-hosted gateway, with per-function model routing, cost caps, a kill switch, and full usage analytics, so no app ever talks to a model provider directly.
Era 4: The AI stack and the iOS suite (June). The lab's AI layer matured into a stack: a self-hosted agentic coding IDE (browser-based editor, Git-native, sandboxed builds with hard memory caps, per-phase model routing); a self-hosted retrieval search service built and live in a week (a full set of docs chunked, embedded locally, queryable by the other apps); and an AI assistant persona in front of it all. Then a sprint most people wouldn't expect from an AI-built lab: a suite of native iOS companion apps in about eight sessions, tested on a physical iPhone over the VPN. The same month, a silent CI failure mode was found and fixed across every deploy workflow, and a dedicated accuracy audit reconciled the docs against live state.
Era 5: Hardening and fleet maturity (July). A four-agent parallel security audit swept the fleet's apps and surfaced the classic self-hosted trap: a strong network perimeter had quietly become the only authentication on several internal backends. App-layer auth went in across the internal backends, file permissions and admin rights were tightened fleet-wide to least-privilege, and "the VPN is not an auth layer" became a written promotion gate. A managed host was chosen for the public website (so the lab never has to expose itself to serve it), and the last tunnel from the internet into the lab was deleted; as of that pass, nothing in the fleet was reachable from the internet. Then the fleet itself matured: a couple of additional business-class mini-PCs came in; the dev role moved off the original laptop onto one of them (every dev app migrated, the old laptop kept powered-off as a rollback, retiring the role, not just the hardware); and the other became a dedicated infrastructure hub for monitoring and backup orchestration, so a production outage can no longer blind the tools that watch production.
Era 6: Specialization, and the lab starts running itself (July). The fleet stopped being interchangeable boxes and specialized. A dedicated AI node came online: local models and a locked-down sandbox where untrusted agent experiments run, built so that a compromised agent can't pivot into the rest of the fleet. A second box was stood up as a clean-room reference stack running its own full application layer, deliberately separate from the rest of the fleet at the application layer while sharing the operational layer. The formerly public-facing box had its public role formally retired. And the most telling addition: an always-on agent box, a machine whose whole job is running the AI coding agent itself, plus a set of scheduled housekeeping jobs (repo and config syncs, a drift check, a mail fetch) condensed each morning into one plain-English brief email. On the same box I designed, trialled, and costed thirteen autonomous AI agent jobs built to patrol the fleet the same way: backups verified, certificate expiries, disk growth, port and config drift, spend digests. Ten earned a place in the lab; none run on a schedule. Those jobs carry enough privilege that the safety case for them is a human being there to approve what they do, so nothing runs unattended. The trial runs still caught real documentation drift, which is the point: four months in, I operated the lab through an AI; five months in, I'd built it thirteen jobs, measured every one, and decided none of them run without me watching.