DEV Community: Paweł Reszka

How to Move Your Lovable or Replit Project to Your Own Infrastructure (Step-by-Step)

Paweł Reszka — Wed, 25 Mar 2026 22:30:25 +0000

You built something on Lovable or Replit. It works. Now you want to own it — run it on your own infrastructure, stop burning credits, and have full control over your code.

This guide walks you through every step in plain English. No assumed knowledge. Windows and Mac instructions throughout.

Before You Start

Moving a project from Lovable or Replit is a bit like moving house. It's not instant, and there's a checklist to follow — but once you're done, your project is yours, living on infrastructure you control.

How long will this take?
A simple project (just a website, no database): about 1-2 hours. A project with a database and logins: plan for a half day.

Do this NOW before anything else:
Take a screenshot of your working project. Note down every feature that works today. This is your "before" picture so you can confirm everything works the same after moving.

Things you'll need:

A computer running Windows or Mac
A free GitHub account
About 1-4 hours of uninterrupted time
Access to your Lovable or Replit project (logged in)
A notepad or text file to save passwords and settings as we go

Step 1: Install Git and Get Your Code

Git is a free tool that saves every version of your code. Think of it as undo/redo on steroids. Every change you make gets saved in history, so you can always go back.

Install Git

Windows:

Go to git-scm.com/download/win — the download starts automatically.
Open the downloaded file. Click Yes if Windows asks for permission.
Click Next through all the screens — the defaults are fine. Click Install, then Finish.
Check it worked: press the Windows key, type cmd, press Enter. Type git --version. You should see a version number.

Mac:

Open Terminal: press ⌘ Command + Space, type Terminal, press Enter.
Type xcode-select --install and press Enter. A window will pop up asking to install Developer Tools. Click Install. Wait 5-15 minutes.
Check it worked: type git --version. You should see a version number.

Download your code

From Lovable:

Open your project in Lovable and click the GitHub icon in the top bar.
Click "Connect to GitHub" or "Push to GitHub". Log in to GitHub and allow access if asked.
Lovable will create a repository on your GitHub account. Write down the URL — it looks like https://github.com/your-name/your-project.
Alternatively, use the Download ZIP option if available.

From Replit:

Open your project. In the left sidebar, look for the three dots menu or click "Version Control" / the Git icon.
Click "Connect to GitHub" and follow the steps to push your code to a new GitHub repository.
Or download directly: click the three dots next to your project name → "Download as ZIP".
If you downloaded a ZIP: right-click and choose Extract All (Windows) or double-click to unzip (Mac).

Open a command window in your project folder

A command window is a text-based way to give your computer instructions. It sounds scary but we'll only type a few simple things.

Windows:
Open File Explorer, navigate to your project folder, click the address bar at the top, type cmd and press Enter. A black window opens already inside your project folder.

Mac:
Open Finder, find your project folder, right-click it and select "New Terminal at Folder".

Now type these commands one at a time, pressing Enter after each:

# Tell Git who you are (use your GitHub name and email)
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# If your code isn't from GitHub yet (downloaded ZIP), run these:
git init
git add .
git commit -m "My project, first save"

Step 2: Save Your Secret Settings

Every app has settings and passwords stored behind the scenes. We need to copy these before moving.

Think of environment variables as the keys to your app's locked doors — passwords for your database, secret codes for payment systems, and connection details. Without them, your moved app won't work.

Finding your settings in Lovable

In your Lovable project, click on the Cloud icon at the top.
Look for a section called "Secrets".
Write down every single variable — the name on the left and the value on the right. Keep this somewhere safe.
Also note your Supabase URL and keys — go to your Supabase project → Settings → API and copy the Project URL, anon/public key, and service_role key.

Finding your settings in Replit

Open your project. In the left sidebar, click the 🔒 Secrets padlock icon.
You'll see a list of your secrets. Each one has a key (the name) and a value.
Click each secret and copy the value. Write them all down. They will NOT be exported with your code automatically.
Also note if you're using Replit's built-in Database — if your code mentions @replit/database, you'll need to export that data separately.

Common variables and what they do

