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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.