Founders are often told to "just build an MVP", as if that answers the question. It doesn't. Build too little and you can't learn anything useful from real users. Build too much and you've spent months of runway on features nobody has asked for yet.
At JRC Software, we build MVPs for startups and scale-ups. Our aim is a first version that's small enough to launch quickly and solid enough to build on, so you aren't rewriting it six months later.
What an MVP is
An MVP is the smallest version of a product that lets you test your core assumption with real users and real data. A good one:
- solves one clear problem well
- keeps the feature set narrow, while the code underneath stays clean enough to extend
- produces usage data that tells you what to build next
- can go in front of paying customers or investors without hidden technical debt waiting to cause problems
Two ways MVPs go wrong
Overbuilding. Under pressure to impress investors or early customers, founders often ask for a feature-complete product before the core idea is proven. Launch slips, runway shrinks, and the product ends up shaped by guesses instead of feedback.
Underbuilding. The opposite is just as common. The MVP is built so quickly and cheaply that it breaks once real users arrive, or it can't be extended when growth comes. The team rebuilds from scratch a few months after launch, which costs far more than building it properly the first time.
Much of our job is helping founders avoid both.
How we approach it
1. Find the riskiest assumption. Before we write any code, we work with the founder to name the one assumption the business depends on most, such as "clinics will pay monthly for this" or "drivers will open the app every day". The MVP is designed to test that. Everything else waits.
On a booking platform we built for service businesses, version one tested one thing: whether a business owner would set themselves up by talking to a chat agent instead of filling in a form. It collected six fields and wrote them to a database. No bookings, no payments, no dashboard. Those were added in the weeks after launch, once the conversation held up.
2. Build a foundation that can grow, without over-engineering it. Building to scale doesn't require microservices and a complex cloud setup on day one. That's overbuilding too. It means sensible early choices: a clean data model, managed cloud services, automated deployments and code another developer can pick up easily. Our platform and cloud engineers make these calls early, while they're still cheap to get right.
On the booking platform, that meant leaving things out as much as putting them in. The first plan included an extra framework to manage the AI conversation. We dropped it and connected to the AI model directly, so version one shipped on just three libraries. It ran on a single Postgres database, managed queues for anything slow, and containers we didn't have to operate. The deployment pipeline went in during week two, ahead of most of the features. Seven months and a mobile app later, none of those choices have been replaced, and the framework still hasn't been needed.
3. Write a short spec. Moving fast still needs clarity. A lightweight spec keeps a small team agreed on what's being built and why. Ours run to a page or two, and the section that earns its keep is Open Questions at the bottom. For the platform's first feature, it asked whether users needed accounts, whether a half-finished session should be resumable, and how opening hours should be stored. The answers came back a line each, and the build started that same day.
4. Launch, measure and adjust. Once real users are in the product, we look at what they use, what they ignore, and where they get stuck. That data, together with the founder's judgement, decides what goes into the next release.
5. Stay for the scale-up. If the MVP works, the product usually needs to grow quickly. Our team also covers data engineering, AI, mobile and cloud cost management, so the people who built the first version can keep building it. You don't have to bring in a new team that spends its first months learning the codebase.
Why this matters for runway and fundraising
Every month spent building is a month of runway spent without proof from the market. A focused MVP puts early spending toward one question: will real users choose this product and keep using it?
It helps with fundraising, too. A working product with real usage data and a sound technical base tells investors far more than a demo.
Common questions about MVP development
How long does an MVP take to build? It depends on scope, but a focused MVP built around one core assumption usually takes us five to six weeks. The biggest factor is how strictly the scope is held.
How much does an MVP cost? Cost follows scope, so we agree the scope with you before we quote. In our experience, budgets are blown by features added before the core idea is validated far more often than by the build itself.
Should an MVP be built to scale from day one? It should be built so it can scale, without paying for scale you don't need yet. That usually means good foundations and managed services, with complexity added only when usage calls for it.
What's the difference between an MVP and a prototype? A prototype shows how an idea might work, often with no real backend. An MVP is a working product that real customers use, built to produce real usage data.
Building for the next stage
The startups that grow well usually get three things right. They build the right first version, they learn from it quickly, and they have a technical partner who can keep up as they grow.
If you're planning a first version, or have an MVP that's starting to struggle, we'd be glad to talk it through.
Have an idea ready to test with real users?
Let's talk about what version one should actually look like.