MVP App Development

The Smallest App Worth Putting in a Store

A mobile MVP has a constraint the web version does not: every release goes through review, and you cannot take a bad build back off somebody’s phone. So version one is scoped to answer one question, instrumented to actually answer it, and released a slice at a time.

Scope

On Mobile, Every Extra Screen Costs Twice

It costs build time, like anywhere else. It also costs review surface: a permission to justify, a declaration to fill in, a background mode to explain, another thing that can be rejected or that quietly breaks on a handset nobody in the room owns.

Is It on the Shortest Path?

Draw the single line from install to the moment the app has done its job once. Anything not on that line is a candidate for version two, no matter how obvious it feels in a meeting. Profile editing, settings screens, notification preferences and onboarding tours are the usual passengers.

Does It Add a Platform Capability?

A feature that needs background location, health data, contacts, the microphone, a payment path or an unusual background mode is not just more code. It is a purpose string, a data declaration, a possible review question and an extra reason for an approval to take a week instead of a day. Sometimes worth it in version one. Often not.

Can It Live Outside the App for Now?

A web page opened from the app, a form somebody fills in for the user, an email sent by hand, a spreadsheet behind the scenes. Anything that a person can do manually at ten users a day does not need building at ten users a day. It needs building when the manual version starts hurting.

Would Cutting It Change Behaviour in Week One?

If removing a feature does not change what a new user does in their first week, it cannot change what you learn from the MVP either. That is the cleanest cut available, and it is usually the one nobody wants to make out loud.

From List to Version One

How the Scope Narrows

Four passes, done in a workshop rather than by email, ending in a written scope you approve before anything is designed.

Everything Anyone Has Ever Suggested

The full wish list, including the things from the investor deck and the feature a competitor shipped last month. Written down, nothing rejected yet.

The One Question the App Exists to Answer

Will people book through a phone instead of ringing? Will drivers log a job on the move? Everything is then measured against that one question rather than against how good an idea it is.

The Shortest Complete Task

One path, start to finish, with nothing branching off it. Every remaining feature has to justify itself against a permission, a declaration and a week of calendar time.

Version One

A screen list, an event list, a store listing plan and a fixed scope. The cut features stay on a written backlog with reasons, not deleted and not forgotten.

Illustrative of the shape of the exercise, not a fixed number of features. What survives the funnel depends entirely on what your app has to do.

The Mobile Trap

You Cannot Iterate on an App the Way You Iterate on a Website

This is the difference that catches out teams who have shipped web products before, and it changes what belongs in version one.

On the Web

Decide at Ten, Live at Eleven

  • Push a change and every visitor has it on next load
  • A bad deploy is rolled back in minutes
  • One version of the product exists at any moment
  • Nobody reviews your copy before it goes out

In the Stores

Build, Sign, Submit, Review, Release, Wait

  • A fix reaches a reviewer before it reaches a user
  • You cannot un-install a bad build from other people’s phones
  • Several versions of your app are live simultaneously, for years
  • A rejection can cost a week you had not planned for

Remote Config From Day One

Limits, copy on key screens, which experiment is running, and which features are switched on all live on the server rather than inside the binary. Changing them is an afternoon, not a submission.

A Kill Switch Per Risky Feature

Anything touching payments, a third-party integration or a background job gets a flag that turns it off remotely. When it misbehaves at two in the morning you disable it and fix it properly on Monday, instead of racing a review queue.

Server-Driven Where It Pays

Content, ordering, promotional blocks and anything a marketing team will want to change weekly comes from the API. Not the whole interface — that path ends in a slow, ugly app — just the parts that genuinely change often.

Release

Version One Does Not Go to Everybody on Day One

Before the public listing there are test tracks, and after it there is a rollout you can stop. Using both is what makes a first release survivable.

01

Internal Builds

Your team on their own phones, with the real backend, well before anyone outside sees it. This catches the device-specific problems that no simulator produces.

02

Closed Beta

A named group of real users through the platforms’ own test distribution. They get the build without it being publicly listed, and feedback comes back attached to a version number.

03

Staged Release

Public, but to a small share of users first, widening over several days while the crash-free rate, the funnel and the review stream are watched. If something is wrong, the rollout is halted before most people ever saw it.

04

Full Availability

Only once the numbers from the earlier slice hold. Then the same discipline applies to every update afterwards, because the second release is where complacency usually starts.

The mechanics differ between the two stores and both change their tooling periodically. The principle does not: never hand a brand new build to your entire user base in one step. More on the submission sequence itself on the store launch page.

Checking app analytics and crash reports for a newly released build
Instrumentation

An MVP Without Measurement Is Just a Small App

The point of a minimum viable product is to learn something specific. If the only data you have after launch is a download count and a handful of opinions, you have spent a build budget and learned nothing you could not have guessed.

So the events go in before the first build ships, not after the first board meeting asks for them. Retrofitting analytics means waiting another release cycle and then another month of data, which on mobile is most of a quarter.

  • One named activation event that counts as the app having worked
  • The install to first-value funnel, step by step, so you can see where people stop
  • Retention at day one, day seven and day thirty, split by platform and by OS version
  • Crash-free sessions and cold start time, treated as product metrics rather than engineering ones
  • Only the data you have actually declared in the store listing — no quiet extras
