A system in production, not a prototype
Deployed at your domain with real accounts signing in and real documents going through it. The two weeks ends with something running, not a demo to evaluate.
Your budget buys three months of one developer.Or a working product in two weeks.
$20,000 flat for something your users sign into, with billing built in and your own model keys. If what you are building reads documents and decides, the hard part already exists and four products of ours are running on it.
The gap between a prototype and a team.
Below you are the builder tools. They get you a demo in an afternoon and then stall, because the part that was going to be your product is the part they cannot do.
Above you is a technical cofounder you do not have, an agency quoting six figures, or senior contractors at $15,000 to $25,000 a month. With $30,000 to $100,000 of your own money or a pre-seed round, that path spends the budget before the product works, and nobody in it carries any of the risk except you.
Almost nothing is built for the person in between: real money, a real idea, and no team to hand it to.
Our own products, live now
Four of our own, built this way, running now.
Cupel
Reads a policy and decides
Adjudicates commercial insurance policies against the certificates issued from them. Every finding cites the form language it came from, because the agency owner has to defend it to a general contractor.
IncidentFast
Interviews, then assembles
Runs the incident interview with the person who was there, reads the evidence photographs, and produces the OSHA report package ready to file. The input is a conversation, not a document.
S2Q
Writes into the system of record
Reads Stripe payouts and posts itemized entries into QuickBooks Online, matched to what the bank actually deposited. Reading is half the job. The other half is writing somewhere that already has rules.
docAnalyzer
Holds the corpus
Question answering across large document libraries with citations under every answer. 300,000 users, in production since 2024. This is the platform the three above are built on.
What the two weeks produces
Your rules, written down and encoded
The decisions it makes come from your process, captured during scoping and built into the pipeline. What a generic model would guess at, yours knows.
A citation under every output
Answers point back to the page and passage they came from. Whoever signs the output has to defend it, and a number with no provenance is not defensible.
A runtime that already exists
Document conversion, chunking, per-corpus search, and the agent loop are ours and already run four products. You are not paying for that to be written, which is why the price is a number and not a range.
Price
$20,000, flat.
One number for any project that fits the scope below. No discovery phase, no statement of work, no hourly billing, no rate card. If your project does not fit, we say so and you have spent an email instead of three weeks.
Scope
The fit test is Cupel, IncidentFast, or S2Q.
If what you are building is comparable in shape to one of those three, the price holds. docAnalyzer is the platform they run on, and something at that scale is not a two week project, so it sits outside this offer. We turn down what does not fit rather than quoting around it.
The questions that come up
I was looking for a technical cofounder, not a vendor.
Those are the same problem at different prices. A cofounder takes 20 to 50 percent of the company and the search takes months, with most of them ending badly. This takes two weeks and you keep all of it. If you still want a cofounder afterward you will be recruiting with something running instead of a deck, and you will get a better one. We will sit in on the technical interviews if you want a second opinion, and train whoever you hire on the stack.
Why not hire a developer or a team and build it properly?
That is the right answer once you know what you are building. Senior contract engineering runs $15,000 to $25,000 a month for one person, so a $60,000 budget buys three months and finds out at the end whether the product works. We have been on the supply side of that trade for ten years. It is a good way to build the second version and an expensive way to discover the first.
Can I raise money on something built on your runtime?
You own the product, the brand, the customers, the data, and the deployment. What you license is the engine underneath, the way you would license a database or a payments provider, and it can run inside your own cloud if that matters to an investor. If your investors want more than that, source escrow releases the code if we ever stop operating, and a perpetual commercial licence is available where the situation warrants one. Both sit outside the build price. Terms get written down before we start rather than discovered in diligence.
Two weeks is not a credible timeline for working software.
It would not be, from zero. The document runtime, the conversion sandbox, the search layer, and the agent loop are already built and already carrying production traffic. What takes two weeks is your process, your documents, and your decisions on top of them.
The four running todayWhat happens if the work turns out to be bigger than the price?
We tell you during scoping and we decline the project. A flat price only holds if we turn down what does not fit, so that is what we do. You get the answer in a day rather than three weeks into a procurement.
Who owns what gets built?
You own your data, your process, and the product you put your name on. Where it runs is a separate decision from the build: our shared cluster, a dedicated server we operate for you alone, or inside your own cloud or data center. The runtime underneath stays ours and keeps improving across every project, which is what holds the price at $20,000 instead of a rebuild each time.
Will our project end up in your portfolio?
No. Everything above is ours, built and operated by us, which is the reason we are free to show it. What we build for you is yours and stays private, including the fact that you are a customer at all if that is what you want. We do not need your work to prove we can do the work.
What happens after the two weeks are over?
It runs. Model costs go to your own provider account on your own keys, so usage bills at your provider price and you pick the provider. Anthropic, OpenAI, Google, Mistral and xAI are supported, along with OpenRouter for routing across several. We bill to keep it running, never per document or per user, so your growth does not change what you pay us. Continued development is a separate retainer and none of it has to be decided during the build.
What if we want our own engineers running it?
Then we train them. It is Node and SvelteKit with Postgres and Redis underneath, so an engineer you hire can learn it rather than inherit something only we understand. We run that as a paid handover with your people in it, not a document drop. This is also what makes taking it in-house real: code nobody on your side knows how to operate is not continuity.
Frequently asked questions
What people want to know before they send the first email.
What if my idea is not document shaped?
Then we are the wrong people and we will say so in the first email. Two weeks and one price only work because the document runtime already exists. A marketplace, a scheduling tool or a social product gets nothing from it, and you would be better served by the team you were already pricing.
The test is whether your product reads something and decides something. If it does, the hard part is built.
What do the two weeks actually look like?
A scoping conversation first, where we write down what gets read and what gets decided. That is where we find out whether the project fits, and it is also the part that determines whether the result is any good.
Then the build, against real documents rather than samples. Then handover: your domain, your accounts, your data.
What kinds of documents does this work on?
Documents that people read and then act on. Policies, contracts, invoices, forms, reports, inspection records, scanned paperwork. The common shape is that somebody opens the file, applies knowledge that lives in their head, and produces a decision or an artifact.
If nobody reads it and nothing is decided from it, this is the wrong tool.
Can our documents stay on our own infrastructure?
Yes. The service pool deploys as a unit, so it can run inside your own cloud account or your data center, with your documents never leaving it. The model keys are yours as well, so the inference calls bill to your provider account rather than through us.
Between that and our shared cluster there is a middle option: a dedicated server we operate for you alone. Same isolation, none of the operational work on your side.
The $20,000 covers the system we build. Where it runs is arranged separately, because a machine of your own and a tenant on shared infrastructure are not the same running cost.
Can we charge our own users through it?
Yes. The metering and checkout machinery that bills our own products comes with the system, so if what we build has users of its own you can price and charge them through it from the first day. We take no percentage of what they pay you.
Put next to your own model keys, that means both sides of the ledger are yours: what your users pay, and what it costs to serve them.
Why publish a price when nobody else in this category does?
Because the alternative is a discovery call, a proposal, and a negotiation, and that costs both of us more than the information is worth. A published number lets you decide alone whether to keep reading.
Can we see how you work before committing?
All four are live and you can use any of them today without talking to anybody.
Cupel, IncidentFast and S2Q are the ones built the way yours would be, so they show you the shape of the result. docAnalyzer is the platform underneath them, and it is the answer to whether this holds up under load: 300,000 users and millions of pages, in production since 2024.