vpv.

← Notes·2026-09-09·guide / apps / websites

Website or app first? How to pick the shape of your MVP.

Most startups should ship a landing page, then a web app, then a native app. How to tell which one your MVP needs, and the cases where native comes first.

By updated 8 min read

For most startups the order that works is a landing page first, a web app second, and a native app only once the product has earned a place on the home screen. A landing page tests whether the sentence at the top makes the right people click. A web app tests whether they come back. A native app is worth its review queue and its two platforms only when the product needs the pocket: the camera, sensors, background work, offline use.

This guide is for founders deciding what to build first with a limited budget. Skipping the landing page costs a few weeks of building for people who were never going to show up. Skipping the web app costs a store review every time you learn something, which in the first months is several times a week. That second cost is the expensive one, and it is the one founders underestimate.

In what order should you decide the shape of an MVP?

  1. 01

    Write the one action that means it worked

    A verb a user does, not a feature you ship.

    30 min
  2. 02

    Ship a landing page with one claim and one button

    A waitlist or a booking link, and a way to reach whoever signs up.

    1 to 2 weeks
  3. 03

    Decide where the first hundred users are

    At a desk or on the move, honestly, for the early users only.

    10 min
  4. 04

    Check for hard native needs

    Camera depth, background work, Bluetooth, offline, large local files.

    1 hour
  5. 05

    Build the web app, installable on phones

    Responsive, fast, deployable the same day you learn something.

    weeks
  6. 06

    Go native when the product has earned it

    Retention is real and a native capability is now the bottleneck.

    later
The decision sequence for the shape of an MVP. An order of questions, not a build schedule.

One example, carried through every step

To keep the advice testable, one hypothetical product runs through this guide. Say you are building Pantry: it plans a week of dinners for parents of toddlers from what is already in the fridge. You picture a phone app with a reminder at 5pm, a photo of the fridge, and a shopping list that syncs between two parents.

That picture is native from end to end, and it is a reasonable picture of the product in two years. The question this guide answers is different: what should exist in the next eight weeks, so that you learn whether parents want Pantry before you pay for two app stores.

The one action that means Pantry worked: a parent cooks a planned dinner and comes back the next week to plan again. Write that sentence down before anything else. Every later decision gets checked against it.

The landing page is an experiment, not a brochure

A landing page is the cheapest experiment available. Does the sentence at the top make the right people click the one button? One page, one claim, one action, and a way to reach whoever signs up.

A waitlist has killed more bad ideas than any MVP, at a fraction of the cost, and the ideas it does not kill arrive at the build with a list of people to talk to. Building the product first inverts that: you learn who wanted it after you have already decided what it is. A landing page takes one to two weeks from this studio; the reasoning behind keeping it to one claim is on the websites for startups page.

For Pantry, the page says "Dinner for the week, planned from what is already in your fridge" and the button says "Get the first week free". If parents of toddlers sign up and a handful answer a follow-up email, you have both a signal and your first interviews. If they do not, the problem is the claim, and no amount of app solves a claim problem.

Output of this step: a live page, a sign-up count, and a short list of people who said yes.

Where the product is used decides almost everything

The honest test is where the first hundred users use the product: at a desk or on the move. Founders tend to answer for the eventual product, which is how a team ends up in a review queue while still working out what the product is.

Web app

Desk, browser, deliberate sessions, and more of the phone than founders expect.

  • Ships in minutes, changes the same afternoon
  • No review queue, no old versions in the wild
  • One codebase, one link you can put in an email
  • Fine for AI features, file handling and long sessions
  • Can be added to the home screen, with web push on iOS 16.4 and later
  • Weak at: background work, deep hardware access, being remembered

Native app

Pocket, camera, sensors, interruptions.

  • Earns a home-screen slot and a reliable notification channel
  • Real access to hardware and background work
  • Waits for review, then waits for users to update
  • Two platforms unless you pick a cross-platform stack
  • Weak at: changing daily, which is what early products do
The question that settles most of these arguments. Answer it about the first hundred users, not the eventual million. A comparison of tendencies, not hard limits.

Why Pantry starts as a web app even though it lives on a phone

Pantry is used on the move, in a kitchen, on a phone. That sounds like an argument for native, and a few years ago it was. But the core loop (plan a week, see a list, tick things off) runs well in a mobile browser. Since iOS and iPadOS 16.4, web apps that a user adds to the home screen can receive Web Push notifications, so even the 5pm reminder no longer forces a native build on day one. The fridge photo is a file upload, which browsers handle.

So Pantry's first build is a mobile-first web app, installable to the home screen. Output of this step: the platform decision written in one line, with the reason.

How often the product changes decides the cost of native

Early products change daily. A web app deploys in minutes and every user gets the new version on the next page load. A native app waits for review, then waits again for users to update, which means you support several versions of a thing you are still designing. Here is what each channel asks of you, as published by the platforms themselves.

Web appiOS App StoreGoogle Play
Account costHosting and a domainApple Developer Program, 99 USD a yearOne-time US$25 registration fee
Before the first public releaseDeployApp Review; Apple says it typically reviews 50% of submissions in under 24 hours and 90% in under 48New personal accounts (created after 13 November 2023) must run a closed test with at least 12 testers opted in for 14 days
Every update after thatDeploy; live on next loadAnother review, then each user updatesAnother review; Google notes some accounts can wait up to seven days or longer
Common reason for delayYour own bugsApple reports over 40% of unresolved issues relate to guideline 2.1, App Completeness (crashes, placeholder content)Policy and testing requirements

Platform figures from Apple Developer and Play Console Help, checked November 2026. They change; confirm before you plan a launch date around them.

