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.
Somebody at your company reads documents and decides something.We build the system that does it.
Two weeks from scope to production. $20,000 flat. We built three of our own products this way, on a platform serving 300,000 users. All four are live and you can use them today.
The category sells you a project. You wanted a result.
Enterprise document platforms are good at what they are for: millions of pages, deep compliance, human review at scale. Buying one means a procurement cycle, a pilot, an implementation partner, and months before the first document goes through.
That arithmetic works when you are buying a document strategy for the whole company. It falls apart when you have one process, one person who knows how to run it, and no reason to spend six months fixing that. Volume is not the dividing line, since the runtime underneath already handles millions of pages. The difference is that you do not have to buy a platform to get one process working.
Our own products, live now
Four systems, four different jobs.
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 your process is comparable in shape to one of those three, the price holds. docAnalyzer is the platform they run on, and rebuilding 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
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 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.