Variable Name	What it is	Need on new host?
`VITE_SUPABASE_URL` / `NEXT_PUBLIC_SUPABASE_URL`	The address of your database	Yes
`SUPABASE_ANON_KEY` / `VITE_SUPABASE_ANON_KEY`	A public key for reading your database	Yes
`SUPABASE_SERVICE_ROLE_KEY`	A powerful private key	Yes — never share publicly
`OPENAI_API_KEY` / `ANTHROPIC_API_KEY`	Your AI service password	Yes — rotate after migration
`STRIPE_SECRET_KEY` / `STRIPE_WEBHOOK_SECRET`	Payment processing keys	Yes — update Stripe dashboard
`DATABASE_URL`	Full address + password of your database	Yes — will change on new host
`NEXTAUTH_SECRET` / `JWT_SECRET`	Secret code for user login security	Yes
`NEXTAUTH_URL` / `PUBLIC_URL`	The web address of your app	Yes — will change to your new address

⚠️ You can copy your existing keys directly to your new hosting platform and everything will keep working. As a best practice, eventually rotate your API keys — especially for payment services and AI APIs. You don't need to do this today; just keep it on your to-do list.

Create your .env file

Windows:

Open Notepad. Type your variables:

VITE_SUPABASE_URL=https://xxxxx.supabase.co
VITE_SUPABASE_ANON_KEY=your-key-here
OPENAI_API_KEY=sk-xxxxxxxxxxxx

Click File → Save As. Navigate to your project folder. In "Save as type", choose "All Files (.)". Name the file exactly: .env (with the dot). Click Save.

Mac:

In your Terminal (already in your project folder), type nano .env
Type your variables (same format as above).
Press Ctrl + X to exit, then Y to save, then Enter to confirm.

🚨 Never upload your .env file to GitHub! It contains passwords. Make sure it's listed in your .gitignore file:
echo ".env" >> .gitignore

Step 3: Save Your Data

If your app lets users sign up, saves any information, or has content that changes — you have a database. If it's a simple display-only website with no logins, you probably don't.

Supabase (Lovable projects)

Log in at supabase.com and open your project.
Go to Project Settings → Database.
Use the Table Editor to export each table as CSV: go to a table, click Export, save the file.

💡 Easiest path: keep Supabase. You don't have to move your database at all. Just deploy your code to a new host and keep using the same Supabase project. Copy your Supabase URL and keys to the new host's environment variables. Done.

Replit's built-in database

⚠️ Replit's database is a simple key-value store that doesn't export easily. If your app uses @replit/database, you'll need to replace it with a real database after moving. Supabase, Neon, or Turso are all good free options.

To export your data, open the Shell tab in Replit and run:

node -e "const D=require('@replit/database');
const d=new D();
d.list().then(k=>Promise.all(k.map(async key=>
({key,val:await d.get(key)}))).then(r=>
console.log(JSON.stringify(r,null,2))))"

Copy the output and save it as replit-data-backup.json.

Step 4: Deploy to Your New Home

For most Lovable/Replit projects: Vercel (for React/Next.js) or Railway (if you have a backend server). Both have free tiers.

Deploy to Vercel

Make sure your code is on GitHub (from Step 1). Go to vercel.com and click Sign Up → Continue with GitHub.
Click Add New Project → Import your GitHub repository.
Before clicking Deploy, find the Environment Variables section and add all the variables you saved in Step 2. Add them one by one.
Click Deploy. After 1-3 minutes, you'll get a URL like your-project.vercel.app. Open it and test everything.

Test everything before moving your domain

Don't touch your domain until this checklist is green:

[ ] Homepage loads without errors
[ ] User sign up works (if you have auth)
[ ] User login works
[ ] Any forms submit correctly
[ ] Images and files load
[ ] If you have payments — test with Stripe's test card (4242 4242 4242 4242)
[ ] Check on your phone too
[ ] Compare with your "before" screenshots from the beginning

Move your custom domain (if you have one)

Only do this once all tests pass. DNS changes can take up to 48 hours to update worldwide.

In Vercel: go to your project → Settings → Domains → add your custom domain.
Vercel will show you DNS records to add. Log in to wherever you bought your domain and update those records.
After your domain is working, update the NEXTAUTH_URL or PUBLIC_URL environment variable to your real domain name.

Step 5: Set Up Claude Code (Optional)

Once your code is running locally, you can use Claude Code to make changes instead of going back to Lovable or Replit. It runs in your terminal — you describe what you want in English, it reads your code and makes the changes. No credits.

Install Claude Code

In your terminal (Windows Command Prompt or Mac Terminal):

npm install -g @anthropic-ai/claude-code

Get your API key

