---
title: >-
  MVP development: from idea to first users, with our own pipeline as the
  example
description: >-
  MVP development in four phases, shown on a real example: the blog pipeline we
  built, what version one left out, and what real use forced us to change.
author: elroot_labs
date: '2026-11-13'
categories:
  - buying-software
---
MVP development means building the smallest working version of a product that solves one real need, putting it in front of real users, and letting what they do decide the next version. The method is well documented: understand the problem first, test risky ideas cheaply, build the smallest real thing, then improve it from use. What the method guides rarely show is a real cut list and the changes real use forces, so this post uses one of ours: the pipeline that writes and publishes this blog. It worked, it broke in useful ways, and its most important lesson came from a failure none of its checks could see.

## What counts as a minimum viable product

The [US Digital Services Playbook](https://playbook.usds.gov/) gives the clearest definition we know: "Ship a functioning 'minimum viable product' (MVP) that solves a core user need as soon as possible." Two words carry the weight. Functioning means real use, so a slide deck or clickable mock-up does not count. Core means one need, so most of the feature list waits.

The UK Government Service Manual breaks the path into phases, and each one ends with a decision, including the decision to stop. We follow its order below.

## Phase 1: understand the problem without building anything

The Service Manual is direct about discovery: "You should not start building your service in discovery." The job is to understand the people with the problem, what they do today, and the constraints around them. It describes around 4 to 8 weeks as typical, and adds that "It's not a failure to stop at the end of the discovery phase if your research shows that's the best thing to do" ([how discovery works](https://www.gov.uk/service-manual/agile-delivery/how-the-discovery-phase-works)).

For our pipeline, the need fitted in a sentence: publish genuinely useful posts regularly, on topics the owner chooses, without anyone making up experience or numbers. The constraints mattered as much as the need. The writing would be done by an AI model running unattended, so anything it could get wrong without a human noticing had to be blocked by design rather than by instruction.

## Phase 2: test the riskiest idea with something you will throw away

The manual's alpha phase is for trying out different solutions with prototypes, building "things that are just complex enough to let you test different ideas, not production quality code," and expecting to throw that code away ([how alpha works](https://www.gov.uk/service-manual/agile-delivery/how-the-alpha-phase-works)).

Our riskiest assumption was that a simple, model-free check could reject the most common failures of AI writing: invented statistics, unsourced claims, filler phrases, dead links. If that did not work, the whole idea of an unattended writer fell apart. So the check came first, and the rest was built around it.

## Phase 3: build the smallest real version

Version one of the pipeline was built and running on 31 October 2026, and the first post went through it on 6 November. Here is what it did:

- A topic backlog. The run writes only topics the owner has approved.
- A quality gate in plain code, with no model involved, that rejects AI writing tells, numbers without a source in the same paragraph, unfilled gaps, dead links and near-duplicate posts.
- Review mode. Each draft becomes a pull request, and merging it is the publish button.
- One post is one file, with a publish date that keeps it hidden until its day.

The cut list mattered more. Version one would not choose its own topics, invent experience, quotes or numbers, touch the site's code, publish without a human merging it, or spend more than five sources and eight research calls on a post. Auto-publishing existed and was switched off. Every one of those limits made the product smaller and safer, and none of them stopped it from doing its one job.

## Phase 4: let real use decide the next version

The manual's beta phase is where you "take your best idea from alpha and start building it for real," starting with a small group and iterating "based on what you learn" ([how beta works](https://www.gov.uk/service-manual/agile-delivery/how-the-beta-phase-works)). These are the changes real use forced on our pipeline, in order:

| Date         | What real use showed                                       | What changed                                                     |
| ------------ | ---------------------------------------------------------- | ---------------------------------------------------------------- |
| 31 Oct       | The daily run redrafted a topic already waiting for review | It now skips topics with a draft open                            |
| 31 Oct       | The cloud sandbox could not always push its work           | Clear instructions for that case, then a move to a local machine |
| 31 Oct       | A local run can reach the whole internet                   | The gate enforces a list of approved source websites             |
| 6 Nov        | New posts had to be submitted to be found                  | Every new post is added to the sitemap and feed automatically    |
| 13 to 14 Nov | Some topics needed sources outside the list                | The list was widened per topic, then narrowed again              |
| 14 Nov       | Four topics could not be sourced honestly                  | They were removed from the backlog                               |
| 14 Nov       | The owner chose not to publish prices                      | The pricing post was blocked                                     |

None of those were predicted in version one. All of them were cheap to fix because version one was small.

## The failure the checks could not catch

The most useful feedback arrived on 14 November, and it did not come from the gate. The owner read a batch of posts that had passed every check, with sources, no AI tells and correct structure, and judged them hollow. The owner was right. They were accurate summaries of other people's documents, and nothing in them could only have come from us.

The gate measured what code can measure: whether a claim had a source, whether a sentence matched a known pattern. It could not measure whether a post said anything new. We paused publishing and reworked the posts around first-hand material: experiments run on our own content, measurements on our own machines, and the real history of our own systems, like this post.

That is the general lesson for any MVP. Automated checks tell you a product is working as built. Only people using it tell you whether it is worth using, so put it in front of them early, and read what they say even when the dashboards are green.

## How to run your own MVP

1. Write the core need in one sentence, in your users' words.
1. Name the riskiest assumption and test it first, cheaply.
1. Write the cut list before you write code: what version one will not do.
1. Ship to a small group, and record every problem they hit with a date.
1. Fix what real use shows, in the order it hurts.
1. Ask people whether it is useful, separately from whether it works.

If you buy MVP development rather than building it in-house, the early phases suit a time-and-materials contract with a ceiling, and the build suits a fixed price once the scope is written down; our guide to [fixed price vs time and materials](/blog/fixed-price-vs-time-and-materials) explains why.

## Frequently asked questions

### What is the difference between an MVP and a prototype?

A prototype tests an idea and is usually thrown away. An MVP is a working product used by real people, built to be improved.

### How long does MVP development take?

It depends on the problem and how much you cut. As a reference, the UK Service Manual describes around 4 to 8 weeks as typical for discovery alone. Our pipeline's first version was built in a day, because the need was narrow and the cut list was long.

### What should an MVP leave out?

Everything the core need can be met without, except the basics that make it trustworthy, such as security, backups and correct data.

If you have an idea you want to test properly before building, [tell us about it](/contact).
