Skip to content
MVP

MVP development: scope and process

MVP development helps you put an idea in front of real users without building everything at once. Together we shape a first version on web or mobile for your startup or new product idea, and decide what it needs to show.

Price
Fixed price after a scoping call
Timeline
2-8 weeks
What is included
  • Scoping call and written feature list
  • A price agreed before work starts
  • Interface design made for your product
  • Web (React, Next.js) or one codebase for iOS and Android (React Native + Expo)
  • User accounts, database and payments where needed
  • Usage analytics and crash reporting
  • Store or web launch
  • Source code and all account handover
Let's talk pricing

What an MVP is, and what it is not

An MVP (minimum viable product) is a first version small enough to test your idea's most important assumption, yet solid enough for real users to actually use. Its job is not to do everything but to answer one question: do people use this, and will they pay?

An MVP is not a prototype or a clickable design; it is a live product that stores data and lets people sign up. The scope is narrow, and what is in scope works properly. If users run into bugs early on, it becomes hard to tell whether they are reacting to the app or to the idea.

Who it is for

MVP development is for anyone with an idea who wants to see whether it works before going all in. Typical cases:

  • Entrepreneurs without a technical partner who want the first version built externally.
  • Teams who want to walk into investor meetings with a working product.
  • Businesses testing a new digital product alongside their existing work.
  • Companies trialling an internal process with a small group first.

Web or mobile?

The first decision is the channel. If people will open the product several times a day, or it needs notifications, camera or location, mobile is usually the better start. If they use it at a desk a few times a week, or you sell to businesses, web is usually faster and costs less. The price depends on scope; after a short call we send you a written quote. As a guide:

  • Validation page — 2-3 weeks: a site that explains the idea and collects a waitlist or pre-sign-ups, to measure demand before building.
  • Web MVP — 4-6 weeks: a working web product with sign-in, a core flow and an admin panel. Larger scopes move into the Bespoke tier (8+ weeks).
  • Mobile MVP — 6-8 weeks: one codebase for iOS and Android, focused on a single core flow, App Store and Google Play submission included.

How we narrow the scope

It is tempting to fit everything into version one, but every feature adds time and cost and makes it harder to see what works. In our first call we go through this order together:

  • We write down the core assumption: who is it for, what problem does it solve, and how?
  • We pick the one flow that tests it: the path from first launch to the moment the user sees the value.
  • Everything else is split into "version one" and "later". Later items are not deleted, just queued.
  • Anything that can be done by hand stays manual for now. For the first users, email or a spreadsheet can do the job of an admin panel.
  • Measurement is set up from the start, because version two is much easier to plan when you can see how many people get through each step.

Measurement: what question will version one answer?

What makes an MVP successful is not launching but leading to a decision. So before development starts we write down, together, the question version one should answer and the data that will answer it.

In a booking app, for example, the question might be: do users book a second appointment through the app? We then measure sign-up, first booking and repeat booking separately. Usage analytics and crash reporting are in from day one, so you see where people drop off and which devices hit errors.

Price and scope agreed in writing

Within 1 business day of our call we send you the feature list, timeline and price in writing. That price stays the same during the project. If a new idea comes up during development, it either swaps with something in scope or is priced separately for the next version, so your budget holds. Every week you also get a working preview, and at the end the source code is handed over to you.

Early-stage budgets are usually tight, so knowing the cost in advance helps you plan. It also gives investors or partners a clearer picture.

Design: how polished should it be?

In an MVP, design mainly serves clarity. If users do not understand what to do on first launch, the data tells you more about the interface than about the idea. So we spend time on the core flow's screens and keep secondary screens simple.

First impressions still count: a carefully made interface helps users trust the product and not give up on the first try. We set up colours, type and components as a small design system from the start, so new screens are added faster and in the same language as the product grows.

Technology: quick to start, able to grow

It helps if an MVP's stack can grow with the product, so a rewrite is not needed if it takes off. On mobile we ship iOS and Android from one codebase with React Native and Expo. On the web we use React and Next.js. On the back end we use Supabase, Node.js or .NET with PostgreSQL, depending on the need.

Managed back ends like Supabase get sign-in and the database running fast, which shortens an MVP. As the product grows, moving to a custom back end on the same PostgreSQL database is possible; since the data and code are yours, that call is yours too.

We build our own products the same way

Alongside client work we build our own products and apply the same process to ourselves. Zamgo sends fuel price alerts in Turkey; we built it with React Native and Expo, and it is live on the App Store and Google Play. Kinnest, a baby tracker, is in development: offline-first with Expo and expo-sqlite, syncing through Supabase, with RevenueCat for subscriptions, Sentry for error tracking, and no ads.

On the client side, Invite Me is a travel meetup app we rewrote in React Native, with real-time chat and subscriptions, on iOS and Android. These projects taught us what a first version really needs and what can wait.

After the MVP launches

An MVP's work starts at launch. In the first weeks we watch where users get stuck, what they ask for and what they never touch. Version two is planned from that data.

There are two ways forward. For continued development, an ongoing monthly retainer, for at least 3 months. If you only need the app kept current and running, yearly mobile maintenance, with its scope agreed in writing. Because the source code is yours, you can also build your own team later.

Process

How we work

We follow the same four steps on every project, so you always know where we are and what comes next.

  1. 01 · 1–5 days

    Getting to know you

    We listen to your idea and clarify what you need together. At the end we share a written scope and price.

  2. 02 · 1–2 weeks

    Design

    We shape the screens together. You see a clickable prototype and can ask for a round of changes.

  3. 03 · Every week

    Development

    Each week we send a link to the working version and take your feedback.

  4. 04 · First 30 days

    Launch and after

    We launch together. For the first 30 days we are there for every question that comes up.

Technology
React NativeExpoReactNext.jsSupabasePostgreSQL
FAQ

Common questions

Have a project in mind?

A short description is enough; if it isn't clear yet, we can think it through together. We'll write back within one business day.

With your consent, we use analytics cookies to improve the site and measure visits. Cookie policy