Process
From the first call to acceptance — no surprises
Every order travels the same well-drilled path: a call, an audit, a fixed quote, three weeks of build. This page lays out the whole process — including what you see on each of its days, and the terms we sign.
The engagement path: four steps, two of them free
Before the production line starts, you know everything: what gets built, what it costs and when it's ready. The call and the quote cost nothing; you pay for the audit — a fixed price from a tiered list — and for the build, at the binding quote you know before the start.
- 01free
Call
10 minutes — a form or a call: your systems, your processes, what hurts.
- 02fixed price by company size
Audit
An AI-assisted analysis of your business: agents map where AI pays off first, a senior engineer sets priorities and signs the report. You pay a fixed amount from the price list — the tier depends on company size — and the report is yours to keep whatever you decide next.
- 03free
Quote
A binding fixed quote for the chosen prototype: scope, acceptance criteria, price, date. Until the quote, you take on no commitment.
- 04per quote
Build
Three weeks, following the schedule above.
Three weeks of build — day by day
The schedule isn't a declaration — it's the line's work plan, with results you see on specific days. Day 10 is your checkpoint; day 21 is acceptance of the finished system.
- 1–3Scope
Kickoff and specification. Together we write the full document base — scope (what's in and, explicitly, what's out), acceptance criteria, data access, target environment — and you sign it.
What you see:The specification document, ready to sign — the project's first and most important artifact.
- 4–9Build I
The line starts: an isolated environment stands up on day one of the build, agent cycles run in parallel, every change is machine-reviewed, QA tests live, and integrations get wired to your systems.
What you see:Access to the test environment — watch the system grow.
- 10Checkpoint
The first formal review: we sit down together over the running system. Course corrections are free at this stage — that's what this day is for.
What you see:A working system plus the list of what's ahead. Your feedback enters the plan.
- 11–16Build II
Your checkpoint feedback is already in the agents' plan. Edge cases and failure paths come in. By day 16 the system meets every criterion.
What you see:New features appear in the test environment day by day.
- 17–19Proof
We harden the system and run a full QA pass — evidence recorded step by step. At the end a senior engineer signs off: the human gate before acceptance.
What you see:The evidence pack grows: logs, traces, screenshots — mapped to your criteria.
- 20–21Delivery
You accept the system criterion by criterion, evidence pack in hand. Then the full handover — credentials, documentation, deployment notes — and a binding quote for the production version.
What you see:Your system, your credentials, your documentation. And a production quote, if you want to go further.
The date you sign is the date you get. The agents don't sleep, don't jump between projects and don't take other clients' calls — that's where the three weeks come from. Bigger scopes get a longer schedule at the quote stage, with the same date guarantee.
Standing terms — the same for every order
We don't negotiate them, because they are what makes the dates and prices possible. You sign exactly what you see.
- 01
Documentation first, then the build. Every order starts with a signed specification: scope, per-stage acceptance criteria, data access, target environment. Until you sign it, the build doesn't start — and the clock doesn't run.
- 02
A fixed quote first. A binding price and date for every stage — before the build begins. No hourly billing, no creeping scope.
- 03
Acceptance, item by item. You accept against the criteria you signed — one by one. Every stage includes two revision rounds.
- 04
Your data, isolated. Every client gets a separate environment; data never mixes with anyone else's. We get access for the project and hand it back at close. Your data never trains any model.
- 05
Your production environment stays yours. The AI line has no access to your production environment. Deployment is done by a human, on a date agreed with you.
- 06
Evidence, not assurances. Every delivery includes machine-recorded test evidence, mapped to your acceptance criteria.
- 07
Warranty. 30 days on every delivered stage — defects reported in that window are fixed free of charge.
Common questions
What if I change my mind about the scope midway?
Day 10 exists exactly for this — course corrections are free then. A change beyond the signed scope becomes a new stage with its own quote: no penalties, no quiet deadline drift.
Who owns the code and the system?
You do. We hand over the repository, credentials, documentation and deployment notes. No license fees on our code, no dependence on us.
What do you build on?
We pick the stack for the case — market standards, nothing exotic, no locking you into a single vendor. Sensitive systems are built to run entirely inside your infrastructure.
What happens after acceptance?
30 days of warranty on the delivered stage. Then it's your call: run the system yourself, or order the production version at the binding quote you receive at delivery.
"Prototype" — so, a hollow demo?
No. It's a working system on real integrations, with QA and evidence — "prototype" describes the scope, not the quality. The production version adds scale, monitoring and hard SLAs.
100%
deliveries at a fixed price and date
24/7
the line never stops
40+
systems delivered
See what the factory can build for you.
A 10-minute call is enough to start the audit. We send back a proposal within 2 business days.