← All writing

Building an MVP for early-stage SaaS around one testable assumption

Building an MVP for startups? Define one testable assumption, scope the smallest release and decide when to continue, change or stop.

Blank pages and a burnt orange tab mark the decision point in an MVP workflow.

You have a scoped v1, an unfinished codebase or a product that needs you beside every user. Advice about building an MVP for startups often jumps straight to features; you need to decide which customer assumption the next release will actually test.

Write the claim that could change your roadmap

A minimum viable product is a limited release that lets real users attempt a useful task and gives you evidence for the next product decision. The useful limit is how much you need to develop to learn something consequential.

Start with a claim about behavior. “People need better task management” leaves too much room for interpretation. A narrower claim might be: “Team leads handling requests in a shared inbox will return to a queue that helps them assign those requests.”

That example is hypothetical, not a client story. It gives us one workflow to follow through the article.

The risky assumption is repeat use. A polished interface, an enthusiastic interview or a successful demonstration cannot settle it. Someone needs to encounter the problem again and choose the product again.

Write down what changes if the claim holds and what changes if it fails. A pass might justify developing an integration. A failure might mean changing the workflow, choosing another user or stopping this direction.

If either result leaves your roadmap unchanged, choose a more consequential assumption. The experiment should help you decide where the next piece of runway goes.

Choose the smallest format for building an MVP for startups

You may not need new software to test the assumption. Choose the experiment based on what you need to observe, including what the experiment cannot tell you.

FormatWhat it can help testWhat remains unproven
Landing page with a specific next stepWhether the promise earns enough interest to start a conversationWhether people can use the product or return to it
Clickable prototypeWhether someone understands the workflow and can navigate itWhether the underlying service delivers the result
Disclosed manual serviceWhether the outcome matters in a real workflowWhether software can deliver it at an acceptable cost
Thin working releaseWhether people complete and repeat the taskWhether demand extends beyond the initial participants

For the request-assignment example, a founder could first provide a disclosed manual queue using approved, limited inputs. That could reveal whether team leads return for the outcome before anyone develops automatic suggestions.

Be explicit about manual work. Participants should know when a person can see their inputs and which actions require their approval.

Move to a working release when the uncertainty concerns actual product behavior, such as whether users trust a suggestion enough to confirm it. A prototype cannot answer that question faithfully.

Recruit around the existing workflow

Recruiting is part of building an MVP for startups: without people who actually face the problem, you cannot run the test.

Define participants by observable circumstances. For this example, look for team leads who already receive requests through a shared inbox, assign them to others and encounter that task repeatedly. “Busy teams” is too broad to recruit against.

Ask people to walk through a recent occurrence. Where did the request arrive? Who assigned it? What happened when ownership was unclear? Use redacted examples or approved sample inputs rather than asking for unrestricted inbox access.

Separate the person doing the work from the person who can approve spending. Repeat use can support a value claim, but it does not establish that someone has budget or permission to buy.

Record recruitment conditions alongside the results. A friend helping you test, a founder who shares your enthusiasm and someone actively looking for a replacement bring different expectations.

If you already have users, inspect the relevant support messages and product events before recruiting another group. Confirm that the events actually capture the behavior you care about. A page view labeled “assignment complete” is weak evidence if no assignment was saved.

Set the decision rule before development starts

The difficult part of building an MVP for startups can be writing down what would make you stop. Do it before you have a release you want to defend.

Here is an illustrative test brief for the request queue. These numbers are chosen planning thresholds, not industry benchmarks or evidence of market size.

Part of the testWritten rule
ParticipantsSix team leads from six separate companies with recurring request-assignment work
Observation windowTwo weeks in which each participant expects normal intake work
Primary resultAt least four participants assign real requests on two separate days without founder reminders
Safety boundaryPause the test if information appears in the wrong account or assignments disappear without explanation
Interpretation limitRepeat use does not establish willingness to pay or demand beyond this group

Define the event precisely. Opening the queue does not count as assigning a request. A founder entering assignments on someone’s behalf does not count as independent use.

Also record setup failures and missing opportunities to use the product. Someone who never receives a request provides different evidence from someone who receives requests and chooses the old workflow.