Analytics and monetisation
The Uncomfortable Bit

Sometimes the Fastest Test Is Not an App at All

We build mobile apps and nothing else, so this costs us work to say. It is still true often enough to be worth saying first rather than in month three.

Probably Not an App Yet

A Web App or a Landing Page Answers This Faster

  • You are testing whether anyone wants it at all
  • You are testing whether they will pay, and a checkout page settles that
  • The whole product is forms, lists and a dashboard with no hardware in sight
  • Your users will meet it once through a link, not daily from a home screen
  • You expect to change the concept every week for the next two months

An App Earns Its Place

These Are Things Only an App Can Do

  • Push notifications that reliably reach somebody who is not looking
  • Genuine offline use, where the work continues with no signal at all
  • Camera, scanning, Bluetooth, sensors or background location
  • Daily use where an icon on the home screen is the habit
  • Store presence as a distribution channel, or app payments as the business model

If your idea sits on the left, we will say so on the first call and point you at the cheaper experiment. We would rather build your app in six months when the demand is proven than build it now and watch it not matter. If it sits on the right, the case for an app is real and we can get on with scoping it.

Delivered

What Exists on the Last Day

The App, Live in the Stores

Listed under your own developer accounts, with screenshots, descriptions and the data declarations completed.

Source Code and Signing

The repository, the signing keys and the build pipeline, in your possession rather than ours. No dependency on us to release again.

Backend and Infrastructure

Running in accounts billed to you, with the environment configuration written down rather than living in somebody’s head.

The Instrumentation

Events, funnel, retention and crash reporting wired up and already producing data from the beta group before launch day.

Design Files and States

Editable sources, the component library and the state coverage from the design phase.

The Cut List

Everything removed from version one, with the reason it was cut and what it would cost to add, so version two starts from a document instead of an argument.

FAQ

Questions About Version One

How small is too small for a version one?

Too small is when the app no longer completes a single useful task end to end. An MVP with one path that works beats an app with six half-finished ones, because a store reviewer, a tester and a real user all judge it on whether the thing they came to do actually finishes. The test we apply is simple: can somebody install it, do the one job, and get a result they would tell a colleague about? If yes, it is big enough. If the only way to describe it is as a preview of something better, it is not ready for a public listing and should go out through a test track instead.

Why can we not just ship fixes the same day like a website?

Because an app update is not live when you press publish. It has to be built, signed, submitted, reviewed by the platform, released, and then downloaded by each user, many of whom have automatic updates switched off. Even when review is quick, the gap between deciding on a change and most of your users having it is days at best and weeks in practice. That is the single biggest structural difference between a mobile MVP and a web one, and it is why we build remote configuration, feature flags and server-driven content into version one rather than adding them after the first emergency.

Should we launch on one platform first or both?

One platform first is usually cheaper to learn from and slower to sell internally. If your audience is genuinely split across both, a cross-platform build reaching both stores on one budget is normally the better answer than sequencing them. If the audience leans clearly one way, or the app depends on hardware behaviour that differs sharply between platforms, starting with one and porting once the idea is proven avoids paying twice for a feature set you may cut. We give you the recommendation with the reasoning, including the cost of each path, before anything is committed.

What is a phased rollout and do we have to use it?

A phased rollout releases a new version to a small slice of users first and widens it over several days instead of giving it to everyone at once. Both stores support a version of this. It matters far more on mobile than on the web because you cannot take a bad build back off the phones that already have it — all you can do is halt the rollout and ship a fix that then has to be reviewed and downloaded. For a first release we use it every time, watch the crash-free rate and the review stream at each step, and only widen when the numbers hold.

Will an MVP look unfinished in the store?

It should not, and this is where a lot of MVPs go wrong. Small scope is fine; missing polish is not. The icon, the screenshots, the empty states, the loading behaviour, the error messages and the first-run flow are all part of what a reviewer and a first-time user judge, and none of them are optional because the feature list is short. We would rather cut a whole feature than ship six features with unfinished states around them, and the store listing gets the same attention as the build.

How will we know whether the MVP worked?

You decide that before we build it, not after. We agree the one question the MVP exists to answer and the specific event that counts as success — the booking placed, the scan completed, the second session in the same week — and instrument it from the first build. Then the numbers you look at are the install-to-first-value funnel, retention at day one, day seven and day thirty, and the crash-free session rate. Without that instrumentation in version one you get downloads and opinions, which is not an answer to anything.

Would a web app or a landing page test the idea faster than an app?

Frequently, yes, and we will tell you when we think so. A responsive web app has no store review, no signing, no install step, no version fragmentation and no update lag, so you can change it at lunchtime and see the effect in the afternoon. If what you are testing is whether people want the thing at all, or whether they will pay for it, that is usually the faster and cheaper experiment. An app earns its place when you need push notifications, offline use, the camera or sensors, background behaviour, a permanent spot on the home screen, or store distribution as the sales channel. If none of those apply yet, building an app first is an expensive way to learn something a web page would have told you in a fortnight.

Tell Us the Idea, We Will Tell You the Smallest Version of It

Including the version where we say a web page would answer the question faster. You get a scope, a screen list and a cost range within two business days.