The inspection gap, and how it gets exploited
When you can't read code, you're buying on proxies: the portfolio, the confident meeting, the price. All three are gameable, and the industry's recurring failures exploit exactly that. The vague-scope trap: 'we'll build your app, $12k' — with 'done' undefined, month three becomes a negotiation you can't win. The dependency trap: code in the vendor's accounts, no documentation, so switching costs a rewrite and staying costs whatever they quote. The complexity trap: an exotic stack that makes every future developer's first quote 'honestly, rebuild it.'
None of this requires malice — mediocrity produces the same outcomes. The defense is contractual and procedural: every protection a technical co-founder would provide by reading the code can be approximated by process a non-technical founder controls.
That process is the rest of this page.
Scope in plain English: the document that defines done
The single highest-leverage artifact is a scope document written in user language, not tech language: 'a visitor can sign up with email, create a listing with photos, and receive booking requests; the owner can approve or decline from a dashboard.' Fifteen to thirty such sentences define an MVP completely — and every sentence is testable by you, personally, without reading a line of code.
Equally important is the exclusion list: what version one deliberately doesn't do (payments processing? native apps? admin analytics?) — because scope disputes live entirely in the unwritten.
A good agency co-writes this with you before quoting; treat a vendor who quotes without it as a red flag in itself. At Chalk Labs, scoping is the first week of every MVP engagement precisely because the document protects both sides: you from drift, us from the eternally-expanding 'just one more thing.'
- 15–30 testable plain-English sentences define the build
- An explicit exclusion list for what v1 won't do
- Every sentence verifiable by the founder, no code-reading required
- Refuse quotes issued without a written scope
Ownership and payment mechanics that protect you
Ownership is binary and verifiable even by non-technical founders: the code repository, hosting, domains, and every third-party account (database, email, payments) live under your accounts, with the vendor added as a collaborator — never the reverse. Written IP assignment says everything created is yours on payment. Documentation — a README a future developer can start from — is a contract deliverable, not a courtesy.
Payment structure does the enforcement: 25–35% to start, the remainder tied to milestones you can personally test against the scope document ('I can complete a booking on my phone'), with the final tranche after deployment to your accounts. A vendor who resists milestone payments or founder-owned repos is answering your diligence question early.
Technology choice is the quieter protection: mainstream stacks (the boring, hireable ones) keep your future options open; exotic choices marry you to the vendor.
Costs, timelines, and how AI changed the math
Market rates for competent MVP builds run $7k–$25k, with AI-heavy products at $10k–$40k, delivered in 14–30 days at agencies with real pipelines. Quotes far below that band buy either an offshore template or a change-order ambush; quotes far above it, at MVP stage, usually buy agency overhead rather than product.
AI-assisted development is what moved these numbers — senior engineers now ship in days what took weeks — but it changed the risk profile too: 'vibe-coded' MVPs from unsupervised AI tools demo beautifully and collapse at the first real user, so the question for any vendor is who reviews the AI's output. (At Chalk Labs: senior engineers, on every build — AI multiplies them, it doesn't replace them.)
The founder's week-by-week rhythm on a healthy build: a scope week, then working-demo checkpoints every few days, each testable against the document. If demos are more than a week apart, or 'it's 80% done' arrives without something you can click, escalate — those are the two earliest signals every rescue project ignored.
Questions we hear about this
Through testable milestones: a plain-English scope document turns every feature into a sentence you can personally verify on your phone ('I can sign up, create a listing, receive a booking'). Working demos every few days against that document replace code-reading entirely.
Structurally: the repository, hosting, domain, and all third-party accounts sit under your accounts with the vendor as collaborator; IP assignment is written into the contract; documentation is a paid deliverable. Verify all four before final payment — each is checkable without technical skills.
Market range is $7k–$25k for standard builds and $10k–$40k for AI-heavy products, shipped in 14–30 days. Chalk Labs builds in the $10k–$40k band with scope documents, milestone payments, and founder-owned infrastructure as standard process.
Only with senior engineering review. AI-assisted development is why MVPs now ship in weeks at these prices — but unsupervised 'vibe-coded' builds demo well and fail under real users. Ask any vendor precisely who reviews the AI's output; the answer is the diligence.