The threshold helps you make a bounded decision. It does not turn a small, deliberately selected group into a representative market sample.

Make every feature answer to the test

A feature belongs in scope when it helps observe the assumption or makes participation safe. That rule keeps building an MVP for startups tied to evidence instead of an expanding backlog.

For the queue, the essential path might be: add a request, suggest an owner, let the team lead confirm the assignment and retain the result for the next visit. The participant must be able to complete that path without you operating the product for them.

A reporting suite, elaborate notification settings and several integrations can wait unless the test depends on them. A narrow input method may be enough before connecting a whole inbox.

One assumption can still require several features. Authentication, account separation and saved state may all be necessary to observe repeat use. Cutting one of them merely to reduce the feature count could invalidate the experiment.

Write the exclusions beside the included workflow. Otherwise, a reasonable request during development can quietly become another commitment.

Keep a separate place for later requests. Capture the underlying problem and who experienced it, but do not move it into the release automatically. Ask whether the current test becomes impossible or misleading without it.

Keep the first release safe enough for real use

A deliberately small release still needs boundaries around data, access and failure. Those boundaries belong in building an MVP for startups, even when only a handful of companies participate.

Collect the least information the workflow needs. If a request title and selected owner are enough, avoid copying an entire conversation history. Explain what is retained, who can access it and how participants can leave the test.

Account separation needs an explicit check. A participant should not be able to retrieve another company’s requests by changing a link or identifier. Secrets should stay out of browser-delivered code and shared documents.

Accessibility belongs in the working path too. Check keyboard navigation, understandable labels and error messages that explain what the user can do next. A blocked participant cannot provide meaningful evidence about value.

Decide how someone reports a failure and who responds. Verify the recovery path for saved assignments rather than assuming a backup exists. Narrow scope makes these checks more manageable; it does not remove them.

For a fuller treatment of these boundaries, use this guide to where security fits in MVP development alongside the test brief.

Put one accountable person over the codebase

You need a named person accountable for technical delivery while building an MVP for startups. An app builder, a contractor and a coding agent each leave decisions that somebody must own.

That person needs to understand the release path, review changes, investigate failures and keep the product maintainable. For a technical founder, the constraint may be attention across product, sales and fundraising. For a non-engineer founder, it may be the absence of anyone able to judge the implementation.

Agentic engineering puts coding, test, security and documentation agents inside a workflow owned by an accountable engineer. Agents can prepare changes and checks. The engineer reviews the work and owns the technical release decision; the founder approves scope, spending and customer promises.

Agents do the work. You make the decisions.

The company should control its repositories, hosting accounts, domain, data and deployment credentials. Verify that another engineer could obtain access and reproduce the release without depending on a contractor’s personal account.

Choose between a first hire and outside technical ownership based on the work that follows the test. If the company needs daily engineering decisions across several product areas, account for that ongoing responsibility. If the immediate need is one bounded experiment, define who owns it through launch, observation and maintenance before expanding the arrangement.

A simple MVP workflow shows scope, draft, review and accept in sequence.

Ship a weekly deliverable the founder can accept

Turn the test brief into small deliverables with a written definition of done. Each should leave something demonstrably usable, observable or safer than before.

For the queue, a useful deliverable could be: “An invited participant can add a request, confirm an owner and find the saved assignment after signing in again.” Acceptance would include demonstrating that path, checking account separation and showing the recorded completion event.

That is specific enough for the founder to evaluate without personally inspecting every implementation detail. A non-engineer founder can review the behavior and evidence. A technical founder can inspect the change without becoming the default person finishing it.

Keep the acceptance record with the deliverable. Include what changed, what was checked, known limitations and the founder’s decision. A demonstration alone leaves too much room for disagreement later.

If the deliverable does not fit the next shipping cycle, reduce the workflow or resolve the blocking uncertainty first. Do not disguise unfinished work behind a percentage-complete update.

The useful unit when building an MVP for startups is an accepted customer workflow, supported by evidence that it meets the written definition of done. A pile of generated code does not establish that a participant can complete the task.

Measure the cost of a completed outcome