Why do store review delays add up?

None of these delays is long alone; they compound. Nielsen Norman Group's long-standing advice is to test with about five users and run as many small rounds as you can afford. On the web, a round can be Monday's interviews and Tuesday's deploy. Through a store, each round carries a review, and teams soon start making decisions to avoid another submission. That is not a product strategy.

Pantry's planning screen will likely change weekly for two months, after five parents use it each round. That cadence is the argument for the web.

When native, desktop or no app at all comes first

Here is the turn: the web-first rule is a default, not a law, and this studio's own products break it more often than they follow it. Shape follows the one thing the product cannot do without.

Travelmaxing follows the rule. It is a trip planner on Next.js with a Mapbox globe, used in deliberate planning sessions. Vanpelt Studio breaks it: it is a desktop app because it transcribes and indexes whole memory cards locally, not a job for a browser tab or a phone. tvcast breaks it differently: it is a command-line tool for macOS because it needs ScreenCaptureKit to capture the screen and system audio, and the local network to reach the TV. And GetCited turned out to need no conventional app at all. Its users work inside a coding agent, so the right shape was an MCP server the agent calls, not a dashboard they have to remember to open.

Which needs justify building native first?

So check for hard native needs before you default to web. Native or desktop comes first when the core action depends on continuous background work (location tracking, audio recording with the screen off), deep hardware access (Bluetooth devices, depth cameras), real offline use, or large files on local disk. If the one action from step one depends on any of those, a web app cannot test it. AI features usually push the other way, toward web or desktop, where model access, long-running jobs and large files do not fight a mobile sandbox.

The limit on my side matters here too. I build alone, so I will not run two separate native codebases at a daily cadence for an unproven product: it doubles the cost of every change. When native is genuinely needed early, I pick one platform or a cross-platform stack and say so in the scope. One engineer can carry a web app and add a thin native shell later.

Pantry goes native when a native capability is the bottleneck

For Pantry, the plan is one engineer, one web codebase, and a native app scoped only once parents come back week after week and the web reminder turns out to be the bottleneck. The signal to go native is specific: retention you can see, and one native capability that is now the thing holding growth back.

What to send before you talk to anyone

MVP shape brief: answer these first

  • The one action a user takes that means the product worked, as a sentence.
  • Where the first hundred users will do it: at a desk or on the move.
  • Any hard native need: background work, Bluetooth, depth camera, offline, large local files.
  • Whether the core loop has AI in it, and where the model runs.
  • How you will reach the first fifty users, in one sentence.
  • What already exists: a landing page, sign-ups, designs, a prototype, a repo.
  • The date something has to be in a user's hands, and what happens if it is not.
  • Who maintains it after launch, and how many people that is.
Eight answers that settle most of the shape before any code is written. A checklist for the founder, not a technical specification.

If the first build went wrong, it is one of these

Nobody signed up. Symptom: the product is live and the sign-ups never came. Cause: the claim was never tested, so the build tested it at a much higher price. Fix: go back to a one-claim landing page and change the sentence until the right people click.

Every change takes a week. Symptom: the team batches fixes to avoid another store submission. Cause: native came before the product stopped changing daily. Fix: move the fast-changing surface to the web and keep the native app as a thin shell until it settles.

Two apps drift apart. Symptom: iOS and Android disagree on features and the bug list doubles. Cause: two platform teams before product-market fit. Fix: one cross-platform codebase, or one platform until retention justifies the second.

The web app cannot do the one action. Symptom: users like the product but the key moment fails in the browser. Cause: a hard native need was missed in step four. Fix: build the smallest native or desktop piece that does that action, and keep everything else on the web.

The app got rejected. Symptom: the first submission comes back incomplete. Cause: placeholder screens or crashes in an MVP, the category Apple reports most often. Fix: ship only finished screens, and test the rest on the web first.

What this studio does

A one-week discovery turns the idea into a scoped build and settles the shape, whether that is a landing page, a web app, native or desktop, before any code is written. Scoped MVPs land between the price of one senior engineer-month and three, and the discovery week fixes the number. Then weekly demos on a live preview until launch. The details are on app development for startups. If the launch needs a film as well, what a product launch video costs covers the budget.

The whole recipe on one line

One action, one claim on a landing page, an honest answer about where the first hundred users are, a check for hard native needs, a web app that changes daily, and native only when retention is real and a native capability is the bottleneck. For Pantry that means a mobile web app with a home-screen reminder this quarter, and an app store listing only once parents keep coming back.

Sources and further reading

  • App Review

    Apple DeveloperApple says it typically reviews 50% of submissions in under 24 hours and 90% in under 48, and that over 40% of unresolved issues relate to guideline 2.1, App Completeness.

  • Enrollment

    Apple DeveloperThe Apple Developer Program annual fee of 99 USD.

  • Get started with Play Console

    Play Console HelpThe one-time US$25 registration fee for a Google Play developer account.

  • App testing requirements for new personal developer accounts

    Play Console HelpThe closed test with at least 12 testers opted in for 14 days that new personal accounts need before production access.

  • Publish your app

    Play Console HelpGoogle notes that review for some developer accounts can take up to seven days or longer.

  • Web Push for Web Apps on iOS and iPadOS

    WebKitThe 2023 announcement that Home Screen web apps on iOS and iPadOS 16.4 can receive push notifications. The change that weakened the strongest argument for native-first.

  • Why you only need to test with 5 users

    Nielsen Norman GroupThe case for many small rounds of testing with about five users each, which is the cadence a web app makes cheap.

Have an app or MVP that needs building?

Apps by the studio →Start a conversation →