Go to console.anthropic.com
Create an account if you don't have one
Go to API Keys → Create Key → Copy it

Connect and start using it

Windows:

set ANTHROPIC_API_KEY=your-key-here
claude

Mac:

export ANTHROPIC_API_KEY=your-key-here
claude

Claude Code will start and you'll see a prompt where you can type in plain English.

Try your first command:

Read the project structure and tell me what this app does

It will analyse your entire codebase and explain it back to you. On Lovable, that would have cost credits. Here it's just a conversation.

Try making a change:

Change the main heading colour to blue

It will find the right file, show you what it's going to change, and ask for permission. Say yes, then refresh your browser.

After making changes, save them to GitHub:

git add .
git commit -m "describe what you changed"
git push

💡 Claude Code uses Anthropic's API which charges per usage — not per edit like Lovable, but per amount of text processed. For typical small changes it's pennies. Much cheaper than platform credits for ongoing work.

Choosing a New Home

For your app

Platform	Best for	Price
Vercel ⭐	React/Next.js projects	Free to start
Netlify	Any website	Free to start
Railway ⭐ (Replit users)	Apps with a backend server	From $5/mo
Render	Any kind of project	From $7/mo

For your database

Platform	Best for	Price
Keep Supabase ⭐	Easiest — don't move it at all	Free to start
Neon	PostgreSQL, similar to Supabase	Free to start
Turso	Replacing Replit's built-in DB	Free to start

Final Migration Checklist

[ ] Code exported and on GitHub
[ ] All environment variables copied from old platform
[ ] .env file created locally (and in .gitignore)
[ ] Database backed up (or confirmed staying on Supabase)
[ ] Deployed to new host (Vercel, Railway, etc.)
[ ] All environment variables added to new host
[ ] App fully tested on new host URL
[ ] Custom domain pointed to new host (if applicable)
[ ] 🔑 Remind yourself to rotate API keys when you have time
[ ] 💸 Cancel your old Lovable/Replit subscription (only once 100% working)

You did it. Your project is now running on infrastructure you control. No more platform-specific lock-in, no more surprise pricing changes. From here, your code deploys automatically every time you push to GitHub.

Full version with screenshots and interactive tabs: inigra.eu/nocodemigration

If you'd rather have someone handle the migration, we do this every week: Book a free discovery call

The No-Code Credit Trap: How AI Builders Are Quietly Draining Your Budget

Paweł Reszka — Tue, 24 Feb 2026 11:26:54 +0000

You started with a simple idea. A quick prototype. You picked Lovable, Replit, or Bolt because they promised speed. Build an app in a weekend. Ship fast. No developers needed.

And it worked - at first.

The loop nobody warns you about

Here's the pattern we see with every founder who comes to us after the no-code phase:

You hit a bug. You ask the AI to fix it. It uses a credit. The fix breaks something else. You ask it to fix that. Another credit. The second fix partially works but introduces a new issue. Three more credits later, you're back where you started - except your balance is lighter.

This isn't a flaw in how you're using the tool. It's how these tools are designed to make money.

Credit-based pricing means you pay for every attempt, not every result. The AI doesn't know what it built yesterday. It doesn't learn from its mistakes on your project. Every prompt is a fresh start with the same chance of hallucinating a solution that looks right but breaks under real usage.

We've seen founders burn through £200-500 in credits fixing a single authentication flow that a developer would handle in a few hours.

The hidden costs beyond credits

Credits are the obvious cost. The hidden costs are worse.

Time. Every cycle of prompt → generate → test → fail → reprompt is 15–30 minutes. Do that ten times for one feature and you've lost a full day. Multiply by every feature in your app.

Technical debt. AI-generated code accumulates workarounds on top of workarounds. Each fix is a patch on a patch. After a few months, your codebase is a Jenga tower - functional, but one change away from collapse.

Security. We've audited dozens of AI-built apps. The pattern is always the same: hardcoded API keys in the frontend, no security headers, cookies without HttpOnly flags, exposed server information. One security researcher scanned 200+ vibe-coded sites and found an average security score of 52 out of 100. The AI builds what you ask for. It never thinks about what you didn't ask for.

Scaling costs. Most platforms charge by operations, rows, or compute. What costs £50/month with 10 test users becomes £500 with 1,000 real users. By the time you notice, you're locked in — your entire app lives on their platform, and migrating means rebuilding.

When no-code makes sense

This isn't an anti-no-code article. These tools are genuinely powerful for the right use case.