Record usage and cost from the first working release. You need enough detail to connect an attempted task to its result and the resources consumed along the way.

For the queue, capture whether a request was submitted, whether an owner was suggested, whether the suggestion was changed and whether the assignment was saved. Record failures and retries as well as successes.

If suggestions use a model, attach model usage to the relevant attempt. A low cost per call can hide several retries, abandoned requests or extensive founder correction. Look at cost per completed assignment and the range across different inputs.

Keep manual interventions visible. A workflow that appears independent may depend on you correcting records or reminding participants to return. Those interventions affect both the test result and the work required to keep the product running.

Before approving more development, compare the proposed work with the uncertainty it removes. This approach to testing development cost estimates helps separate a bounded deliverable from a quote full of unresolved assumptions.

This is where building an MVP for startups can expose a pricing assumption: the product may deliver value, yet require more ongoing work than the intended price can support.

Interpret the result before adding more scope

At the end of the observation window, compare the recorded behavior with the original rule. Start with events and intervention records, then use conversations to explain what happened.

If participants repeat the workflow without prompting and the safety checks hold, choose the next uncertainty. That might be willingness to pay, an integration requirement or whether another participant group behaves similarly. A pass supports another bounded commitment.

If people try the queue but return to the inbox, inspect the point of abandonment. They may distrust the suggested owner, need context the queue removes or simply prefer their existing method. Those explanations call for different experiments.

If setup prevents participation, the test has revealed an access problem. Fixing that problem may justify another run, but document the change. Do not silently count an incomplete experiment as evidence for demand.

If participants complete the task and still find little value, reconsider the promise or the user group. More features need a reason grounded in what you observed.

Evidence from building an MVP for startups should change the next commitment of time and runway. Write the decision beside the original assumption so that future roadmap discussions retain the reasoning, including evidence that disappointed you.

Apply the test to the codebase you already have

An existing v1 changes the starting point. Before commissioning a rewrite, check whether the current product can support the chosen experiment with a bounded change.

Establish what runs, where it runs and whether you can release it again. Confirm control of the source, environments and data. Then identify the smallest part of the workflow that needs to change or become observable.

An app-builder product may still be useful for testing repeat use even if it cannot support the intended long-term architecture. A contractor-built v1 may need a repaired release path before another feature. A coding-agent prototype may need independent review before real participant data enters it.

Keep those findings separate from product demand. A deployment problem does not prove that customers reject the workflow. Equally, enthusiastic users do not establish that the company can maintain the product safely.

The test should determine how much code you change when building an MVP for startups. Preserve working behavior where you can verify it, repair what blocks the experiment and make any larger replacement decision against explicit requirements.

Frequently asked questions

What is an MVP for an early-stage SaaS? It is a limited working release that lets real users attempt a useful task and produces evidence for a product decision. Its scope follows the assumption being tested, including the safeguards needed for real participation.

Can I test demand before developing software? Yes. A specific offer, a prototype or a disclosed manual service can test parts of demand. Record the limits: interest does not establish repeat use, and a manual service does not establish software delivery cost.

How long does building an MVP for startups take? Scope depends on the workflow, existing codebase and access to participants. Set an observation window separately from development. Approve a bounded deliverable after the technical owner understands what already exists and what must change.

Does an MVP need an AI capability? Only when that capability is necessary to the promise or the assumption being tested. If it generates suggestions, keep acceptance and correction observable so you can see whether users benefit from them and what each completed outcome costs.

Write the test brief this week

Put one assumption, one participant definition, one observable behavior and one decision rule on a single page. Add the data boundary, the person accountable for technical delivery and the next deliverable’s definition of done.

If you already have a v1, check whether it can run that test before approving more scope. If you have only a plan, establish whether a manual experiment can answer the question first. Keep the company’s accounts and ownership clear in either case.

Through Archer Scaling AI, I help early-stage SaaS become AI-native. I build and run the systems that develop, market and sell the SaaS so the founder’s time goes to the decisions. The AI-native assessment starts with seven days of discovery across the company and codebase on read-only access, ending in a written report and plan. The development retainer follows with one accepted deliverable a week.

To discuss your assumption, the codebase and who owns the next release, book a free intro call about your company.