Ship the smallest version people can actually use.
You already know the mechanic works. Maybe you built it yourself over a few weekends. Maybe you proved it with us as a prototype. Either way, the people who've seen it keep saying the same thing: that's a good idea. None of that answers the only question that actually matters now. Will a stranger, alone, with no one standing over their shoulder to explain what they're looking at, actually use this more than once? Roughly four in ten startups that fail point to the same root cause when the postmortem finally gets written: nobody wanted what they built. There's exactly one way to find that out before you've spent a year finding it out the hard way. Put a real version in front of real people and watch what they actually do. MVP means minimum viable product, not most valuable product, a mix-up worth heading off early. It's the smallest real version that can actually answer whether people want this, not a full-blown app.
Where this sits
Below this, a prototype proves the mechanic runs, verified live together, with you in the room. Most MVPs built here start there, since a Prototype lets a working relationship begin before committing to something heavier. That's real proof, and it's the right amount of it for a decision this size. It's the wrong amount of proof for whether you should quit a job, or ask friends and family for money, or spend the next year of your life on this. Strangers behave nothing like a friendly test audience with you standing right there to explain the confusing part. They skip your instructions, they misread your interface, they close the tab the second something doesn't make sense, and they never tell you why. An MVP takes the mechanic that already proved out and builds it into something that can survive contact with people who owe you nothing: real accounts, real sessions, data collected without anyone in the room to interpret it for them. That's a bigger build, and a different one. It's also the only way the question "does anyone want this" gets answered for real instead of hopefully.
What you get
- The application itself, built and deployed live, scoped to what your first real users actually need rather than a wishlist of what they might need someday.
- A layered architecture, view, business logic, and data kept separate, so a screen, a flow, or a whole feature can change without tearing up the foundation underneath it.
- A real handoff: documentation kept current as it's built, your full project history in a format you can actually keep, and a ninety-day warranty against anything that doesn't match the spec.
- The infrastructure your app actually runs on: hosting, database, authentication, email, error tracking, and analytics, named and set up rather than left for you to assemble.
- Privacy and security basics built in from day one: cookie consent, encryption, a real authentication provider, and a real way for a user to delete their own data.
- A named, bounded advisory option after launch, for the times you want us back in the room without signing up for anything ongoing.
Everything below is written out in plain language: what's included by default, what's billed to you separately and why, and where the edges actually are. What all of it costs is on the pricing page.
What these terms mean
Built to bend, not to hold
The foundation everything else sits on, and what it buys you the first time you need to change your mind.
- The layered architecture
- Your app is built in three separate layers: what a person sees, the logic that decides what happens, and the data underneath it. Because they're kept apart instead of tangled together, you can redesign a screen, rework a flow, or run an A/B test on a whole feature without touching the layers underneath it. That includes building the frontend, setting up the databases underneath it, and wiring up communication with the third-party services your product depends on. Design is genuinely part of the scope too, not an afterthought, and building it well takes real time, which is part of why the hours on a Level look the way they do.This is about the shape of what you're handed, not an ongoing promise to keep rebuilding it for you. If you want us doing that work regularly after launch, that's the advisory option below, named and priced on its own terms.
- Who owns it
- The code, the architecture, the decisions behind it: yours, outright, the day it ships. Nothing about this build depends on you staying a client to keep using what you paid for.
- How complex your idea is
- MVP pricing doesn't work like a menu of add-ons. What actually moves the price is risk: whether a mistake in the finished system surfaces immediately and gets caught, or hides and compounds silently until it's already done damage. The pricing page lays out the Levels that creates, with real examples in each one.
What you walk away with
The build ends with an actual handoff, not a login you inherit and a channel that goes quiet. Four pieces, always included.
- Documentation
- Auto-generated component and API references that stay current as the system is built, plus a written layer on top: an architecture overview, a setup guide, and a log of the decisions that shaped it and why.
- Your project history
- The full build record, every ticket and every change, handed to you in a portable file you can open and keep. Not a login to a workspace you'll lose access to eventually. Something that's actually yours.
- Ninety-day warranty
- For ninety days after launch, if something doesn't do what the spec said it would do, we fix it. That's the whole scope. It doesn't cover new features you think of afterward, and it doesn't cover the market deciding it doesn't want what you asked for. It covers whether we built what we agreed to build.
- Advisory, if you want it
- A named, paid, bounded option for after the warranty window closes: a block of our time, on your terms, whenever you actually need us back in the room. It isn't a retainer, and we won't try to talk you into one. Our aim is to keep building new MVPs for new founders, not to become anyone's permanent outsourced dev team.
- Privacy and compliance basics
- Bundled in by default: cookie consent, encryption, a real authentication provider, and a real path for a user to delete their own data. We architect it. You own it, and the legal and policy decisions on top of it stay yours.
How you'll know it's running
The services your MVP actually runs on. Named upfront and billed to you directly, because it's an ongoing cost of keeping the thing alive, not a one-time cost of building it.
- The default bundle
- Hosting to keep it live. A database, authentication, and file storage, set up twice, once for development and once for the real thing, so testing never touches real user data. A dedicated authentication provider. Transactional email. Error tracking, so we know something broke before your users have to tell you. Analytics, session replay, and feature flags, so you can actually see what people are doing with it.
- Why a full stack instead of the cheapest option
- A bare database is cheaper sitting idle. It also leaves you, or us, to assemble authentication, file storage, and access rules by hand. We chose a stack that comes with the whole thing working together, because you're a founder trying to learn whether people want your product, not a founder who also wants to be a part time database administrator.
- Going deeper, if you want it
- Usability testing and a real feedback channel for the people already using it. Optional, your call, billed separately if you want it added.
Costs that scale with what you build
A separate menu from the bundle above, identified and estimated during discovery because what you actually need here depends entirely on what you're building. We estimate it and we cap it. We don't control it and we don't mark it up.
- AI and language model calls
- If your product calls an AI model to do its thinking, those calls are billed by usage. We estimate the range during discovery and keep a cap on it.
- Vector search and retrieval
- If your product needs to search across its own content or remember something about a user over time, that's a vector database, scoped and priced as its own line.
- Voice and audio pipelines
- If your product listens or speaks: real time voice infrastructure plus speech to text and text to speech, the same category of stack running underneath Discourser.ai, the voice practice tool we built ourselves. Estimated up front, not discovered on your first bill.
- Image and media generation
- Generated imagery or media, billed by usage from whichever provider fits what you're building.
- Payments
- Processing fees from a provider like Stripe. Standard, and outside anyone's control but theirs.
Every one of these has a price on the pricing page.
How it runs
- Formative
Free first conversation
We talk about what's already been proven and what's still an assumption. No scoping work yet, just finding out if this is a fit.
- Formative
Paid discovery
Real diagnostic and planning work: what has to exist for a first real user, what can wait, the architecture, and the infrastructure bundle your specific product actually needs. It ends in a written spec and a real timeline, not a sales deck.
- Legible
You approve the spec
The real gate. Nothing gets built until you've read the spec and signed off on it.
- Architectural
Milestone based build
Payments tied to milestones defined in the spec, not to the calendar. The spec defines what gets built and by when. If the work takes longer than planned for reasons on our side, that's on us. If what you're asking for changes along the way, that becomes a documented change, priced and approved before it starts.
- Legible
Launch
Deployed live, real infrastructure running underneath it, and your first real users able to reach it on their own.
- Calibrated
Ninety-day warranty window
If something doesn't match the spec, we fix it. That's the whole scope of the warranty, and it's enough to know the thing you paid for is the thing you got.
- Legible
Advisory, if you want us back
A named, bounded, paid option once the warranty window closes. Not required, and never automatic.
What this isn’t
This isn't a system we keep polishing forever. We hand you something built to outlive us: documented, exportable, warrantied for ninety days against anything that strays from the agreed spec. If you want us back in the room after that, that's a real, bounded conversation you start when you're ready, not a subscription running quietly in the background. It isn't a guarantee that people will want what you build, and we won't pretend it is. We're accountable for whether the system does what the spec said it would do. Whether the market wants it is the question this tier exists to help you answer, and that answer belongs to you, whichever way it comes out. It isn't open-ended scope, either. On a real build, something usually changes along the way, and when it does, that becomes a documented change: a new estimate, your approval, then the work resumes. Nothing gets absorbed silently and argued about later. If you already know the mechanic works and you're ready to find out if it's a business, this is where that starts. A real spec, a real timeline, a real answer, before anything gets built.
Still deciding between tiers, or wondering what a project actually costs? See how the tiers differ and what a project costs on the FAQ page.