MVP Development
A first version narrow enough to ship and solid enough to keep
We build one core workflow to production quality rather than six features to demo quality. You get something real users can rely on, instrumented so you can see what they actually do, on a codebase your own engineers can take over without a rewrite.
- Typical timeline
- 8 to 12 weeks to production
- Scope
- One core workflow, built properly
- Ownership
- Your repository and accounts from day one
(01)Overview
What this covers
First versions fail in two directions. Built too broadly, they run out of budget before anyone uses them and the feedback never arrives. Built too cheaply, they get traction and then have to be rebuilt, which costs more than doing it correctly the first time and happens at the worst possible moment.
We take a different cut. We pick the single workflow that carries your product's value and build that to a standard you can run a business on: proper authentication, a data model that will not need unpicking, tests on the paths that matter, automated deployment, and error tracking. Everything else is deliberately deferred and written down as deferred.
The point of the first version is information. We instrument the product so you can see where people start, where they stop, and which assumptions in your plan turned out to be wrong. That evidence is what should determine the second version, and it is far cheaper to collect from a narrow product that works than a broad one that nearly works.
(02)Capabilities
Capabilities
A single team covering the path from decision to production.
- 01
Scope definition
A short discovery that identifies the core workflow, the users it serves, and the assumptions the first version needs to test. The output is an explicit in-scope list and an equally explicit deferred list.
- 02
Interface design
Screen design for the flows being built, as a component set rather than one-off mockups. Enough design system to stay consistent as the product grows, without the overhead of a full brand programme.
- 03
Application engineering
Web and mobile front ends with a typed API and a relational data model designed for where the product is going, not only for the first release. Migrations are versioned from the first commit.
- 04
Accounts, billing, and permissions
Authentication, organisations, roles, and subscription billing implemented with established providers rather than written from scratch, because these are the parts that are expensive to get wrong.
- 05
Deployment and monitoring
Automated deployment from your main branch, separate staging and production environments, error tracking, uptime checks, and backups verified by restoring them at least once before launch.
- 06
Product analytics
Event tracking on the funnel that matters, set up so you can answer where users drop off and which features are used, without having to ask an engineer to run a query.
(03)What you get
What you receive
A running product and the means to continue without us, from the first week.
- A production application serving real users, on your own domain
- Source code in your repository, with commit history from the first day
- Cloud accounts, DNS, and third-party services registered in your name
- Automated deployment, staging and production environments, and verified backups
- A technical handover document covering architecture, data model, and operational tasks
- An analytics dashboard on the core funnel, plus the written list of deferred scope
(04)Process
How we work
Two-week increments against a fixed scope, with a working deployment you can use from the end of the second week.
- 01
1.Discovery and scope
One week. We work through the product idea, the users, and the commercial constraints, then agree the core workflow and write down what is deliberately excluded. You receive a scope document, an architecture outline, and a fixed estimate.
- 02
2.Foundations
Weeks two and three. Data model, authentication, deployment pipeline, and environments. At the end of this stage there is a deployed application you can log into, which is where feedback starts.
- 03
3.Core build
Weeks four to ten. The main workflow is built in two-week increments, each ending with a review on the staging environment. Changes are accommodated by trading scope against the deferred list, not by extending the timeline silently.
- 04
4.Launch and handover
Final weeks. Production hardening, analytics verification, backup restore test, and a recorded handover walkthrough. Thirty days of support follow launch, after which you can continue in-house or on a retainer.
(05)Technology
Technology
Deliberately conventional choices, so you can hire for them and another team can pick the codebase up.
- Front end
- Next.js
- React
- TypeScript
- Tailwind CSS
- Back end
- Node.js
- Python
- PostgreSQL
- Prisma
- Platform
- Vercel
- AWS
- Supabase
- Stripe
- Operations
- GitHub Actions
- Sentry
- PostHog
- Playwright
(06)Questions
Questions we are asked
What does a first version cost?
It depends on scope, and we give a fixed estimate at the end of the one-week discovery rather than before it. Discovery is paid and self-contained: if you decide not to continue, you keep the scope document, architecture outline, and estimate and can take them to any other team.
Do we own the code?
Yes, from the first commit. Work happens in your repository under your organisation, and cloud and third-party accounts are registered in your name. There is no transfer step at the end and no licence to negotiate.
What if we need to change direction mid-build?
Expected, and handled through the deferred list. Scope can be exchanged at any increment boundary at no extra cost. Adding scope without removing any moves the timeline, and we tell you by how much before the change is accepted.
Will this hold up if the product gets traction?
The foundations are built to carry growth: a normalised data model, versioned migrations, automated deployment, and monitoring. We do not pre-build for scale you do not have, but the architecture is designed so that scaling is an incremental change rather than a rewrite.
Can our own engineers take over?
That is how most engagements end. The stack is conventional, the handover document covers architecture and operations, and the code is written to be read. Teams typically take over at the end of the thirty-day support window.
Other services
Start a project
Start with discovery
A week of structured work to establish what the first version should contain, how it will be built, and what it will cost.