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)
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.
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.
02 · 1–2 weeks
Design
We shape the screens together. You see a clickable prototype and can ask for a round of changes.
03 · Every week
Development
Each week we send a link to the working version and take your feedback.
04 · First 30 days
Launch and after
We launch together. For the first 30 days we are there for every question that comes up.