Validation. If you haven't proven that people will pay for your product, no-code is the fastest way to find out. Build ugly, ship fast, get feedback. Don't spend £15K on custom development for an idea nobody wants.

Internal tools. A simple dashboard, a form that feeds a database, a basic CRUD app for a small team. No-code handles these well because the requirements are stable and the user base is small.

Prototyping. Building something to show investors or test a UX flow? No-code gives you a clickable product in days. That prototype becomes your best spec document when you eventually hire developers.

The problem isn't using no-code. The problem is staying on no-code past the point where it's serving you.

The signs you're in the trap

You're in the credit trap if any of these sound familiar:

Your credit spend is unpredictable. You budget £100/month but some months hit £400 because of a cascade of fixes. You can't forecast costs because you can't predict how many attempts the AI will need.

Workarounds outnumber features. You've added Zapier chains, hidden fields, webhook relays, and custom CSS hacks to make basic things work. Your "no-code" app now has more duct tape than logic.

You're afraid to change things. Every new feature risks breaking something else. You've stopped iterating because the cost of change — in credits and time - is too high. That's the opposite of what an MVP should be.

You can't explain your own app. The AI built it, but nobody — including you — fully understands the logic. When something breaks, you can't debug it. You can only ask the AI to try again.

Performance is degrading. Pages load slowly. API calls time out. Database queries choke on a few thousand records. You've optimized what you can, but the platform's architecture has limits you can't work around.

What the transition looks like

If you've decided it's time to move, here's the honest version.

It's not a weekend project. A typical SaaS MVP rebuild takes 4–8 weeks with a proper development team. Complex platforms take longer. Plan for this.

Your no-code app is valuable. It's a working prototype that shows exactly how the product should behave. Developers love having something they can click through rather than interpreting wireframes. This makes scoping faster and cheaper.

You don't rebuild everything at once. Start with the core — the part that's causing the most pain. Your no-code app can run in parallel during the transition. Migrate incrementally.

Budget varies widely. A basic SaaS rebuild starts around £7,000–15,000. A complex platform with real-time features, integrations, and compliance requirements can be £30,000+. The specifics depend on scope, which is why having a clear brief matters before you talk to anyone.

The monthly cost drops. This is the part that surprises people. A properly built app on standard infrastructure (Supabase, Vercel, Google Cloud) often costs £20–50/month to host. Compare that to what you're paying in platform fees and credits.

The bottom line

No-code tools sell the first weekend. Nobody sells the next three months - the part where you're trapped in a cycle of credits, patches, and mounting costs.

If your tool is still serving you, keep using it. If you're spending more time fighting it than building product, that's your signal.

The best time to evaluate is before you're desperate. Look at your credit spend over the last three months. Calculate the hours you've lost to the fix-break-fix cycle. Compare that to what a proper build would cost.

You might find that the "expensive" option is actually the cheap one.

If you're considering this move, try our free brief generator — answer a few questions and get a scope + cost estimate in 5 minutes.

When It's Time to Move On from Lovable, Replit, and Bubble

Paweł Reszka — Tue, 17 Feb 2026 08:52:38 +0000

No-code and AI-assisted builders have changed the game for early-stage products. Tools like Bubble, Lovable, Replit Agent, and Bolt let you go from idea to working prototype in hours, not months. That's genuinely powerful.

But at some point, many founders hit a wall. The app works — sort of — but it's slow, hard to extend, expensive to scale, or held together with workarounds. And then the question becomes: do I keep patching, or do I rebuild?

Here's how to think about that decision.

The signs you've outgrown your tool

There's no single breaking point, but a pattern usually emerges. You start noticing several of these at once:

Performance gets worse as you grow. Pages load slowly, API calls time out, or your database queries choke on a few thousand records. You've optimized what you can, but the platform's architecture has limits you can't work around.

You're spending more time on workarounds than features. Every new feature requires a hack — a Zapier chain, a webhook relay, a hidden field that tricks the system into doing what you need. Your "no-code" app now has more duct tape than logic.

Costs are scaling faster than revenue. Many no-code platforms charge by operations, rows, or users. What was €50/month at launch is now €500 and climbing. At some point, hosting your own infrastructure becomes cheaper.

You need something the platform simply can't do. Real-time collaboration, complex permissions, custom integrations with legacy systems, offline functionality, advanced data processing — some things just aren't possible within the constraints of a visual builder.

