Requirements to Production in Eleven Days

My first commercial build, shipped solo: a client's requirements turned into a regulated, live SaaS — and the case for hiring one AI-CTO instead of a team.

Ivan Podtsebnev · naykip · a builder's log

This is the one I'd been waiting to write: a real commercial engagement, start to finish. A client came with requirements — not a specification, not wireframes, not a backlog. Just what the business needed the product to do. I turned that into a technical spec, designed the architecture, built it, shipped it to production, and I'm now on to support it and grow it. That's the full job a CTO owns — and I did it as one person managing one AI agent, in eleven days of wall-clock time.

I want to be precise about what that means, because the number sounds like a stunt and it wasn't. This isn't a landing page and a Stripe button. It's a regulated, multi-service system with real compliance, a real catalog, and a decision engine you can defend in front of an inspector. Here's what actually went on the board.

What the product actually is

The product is analog-pro — a suitability arbiter for low-voltage electrical equipment: breakers, RCDs, RCBOs, contactors. The domain is deceptively boring and genuinely hard. Not “what looks similar,” but “is this part a valid substitute for that one, and can you prove it?” When the answer feeds a wiring closet or a procurement order an inspector signs off on, a plausible guess is worse than none. So the core is a deterministic solver — the verdict is reproducible, reason-carrying, and never touched by an AI model. AI does the heavy data work (parsing vendor datasheets, reading trip curves, normalizing 30,000 parts), but strictly in the write-path, behind a human expert gate. It never makes the call.

And it's regulated. The system is split along a data-residency line: personal data lives in a region tier, kept in-jurisdiction and never replicated across borders; the catalog and the matcher live in a separate center tier that holds zero personal data; the two talk over mutually-authenticated gRPC. Before go-live: registration as a personal-data operator with the regulator, payments through a compliant processor, a security-hardening pass, and a live end-to-end control payment (checkout widget → webhook → access grant). This is GDPR-class data isolation, not glue — it's the shape of the thing.

This is the depth a client is really buying: not a form and a database, but a regulated, auditable decision system — delivered at solo speed.

Why eleven days, and why it holds up

Speed with no discipline is just debt you haven't been billed for yet. The reason this shipped fast and survives contact with production is the method, not heroics. Everything ran task-first, one thread at a time (WIP = 1) — 287 tasks tracked, 221 closed. Every change went branch → code → verify on a live database → pull request → merge: 177 commits through review, zero direct pushes to master. The test suite is real, not decorative — roughly 0.62 lines of test for every line of production code. Thirty-plus tagged releases mean it was shippable continuously, not in one terminal big-bang.

That's the part the “AI wrote my app” demos skip. An unmanaged agent ships fast and leaves a swamp. The value I bring isn't a faster typist — it's the management layer that keeps a good model on a long, hard, regulated build without it drifting, cutting corners, or quietly forgetting the goal. Fast is easy. Fast and auditable is the product.

The eleven days aren't the whole story

I want to be honest about where the speed actually comes from, because it isn't a trick and it isn't corner-cutting. It comes from a long stretch of unglamorous work done before there was ever a client — building the tools. My own platform: a project-and-release server, a from-scratch database, an ML stack in Rust, and, above all, a discipline for keeping an AI agent on long, hard, multi-layer work without it wandering off. That backstory is its own piece — the one-person foundry — and analog-pro is the first time I pointed that whole apparatus at a paying client's problem.

So the eleven days are the dividend of the tooling, not a heroic sprint. And that's the quiet part worth saying plainly: the hard, slow, build-it-once work — the machinery that makes complex delivery fast and safe — is already done. A new order doesn't pay to build it again. It plugs into it.

The tools took months to build. Because they exist, an order of almost any complexity is now a matter of weeks — not quarters.

The honest comparison

Because I don't publish a scoreboard I'd flinch at, here's the same build the normal way versus this one:

The point of the table isn't “cheaper.” Cheaper is easy if you also accept worse. The point is cheaper without worse: every commit reviewed, every verdict reproducible, the whole thing compliant on day one. Faster, less expensive, and held to a standard a team would be proud of.

The takeaway

A lot of people reading this have a project they've quietly shelved — not because it's a bad idea, but because the team quote was too big and the timeline too long. Here's the part I'd gently point at: the reason analog-pro went from requirements to production in eleven days is that the expensive, once-only work was already done. The tooling exists. The method is proven. What's left, for your project, is the part that was always supposed to be the point — building your product — and that part is now measured in weeks. Complexity isn't the obstacle it used to be, because the machinery for handling it is built.

one AI-CTO — requirements to production, then support.