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 NAS joined as the storage 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 where it mattered, 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: monitoring, backup orchestration, a warm-standby mirror of every Git repo, and network-wide DNS filtering, 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, the AI gateway, 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: its own git server, password manager, identity provider, and secrets store, deliberately separate at the application layer but joined to the fleet's monitoring and backups. 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. Coding sessions startable from my phone, an hourly mirror of every repo, and a growing roster of scheduled patrol jobs in which the AI audits the lab on a schedule (backups verified, certificate expiries, disk growth, port and config drift, spend digests), condensed each morning into one plain-English brief email. The patrols' first live runs caught real documentation drift, which is the point: four months in, I operated the lab through an AI; five months in, the AI also patrols the lab and reports back.