Your team is fighting the tool. If you've hired a developer and they're spending most of their time reverse-engineering the platform's quirks instead of building product, that's a signal.

When it's NOT time to move

Not every frustration means you should rebuild. Be honest with yourself about a few things:

If you haven't found product-market fit yet, stay on your no-code tool. Rebuilding before you know what users actually want is one of the most expensive mistakes a startup can make. Keep shipping, keep learning.

If the issue is a single missing feature, look for a plugin, an API integration, or a small custom module before committing to a full rewrite. Sometimes a targeted fix is enough.

If you're moving because you're embarrassed it's built on Bubble — don't. Nobody cares what your stack is. They care if it works.

What the transition actually looks like

If you've decided it's time, here's the honest version of what to expect.

It's not a weekend project. Even a relatively simple app usually takes 2–4 months to rebuild properly with a custom stack. Complex platforms take longer. Plan for this.

You don't have to rebuild everything at once. A phased approach often works better. Start with the core — the part that's causing the most pain or limiting growth — and migrate incrementally. Your no-code app can keep running in parallel during the transition.

Your no-code version is actually valuable. It's a working prototype that shows exactly how the product should behave. This makes the development brief much clearer than starting from scratch with wireframes. Developers love having a reference they can click through.

Budget varies widely. A basic SaaS rebuild might start around €15–25K, while a complex platform with integrations and real-time features can easily be €50K+. The specifics depend on scope, and that's why having a clear brief matters before you talk to anyone.

If you're at the stage where you're considering this move, try putting together a brief of your current product and what you need from the custom version. We built a free tool that helps with exactly this — answer a few questions about your project and get a structured brief with a rough time and cost estimate sent to your email.

Choosing the right approach for the rebuild

Once you decide to move, you'll face another decision: what to build with?

Established frameworks (React, Next.js, Django, Rails, etc.) are the most common path. Mature ecosystems, large talent pools, and well-understood patterns. This is usually the right choice for most products.

AI-assisted custom development is the middle ground that's emerging now. Your dev team uses AI tools like Cursor, Claude, or Copilot to build faster — but on a proper, maintainable codebase. You get speed without the constraints.

Headless or composable architecture works well if your product is content-heavy or needs to connect to many services. A headless CMS plus custom frontend can be a pragmatic path.

The right answer depends on your product, your team, and your timeline. There's no universal "best stack."

The bottom line

No-code tools are a starting point, not a ceiling — and not a trap. They let you validate ideas cheaply, and that's exactly what they should be used for. The transition to custom development is a sign of success, not failure. It means your product is real enough to need a real foundation.

The key is timing it right: not too early (wasting money rebuilding something users don't want yet) and not too late (losing users to performance issues and limitations you can't fix).

Inigra is a software house based in Poznań, Poland. We help founders move from prototype to production. If you're thinking about this transition, start with a brief.

The Real Cost of Building an MVP in 2026 — With Actual Numbers

Paweł Reszka — Thu, 05 Feb 2026 13:11:43 +0000

Most articles about MVP costs give you useless ranges like "anywhere from $5,000 to $500,000." That's not helpful.

I run a software house in Poland. We specialize in MVPs for funded startups. Over the past few years, we've shipped 30+ MVPs across fintech, healthtech, SaaS, marketplaces, and internal tools.

Here's what things actually cost — and why.

The three tiers of MVP development

After dozens of projects, MVPs cluster into three categories.

Tier 1: Validation MVP — £5,000 to £10,000

What you get: One core flow, functional but minimal. Enough to put in front of users and learn if your idea has legs.

Timeline: 2-4 weeks

Typical scope:

Single user type (no admin panel)
One core workflow
Basic authentication
Simple, clean UI (not custom design)
Deployed and working

Real example: A founder came to us with a compliance checking tool idea. We built: user uploads document → AI extracts data → user reviews results. No dashboard, no team features, no billing. Total: £7,500, delivered in 3 weeks.

Who this is for: You have an idea but aren't sure it'll work. You want to test before committing £20K+.

Tier 2: Standard MVP — £10,000 to £20,000

What you get: A real product with core features needed to acquire and retain early users. This is what most people mean when they say "MVP."

Timeline: 4-8 weeks

Typical scope:

User authentication (email, Google, magic links)
3-5 core features
Basic admin panel
Payment integration (Stripe)
Responsive design
Analytics setup
CI/CD pipeline

Real example: B2B SaaS for recruitment. Sign up, connect CRM, dashboard with insights, paid upgrade. Admin panel for metrics. Total: £14,000, delivered in 6 weeks. They raised a seed round 4 months later.

Tier 3: Advanced MVP — £20,000 to £35,000+

What you get: Complex business logic, multiple user types, integrations.

Timeline: 8-12 weeks

Typical scope:

Multiple user roles (customers, vendors, admins)
Complex workflows
Third-party integrations
Real-time features (chat, notifications)
Multi-tenant architecture
More sophisticated UI/UX

Real example: Marketplace connecting freelancers with clients. Both sides had onboarding, profiles, search/matching, messaging, booking, payments with escrow, reviews, admin panel. Total: £28,000, delivered in 10 weeks.

What drives cost up (and down)

Things that increase cost

Factor	Impact	Why
Multiple user types	+30-50%	Each role needs own flows, permissions, UI
Real-time features	+20-40%	WebSockets, state sync, edge cases
Third-party integrations	+10-30% each	APIs are never as clean as documented
Custom design	+15-25%	Off-the-shelf UI is fast; bespoke isn't
Regulatory compliance	+20-40%	HIPAA, GDPR, PCI-DSS add overhead
Native mobile apps	+50-100%	Two platforms, app store review, device testing

Things that keep cost down

Factor	Impact	Why
Clear scope upfront	-10-20%	Less back-and-forth
Existing wireframes	-10-15%	Not starting from scratch
Flexible on tech stack	-5-10%	We use what's fastest
Prioritized feature list	-15-25%	Build what matters, cut what doesn't

The hidden costs nobody tells you about

1. Infrastructure — £50-500/month

Hosting, database, CDN, email service, monitoring. For an MVP, usually £50-150/month.

2. Third-party services — £0-500/month

Stripe fees (2.9% + 30p per transaction), analytics, error tracking, email marketing.

3. Post-launch iteration — £2,000-5,000

Your first version will need changes after real users touch it. Budget 2-4 weeks of iteration.

4. Your time

Even with a dev team, you'll spend 5-10 hours/week on feedback, decisions, and testing.

Poland vs. UK/US: The cost difference

Location	Standard MVP cost	Notes
US (Bay Area)	$80,000-150,000	High salaries, expensive everything
UK (London)	£40,000-80,000	Less than SF, still expensive
Western Europe	€35,000-70,000	Germany, Netherlands, France
Poland	£10,000-20,000	Strong talent, lower cost of living
India/Pakistan	£5,000-12,000	Lower cost, often quality/communication tradeoffs

We're not the cheapest. We're the best value for founders who want quality, direct communication with senior devs, and EU timezone overlap.

What you should actually budget

Pre-seed / Bootstrapped: £5,000-10,000
Build a Validation MVP. Test the core assumption. Don't over-build.

Seed-funded: £15,000-25,000
Build a Standard MVP that can acquire paying customers. Include analytics to prove traction.

Series A / Well-funded: £25,000-50,000+
Build for scale from day one. Invest in architecture, testing, infrastructure.

Red flags when comparing quotes

If someone quotes you significantly below these ranges, ask:

Who's actually doing the work? (Junior devs? Outsourced further?)
What's included? (Design? Testing? Deployment? Post-launch support?)
What's the revision policy?
Who owns the code? (You should. Always.)
What happens after launch?

Cheap quotes often become expensive projects when you're rebuilding 6 months later.

How to get an accurate quote

When you reach out to a dev shop, come prepared with:

One paragraph describing the product — What does it do? Who is it for?
The core user flow — What's the main thing a user does?
A rough feature list — Even bullet points help
Your timeline — When do you need it?
Your budget range — They'll tell you what's realistic within it

The more clarity you provide, the more accurate the estimate.

The bottom line

Building an MVP in 2026:

Validation MVP: £5,000-10,000 (2-4 weeks)
Standard MVP: £10,000-20,000 (4-8 weeks)
Advanced MVP: £20,000-35,000+ (8-12 weeks)

Add 20-30% buffer for post-launch iteration and hidden costs.

Don't pay Bay Area prices for work that can be done at equal quality in Europe. Don't pay bottom-dollar rates and get code you'll have to throw away.

I'm Paweł Reszka, CTO at Inigra — a software house in Poznań, Poland. We build MVPs for startups using AI-assisted development. If you want an honest estimate, book a free discovery call.