The Atlas 2025 MVP Guide - Part 2
How to make your MVP “real” by adding a database, authentication, business logic, powerful AI features and publishing it to the world!
This is part 2 of 2 of the Atlas 2025 MVP Guide. You can find part 1 of the guide here. An in-depth video tutorial is also being developed. Subscribe to receive an update when it launches. If you’re reading this in your email, open it up in the Substack app or view online to read the full article.
Preview of what you’re going to learn how to build…
Before you read this guide, I want to show you the application that I’m going to teach you how to build. By seeing the end result up front, my hope is that this will encourage you to engage fully with this guide and try this process out for yourself! I will consider this guide a success if it encourages at least some of you to start turning your ideas into reality.
We’re building a web application called "BluffNote," an AI-powered meeting notes tool designed to summarise meetings and pinpoint action items. (Yes, it'll even help you confidently sprinkle in buzzwords like "low-hanging fruit", "cross-functional dependencies", and "circle back offline." by integrating with powerful AI-models.)
Without further ado, here is the application I created using the tools and techniques I’m about to share with you. Enjoy!
Click the link to preview the app: https://bluffnote-genius.lovable.app/
Introduction to Part 2
Welcome back to Part 2 of the Atlas 2025 MVP Guide!
I’m Tim Woods, a Digital Transformation Consultant, Product Manager, Startup Founder, and Author based in London.
Over the years, I’ve worked with some of the world’s leading companies—Expedia, The Economist, Thomson Reuters—to build innovative digital products and transform their businesses for the future.
I’ve spent my career helping organizations navigate the ever-changing tech landscape, bridging the gap between business strategy and emerging technologies.
But beyond working with large enterprises, I’m also deeply passionate about helping entrepreneurs, small businesses, and consultants unlock new opportunities through technology—particularly through AI and No-Code/Low-Code tools.
Here’s what I believe…
We’re entering an era where the question is no longer “Is there an app for that?”
Instead, the new mindset is: “I can build an app for that.”
Thanks to AI and no-code tools, it’s now possible to take an idea from concept to a working product in weeks, not years.
We’re flipping the script.
And that’s a huge opportunity for anyone who’s willing to embrace this shift.
Reminder of who this guide is for
If you’re someone who’s trying to turn an idea into reality, build your own internal tools, or bring a product to market faster and cheaper than ever before, then this article is for you:
You’ve got an idea for an app stuck in your head—something that could make a difference in the world—but you don’t know how to make it a reality.
Your team is stuck using off-the-shelf software, spending a fortune on internal tools that don’t quite fit your needs, and you wish you could just build your own solution—but time and resources are holding you back.
You’ve been working with developers for years trying to get an app built, but it’s taking way longer than expected and costing a fortune—you feel like you’re throwing money into a blazing furnace.
You’ve tried learning how to code, but it’s just not landing. You’ve seen people build amazing demos with AI, but you don’t understand how to stitch everything together.
You’re a consultant, and a client has asked for help building an MVP—but you have to outsource the work to a third party, meaning you miss out on the full value you could be creating for your client and your own business.
If any of this resonates with you, you’re not alone.
Recap of Part 1
In Part 1 of the guide, we explored how AI and no-code tools have transformed MVP development, making it faster, cheaper, and more accessible than ever before.
We started by redefining the concept of an MVP—not just as a Minimum Viable Product, but as a Minimum Lovable Product (MLP). Instead of launching something half-baked, we aim to build something small, complete, and delightful that users truly enjoy from day one.
From there, we covered a step-by-step framework for turning an idea into a working product:
✅ Phase 1: Defining the Product with ChatGPT
Used AI to brainstorm, refine, and generate a Product Requirements Document (PRD). We Prioritized features for an MLP—focusing on what makes users love the product, not just tolerate it
✅ Phase 2: Designing the UX/UI with AI-Powered Tools
Leveraged UX Pilot to generate wireframes and UI layouts instantly. We Created high-fidelity designs that align with our product vision, ensuring a seamless user experience
✅ Phase 3: Building the Front-End with No-Code AI Builders
Used Lovable.dev (or alternatives like Bolt.new and WeWeb) to code a fully functional front-end using natural language prompts
Rapidly iterated on designs and built core app features without coding
Ensured the interface and interactions matched the user experience outlined in the PRD and in our high-fidelity wireframes.
Making your app come to life in Part 2
Part 1 was all about defining, designing, and constructing the front-end of your product.
In Part 2, we bring your product to life by integrating a backend, authentication, and AI-powered features, making the MVP fully functional and ready for production!
Here’s a quick overview of what we’re going to cover as we complete Phase 3 of the Atlas MVP framework:
➡️ Power Up Your App with a Backend
Integrate Supabase for authentication, database, and storage (no coding required).
Add user login (email/password) so people can sign up and log in.
Store and retrieve real meeting notes
Power-up our app with advanced AI features using OpenAI’s state of the art Large-Language-Models (LLMs). Our users will be able to generate meeting summaries and extract action items using AI!
Lovable will handle all the heavy lifting, from database setup, creating our AI-logic, to the UI integration.
➡️ Explore Alternative AI App Builders
We’ve been using Lovable as our primary development tool as it’s one of the most powerful natural language programming tools in the market right now. It’s powered by Anthropic’s leading Claude Sonnet 3.7 model under the hood which excels at code generation and creating detailed plans so it’s perfect for our MVP development journey.
But we’ll take a look at some other market-leading solutions that may be a better fit depending on your needs:
Bolt.new – If you need a mobile-first approach (iOS/Android), Bolt is a great alternative to Lovable.
WeWeb – A powerful drag-and-drop builder that offers more customization and control.
Compare Lovable vs. Bolt vs. WeWeb to find the best tool for your needs.
➡️ Publishing Your MVP for the World to See
We’ll then Publish our app so that we can share it with real users and start gathering feedback. We’ll use Lovable’s integration with Netlify to make deploying our application quick and easy. See your idea go from concept to reality!
But We’re Not Stopping There…
As you near the end of your MVP development journey, I think it’s important that you have a map of the road ahead. As your needs grow, no-code tools may reach their limits. You might require custom features, advanced algorithms, or better scalability. Whether you're expanding your app, onboarding developers, or scaling to millions of users, transitioning to low-code can help.
I’m going to give you a quick overview of what you can do next as your technical knowledge grows, or the technical knowledge that you have access to on your team expands.
At this point we’ll be expanding beyond the realm of MVP, so don’t worry too much about this for now. It’s something you can return to in the future. What we covered up to this point will be more than sufficient for you to create a fully functioning, powerful and more importantly “lovable” MVP!
➡️ Phase 4 (Advanced): Taking Control with GitHub + AI Coding Assistants
Export your app’s code to GitHub—so you’re never locked into a no-code platform.
Use AI-powered IDEs like Cursor & Windsurf to add custom features and fix bugs faster. Let AI assist you in modifying the UI, adding new API integrations, and even writing new functions.
➡️ Phase 5 (Advanced): Deploy Like a Pro with Vercel
If you want even more flexibility, we’ll show you how to deploy your MVP on Vercel for scalability and speed. Serverless hosting, automatic scaling, and zero maintenance.
➡️ We’ll conclude by breaking down the pros and cons of using AI + No-Code for building a product.
Is the speed, affordability and accessibility enough to combat potential customisation limits, performance concerns and vendor lock-in? We’ll explore these questions together in this section.
Why You Can’t Miss Part 2
By the end of Part 2, you’ll have:
✅ A real, functional MVP with user authentication and database storage.
✅ A live app on the web, accessible to real users.
✅ The knowledge to extend, customize, and export your code for more control
✅ A clear understanding of when to use AI + No-Code and when custom coding is necessary.
This is where your MVP goes from a pretty prototype to an actual product!
So let’s resume our MVP development journey and pick up where we left off building BluffNote, our AI-powered meeting notes app!
Lights, camera, action…?
Now that we’ve completed part 1, we’ve got a functioning prototype — we can click around the application, move between different pages and seemingly create meeting notes. Amazing!
So are we ready to publish BluffNote to the world and raise $5m in a pre-seed round for our hot new AI startup?
We’re getting there, but not yet! (although I’m sure more has been raised with less…).
What we’ve done so far is create the front-end of our application. Basically, we’ve built the walls of our house, but there’s nothing inside yet that will allow this to function as a home. In other words, we’ve set up a restaurant and we’ve got a nice menu but there aren’t any waiters/waitresses to take orders or chefs in the kitchen to make food.
Before we publish our app, we need to create our back-end (user authentication, database, and business logic).
Integrating a back-end so your app actually does something
“But why do I need all that? I can already create a note and it saves it and I can see it on the dashboard…?”
Yes, but right now Lovable is saving our notes in browser storage (session storage), meaning these notes aren’t being stored in a permanent database yet. So if we close the app and come back, the session storage is cleared, and our notes won’t be there any more.
So to allow our users to save notes long term, we need to connect our application to a database.
We also need to think about security here. We only want users to be able to view their own notes, unless they explicitly share them with other users. So to achieve this we’ll need to add authentication to our application. Basically, we need signup/login flows and rules in our database to say who gets access to what.
Also in our PRD, to enable our application to raise millions in AI venture capital hype-money, we scoped an AI-generated meeting note summary feature and action item extraction tool.
Right now Lovable is just faking this for us by giving us some pre-filled (hard-coded) responses in these boxes. To make this real, we need to create logic that sends the meeting note that we’ve written to OpenAI, prompts one of the OpenAI models to generate a summary of our meeting note, and also extracts Action items from the note. We’ll then need to save these responses in the meeting note table in our database so that we complete the loop and can show these summaries to the user on the front-end.
(If all of this sounds confusing, don’t worry, I’ll explain it all step-by-step later).
Essentially, we make our app real by adding a backend.
Adding a database and login/signup with Supabase
Author’s note: In this section I’m going to start using some technical terms. If you’re technical this should help with your understanding of what’s going on behind the scenes. If you’re not technical, this will begin to familiarise you with some key terminology that will become important to you as you progress on your app development journey. Exposure like this is how you, me and everyone else eventually “becomes” technical, so don’t stress if it’s a bit confusing now. It will all make sense down the line.
Introduction to Supabase
Lovable integrates easily with Supabase for database and authentication needs. Supabase is an open-source backend-as-a-service that provides a Postgres database, user authentication, file storage, and more.
To simplify this further - you can think about Supabase as being an Excel file that lives in the cloud that your application connects to. It’s going to store and connect all of your user data together, and we’re going to build in some logic that means users can only access information that they own. We can also store some larger files and other media here that we can pull into our app if we like.
Connecting Lovable to Supabase
So how do we connect BluffNote to Supabase?
The good news is that Lovable makes this really easy with a native Supabase integration.
With your project open, you should see an option to “Connect Supabase”. You follow a simple setup wizard: log into Supabase (a free account works), create a new project (database), and then Lovable links it to your app.
Here is the official integration documentation for reference.
Enabling users to login/signup
So what do you once it’s connected? Well you can just tell Lovable to start using Supabase for certain features. For example, you might prompt:
Use Supabase to add user authentication (email/password) to the app enabling our users to securely sign up and log in.
Lovable will then configure the Users table in the Supabase database, the authentication service and then generate the necessary login/signup pages for you in the UI!
You can then experiment with this implementation by testing your application and signing up some test users. When you login to your new Supabase project, you should then see something like the below in the Authentication section.
This shows us that new users have been successfully created in our database when we submitted the signup form, and the connection between our front-end and back-end looks to be working!
Our users can now actually sign up and log in to BluffNote, and Supabase handles storing those user accounts securely.
As with all of the prompts that we’re using, don’t panic if it doesn’t get this right first time. If you test it and find that nothing is appearing in Supabase, go back to Lovable and tell it that it’s not working and ask it to create a plan to fix the issue.
Keep iterating until it gets it right.
Enabling users to store data
Next, you want your meeting notes data to be stored in a real database (so that users can keep a record of their notes).
You can instruct Lovable:
Use Supabase to store meeting notes with fields for title, content, AI-generated summary, and action items, and connect it to the front-end.
Under the hood, Lovable will create a new table in your Supabase database (maybe called “meeting_notes”) and adjust the app’s code to read/write from it.
Once again, think of this like creating a new sheet in an Excel file, and giving our users the ability to view the information in it as well as the ability to add new items to it.
In some cases, Lovable might prompt you with a suggested database schema (a bunch of data tables and a mapping of how they connect together) or ask for confirmation. You can simply tell Lovable what data you expect to store.
As we’ve integrated Lovable with Supabase, Lovable will even run the commands to make the database changes in Supabase on your behalf so you don’t need to worry too much about this.
Adding advanced AI features to our app with Supabase and OpenAI
Now that you’ve built the walls of your app using Lovable and connected it to a real database with Supabase, it’s time to bring in some AI magic.
In this section, we’re going to add an AI brain to your application—automatically generating summaries and extracting action items from your meeting notes—all by leveraging OpenAI’s GPT-4o model through Supabase Edge Functions.
What is OpenAI and how do its AI models help us?
OpenAI is a leader in artificial intelligence research and development. They create advanced AI models, that can understand and generate human-like text. These models were trained on billions of parameters of data using tens of millions of dollars. The good news is that we can harness the power of these advanced AI models their with a simple API request costing us less than few cents each time - nice!
What’s an API request? An API request is a message sent from one computer program to another asking for specific data or to perform a task, and then it receives a response back. Think of an API request like sending a note to a restaurant waiter asking for your favorite dish. You tell the waiter (the API) exactly what you want, and then the waiter goes to the kitchen (the computer or server) to get it for you. When the food is ready, the waiter brings it back to you.
When we make API requests to AI models like OpenAI’s GPT4o model, it’s like passing a request off to a near-human like intelligence in the cloud, that is incredibly adaptable to lots of different types of problems we can throw at it. In this case, it’s less like a chef who can make a fixed number of recipes, and more like a multi-talented song-writer, poet, a business consultant and a computer programmer… really whatever you ask it to. The AI will use the data it was trained on in addition to whatever other tools it has access to, to help us with whatever we want (within reason). It all just depends on the prompt we send and the capabilities of the AI model that we’re reaching out to.
How do we connect our app to OpenAI’s AI models?
To unlock these AI superpowers, we need to send our meeting notes to OpenAI by making an API request. Here’s how it works in our architecture:
Crafting the Request: Our meeting note is packaged up (like putting an order on a slip of paper) and sent to the OpenAI API. The API request tells the GPT-4o AI model what to do, for example, “summarize this note and extract action items.”
Using Supabase Edge Functions: In addition to providing a database and user authentication, Supabase also allows us to add business logic to our application. We create logic in the form of “edge-functions”. In English, a function might look something like this, “When the user saves a note, then it should be added to the meeting notes table in our database”. How do we create the edge function? We prompt Lovable to instruct Supabase to create and run an edge function on our behalf. These edge functions will live permanently within Supabase, and we can run them whenever we want. It’s like having preconfigured commands that we can trigger whenever something happens in our app. In this example, we want an edge function that makes an API request to OpenAI, taking the note that the user created and then sending it to GPT-4o to analyse.
Handling the AI Response: Once our Supabase Edge Function receives the AI-generated summary and action items, it updates the meeting_notes table in the Supabase database. This ensures that every piece of intelligent content is saved permanently. Saving the AI responses in your database means your meeting summaries and action items won’t vanish when you close your browser—they’re there every time you log in. (If we just displayed the response from OpenAI on the front-end and didn’t save it, it would just disappear later.)
Showing the response to the user: The front-end we built with Lovable then retrieves the stored data from Supabase and presents it to the user.
Picture the Supabase Edge function as a reliable courier. It takes your "order" (meeting note) to the AI kitchen (OpenAI via an API call), collects the "prepared dish" (AI response), and brings it back to your app—ready to be handed over to the user.
Bringing it all together
One of the best parts of this process is how simple it is to instruct these complex operations using Lovable. Instead of writing endless lines of code, you can once again give Lovable a natural language prompts, such as the following:
We want to enable AI-generated meeting note summaries in our app. Create a Supabase Edge Function that achieves the following: When a user saves a note, make an API request to the OpenAI GPT-4o model prompting it to review the meeting note, generate and return a concise summary of the meeting. Then, save the response that OpenAI provides in the meeting_notes table in Supabase. Create a new column in our meeting notes table to store these AI-generated summaries for each meeting note, if one does not already exist.
Here is what the Edge functions look like in Supabase:
You can see that I’ve repeated the process to create a dedicated function for the extract action items logic and also the generate bs note logic. When you’re creating your own edge functions, don’t try to get them to do too much individually. It’s better to create smaller pieces of discrete logic. You can always call multiple different edge functions to complete an operation within your app.
In Summary
By combining:
OpenAI’s GPT-4o model (our AI expert),
Supabase Edge Functions (our secure, fast mini-servers that handle our business logic),
Supabase Database (our permanent storage), and
Lovable (our natural language application builder),
We transform our basic meeting notes app into an intelligent tool that automatically generates meeting summaries and action items.
This AI-integration enhances the user experience and showcases how advanced AI capabilities can be embedded into our application. BluffNote is now a hot new AI startup to watch!
A quick side-note from me. You have probably seen a lot of companies recently talk about how they have launched state of the art AI capabilities that will transform X or Y for Z! Often what this translates to is what we’ve just walked through. They’re making API requests to these AI model providers to add AI capabilities to their own applications. Of course, some companies are training and hosting their own AI-models, but for the most part they are the exception and often do this because they have very specific use-cases or security requirements to address.
Back-end complete!
After these steps, you now have the core functionality of the app implemented: real database, real user accounts, UI screens generated for all your main features, and spicy new AI-features. All without writing code by hand!
It’s worth pausing here to appreciate how quickly this has come together.
You’re seeing now why non-technical founders have reported using these next-generation app development tools like Lovable to go from zero to a working app in just a weekend or a few evenings. The heavy lifting of setting up a full-stack app (React components, API routes, SQL tables, auth flows) is handled by the AI that’s powering them behind the scenes.
Remember, as a builder, your focus is on describing what you want, reviewing and tweaking the results, and ensuring it aligns with the lovable experience you envisioned.
Publishing your app to the world with Lovable
At the end of this phase, you can now publish your app if you’re happy with it. Lovable has a built-in integration with Netlify for hosting, meaning you can deploy your application to the web with just a few clicks. Once you do this, your application is live to the world! You’ll get a link to your app that you can open up in your browser and share with anyone you like.
Here is the official documentation for more information.
Add a custom domain name
“How do I get the URL to match my brand name?”. When you publish your app with Lovable and Netlify, it will automatically be assigned a URL. It will look something like this: https://bluffnote-genius.lovable.app/
If you want to change this to something else, let’s imagine “bluffnote.com, you will need to purchase a domain name from a service like GoDaddy or DreamHost and then connect this new domain to your Lovable app.
Here is Lovable’s documentation for more information on how to do this.
Ladies and gentlemen, we’re live!
Congratulations, you've officially developed your first app!
By the end of Phase 3, you should now have a working application that closely matches your designs from Phase 2 and fulfils the product requirements from Phase 1.
If you used Lovable or Bolt, you’ve likely already been testing the app in their preview environment. Now try using it as an end-user would: create an account, start a new meeting note, input some vague topics (or just hit BS Mode), and let AI generate key takeaways.
It’s amazing to see an idea that was once just text in a document now running as a real app.
And all this has been achieved for minimal cost – these platforms have free tiers or low-cost plans (often well under $50/month). We’ve essentially eliminated the need for hiring a front-end developer, back-end developer, and maybe even an AWS/cloud specialist at this stage, because the no-code AI tool handled it.
One thing to note: while the app is functional, it might not be perfect. There could be minor UI or functionality issues that you want to refine. And perhaps you have a couple of advanced features in mind that Lovable/Bolt couldn’t fully realize via prompts alone (yet).
Remember, the goal here is to create a Minimum Lovable Product so we can quickly get it into the hands of real users. Real users mean real feedback we can use to improve the app further. So if you’re happy, hit publish and let the world see your creation!
Here is BluffNote in all its glory, created entirely using ChatGPT for requirement planning → UX Pilot for design → Lovable for our front-end and as our AI developer → Supabase for our back-end (storage, autentication and business logic) → OpenAI for our AI powered brain → Netlify to host our app and make it accessible to the world!
Click the link to preview the app for yourself: https://bluffnote-genius.lovable.app/
And if you’d like to receive more tutorials like this in the future, make sure you Subscribe to the Atlas Woods Newsletter.
Alternatives to Lovable (Bolt and WeWeb)
This guide has focused mainly on the use of Lovable as our AI app builder. However, there are other similar tools out that that may be a better fit for you depending on your needs and your skillset.
Bolt.new
Bolt is another AI app builder worth mentioning, particularly if you care about mobile apps (iOS/Android). Bolt is very similar to Lovable as it allows you to prompt an app into existence.
The key difference is Bolt can generate and run mobile apps using Expo/React Native (as well as web apps). So if your product needs a native mobile component, Bolt is a great option.
Its interface is very similar – you start with a description of your app, and it outputs a working project you can preview on the web or in an Expo Go app on your phone. Both Lovable and Bolt offer that magical prompt-to-app generation and have Supabase integration for backend if needed.
The AI results from the two are often comparable. This is because they’re both using the same AI model behind the scenes (Anthropic’s Claude 3.7 Sonnet LLM).
For a web-first product, both Lovable and Bolt are fantastic; for mobile, Bolt might save you time by handling device-specific setup.
WeWeb
Another alternative is WeWeb, a leading no-code web app builder that offers a more traditional no-code-esque drag-and-drop interface, which is very powerful for building custom web apps without coding.
WeWeb doesn’t rely solely on AI to generate your app; instead, you can visually assemble pages and logic. However, they did recently introduce their own natural language prompting feature called WeWeb AI that in many ways looks to combine best-in-class visual programming tools with natural language prompting.
Consider WeWeb if you want more fine-grained control over design and you’re comfortable configuring more things manually. WeWeb lets you bind data to UI elements, call APIs, and manage state all through a visual interface, which can be easier for some people than trusting AI only. The trade-off is it might take longer than the AI-only approach if you’re new to this.
WeWeb (and similar tools like Bubble or Adalo) can accelerate development massively compared to coding from scratch. Another advantage is they have pre-built components for common things like login forms, lists, etc., and you simply configure them.
Next steps
If there’s still something important missing from your app at this stage and you want to make further and more advanced changes, then you can move on to the next phase, which includes deeper customization using low-code tools and possibly deploying your app using another hosting provider called Vercel.
However, I should caveat that this is for more technical users. If you’re non-technical, you can skip this next part (or consider getting professional help) and I’ll see you back in the Conclusion section!
Phase 4: Advanced Functionality with GitHub + AI IDEs (Cursor/Windsurf)
So now you have a functional MLP, built with no-code/low-code tools. Congratulations, you can end your journey here!
In fact, if you’re very non-technical I would encourage you to do so but to also read ahead to get a flavour for what a more advanced implementation beyond this point might look like. This will equip you for steps you may wish to take in the future as your product grows!
As your needs evolve you may hit the limits of what the tools that we’ve discussed can provide:
Perhaps there’s a specific feature your app needs or an advanced algorithm that isn’t straightforward to create via prompts alone.
Perhaps you’ve achieved some success with your MLP and you’re now ready to bring some developers onboard to scale your application to more users or more widely within your business.
Perhaps you’re ready to go full-unicorn and scale your application to a million users and you need some more advanced hosting options.
This is where you may want to start transitioning from pure no-code to “low-code” by tapping into the codebase. The good news is, modern AI-assisted coding tools make this far easier than manual coding alone.
In Phase 4 and Phase 5, we’ll go even deeper into the low-code world to customize and enhance your application beyond MVP status.
We’ll discuss how to export or sync your project’s code to GitHub and use AI-powered IDEs like Cursor or Windsurf to implement advanced functionality quickly before deploying your application on Vercel’s scalable hosting infrastructure.
This won’t be an exhaustive overview on how to use these tools. At this point we’re extending beyond the realm of MVP (this is supposed to be an MVP guide after all!)
However, I will publish more detailed guides on these topics later so make sure you subscribe to the Atlas Woods newsletter to stay updated.
Expose your code
First, let’s get access to our code.
Lovable allows us to connect our application to a GitHub repository. Think of GitHub like a folder in the cloud where you can store and publish changes to your application’s code files.
With a couple of clicks, you can sync your app’s source code to a GitHub repo under your account. Now you have the entire project – front-end code, backend/serverless functions (if any), configuration – all in code form that you can edit and host wherever you want.
This is a crucial capability because it means you’re never truly “locked in” to the no-code tool. You can always take the code and extend it or even hand it to developers down the road.
Similarly, Bolt, WeWeb and some other AI builders provide ways to download or sync code. But that’s not always the case so don’t take this for granted when selecting a no-code solution.
For our scenario, let’s assume we now have our BluffNote code synced on GitHub.
Add your advanced features
Now, to add our advanced features.
Instead of manually coding them from scratch, you can fire up an AI-enabled code editor like Cursor or Windsurf. These are next-generation Integrated Development Environments (IDEs) that have AI-copilots deeply integrated. Essentially, these tools combine the functions of an editor and ChatGPT-style assistant tuned for coding.
You might be thinking - “Wait a minute… isn’t this basically the same thing that Lovable was doing?” How astute of you. And the answer is yes… kind of.
Tools like Lovable, Bolt and WeWeb abstract a lot of complexity away from you. Cursor and Windsurf take you back stage and give you full view of everything going on in your codebase. You can make manual code changes to your files in addition to being able to make code changes using the AI natural language interface. For this reason you get much more fine-grained control over your application.
You can even use different AI models depending on your use-case. This is great as some models are better than others at different things. For example, OpenAI’s o-series reasoning models are strong at breaking down complex technical changes and creating detailed implementation plans but are generally slow when it comes to making code changes. On the other hand, Google’s Gemini Flash models won’t be as intelligent when it comes to planning but they are good at making code changes quickly.
Use Cursor/Windsurf to add features or fix Issues
With your Lovable project synced to a Github repository, open your project from the repository in Cursor/Windsurf. This pulls in all of the code that you’ve created so far using Lovable.
On one side, you see your codebase (files, folders—just like VS Code). On another, you have a chat panel where you can ask the AI to add features or fix issues in your code, just like Lovable.
By pulling your code into a more traditional IDE and syncing changes with Github, we enable more traditional development and release workflows. We can now more easily build a team around our project and allow multiple developers to work on our product at once while maintaining strict version control, code review and deployment processes.
Phase 4 summary
In summary, no-code and AI got you 90% of the way, and a bit of AI-assisted low-code can get you the last 10%.
Not every MLP will need this step – many apps can go live with just the no-code tool’s capabilities. But it’s comforting to know that if you do need to dip into code for a custom touch, you don’t have to go it alone. Even a founder with modest coding experience can implement fairly advanced features with the help of Cursor or Windsurf acting as a smart pair-programmer.
And importantly, this doesn’t break the bank: these AI IDEs are fairly low-cost, and the speed at which they enable changes means you might spend just hours instead of days on your customisations.
By the end of Phase 4, your MLP should be feature-complete and polished. You have the core that was generated via no-code AI, plus any special sauce added via low-code. You’ve also opened the door for some developers to come in and extend your application further. You’ve effectively combined the power of no-code development with traditional code where necessary – a hybrid approach that maximizes speed without sacrificing flexibility.
Now, for the final step: enabling our app to scale to millions of users.
Phase 5: Deployment with Vercel
With a working product in hand, the last step is to deploy it so that users can access it. Of course, if you deployed your app using Lovable in Phase 3 then you’re already there!
But if you want to know more about alternative deployment options, scaling considerations as your app grows and how all of this comes together, then stick around for this section.
Deployment used to be a complicated affair – provisioning servers, configuring hosting, dealing with DNS, and so on. But now, services like Vercel make deploying a web application more simple, while providing production-grade performance and scalability out of the box.
Vercel is a popular choice for hosting applications for a few reasons: it’s relatively easy to use, scales automatically, and offers a lot of developer-friendly, serverless features which pair well with the stack we’ve used already (React front-end, serverless functions, etc.).
If your code is on GitHub (refer to Phase 4), deploying to Vercel is fairly straightforward. You sign into Vercel (there’s a generous free tier), click “Add New Project”, and import the GitHub repo of your app. Vercel will automatically detect the framework (for example, a React/Vite app or Next.js app) and apply the correct build settings. Then it’s one more click to deploy.
Vercel will then “build” your application and host it on a global edge network. You get a secure URL like your-app-name.vercel.app where the app is live. This means you can start sharing the product with beta users or teammates immediately, without worrying about setting up any infrastructure. You can add a customer domain name later.
What makes Vercel especially powerful is how it handles scaling and back-end functionality. Vercel was built largely with the concept of serverless functions and static frontends in mind. So if your app has any backend API routes (for example, maybe some custom function you wrote in Phase 4), Vercel will deploy those as serverless functions that run on demand. You don’t have to manage a separate back-end Node.js server or an Express app – Vercel takes your API code and hosts it, scaling it from zero to many invocations seamlessly.
This is good for an MLP: you likely won’t have huge traffic on day one, but if you suddenly do (imagine your app goes viral), Vercel can handle it by scaling up to thousands of function invocations without you doing anything (their platform can run tens of thousands of functions in parallel as needed).
Deployment on Vercel can be free for small projects, which fits our under $100 budget. The hobby/free plan can handle plenty of usage for an early-stage product. As the app grows, you can upgrade to higher tiers, but you only do so once you have the traction to warrant it. This usage-based model is cost-effective for startups with the promise of starting small and scale as your needs evolve without large upfront costs.
A very important disclaimer here is that if your app does go viral and scales to the moon, Vercel costs will scale too, so be careful if you’re bootstrapping a free app or you might find yourself out of pocket. Alas, the dream of going viral is often just that, a dream, but I mention this as a “buyer beware” just in case.
Phase 5 summary
To sum up Phase 5: you take your lovingly built MLP and push it live using Vercel’s platform. In minutes, your product is accessible to the world at a stable URL. No servers to manage, no complex deploy scripts.
You can now share the app with early users, stakeholders, or even post it on Product Hunt to gather feedback. And you can do so confidently, knowing that if your user base grows, Vercel will handle the scaling and you won’t wake up to a server crash.
This lets you focus on what matters next: observing how users interact with your MLP, gathering feedback, and iterating on the product.
Strengths and Weaknesses of This MVP Stack
Congrats, you’ve done it!
By following this end-to-end MVP creation framework: ChatGPT for ideation → UX Pilot for design → Lovable + Supabase + OpenAI for building → AI IDEs for advanced coding and collaboration → and Vercel for deployment – you’ve leveraged the strengths of AI and no/low-code at every step.
I want to end this guide by taking a look at the strengths and weaknesses of this framework as I see it in early 2025. These will of course change as these tools and AI models become increasingly more powerful, so consider this a snapshot of their capabilities at this point in time.
Strengths
Speed
Tasks that normally happen sequentially over months were done in days or even hours.
Brainstorming and writing the initial PRD took less than an hour with ChatGPT instead of weeks to draft
Designing a full prototype took perhaps a day with AI assistance
Building a functional app was done largely automatically by Lovable/Bolt in another day or two
Any custom coding was sped up by our AI pair-programmers in our Cursor/Windsurf IDEs
Deployment the application to the world on Vercel took minutes.
We’ve compressed the product development timeline dramatically. This speed means you can get to user feedback faster and iterate more rapidly. In the lean startup philosophy, quick validated learning is key – and this stack maximises how quickly you can get an initial product in front of users to learn what they love or don’t love about it.
Affordability
Every tool used is either free or low-cost.
ChatGPT can be used for free (though ChatGPT Plus at $20/month will give you higher usage limits and access to some more advanced AI models – still, that’s optional. We used the free tier and the GPT-4o model to create our PRD in this guide).
UX Pilot has a free tier and a paid plan around $6/month for full features.
Lovable and Bolt currently have free trials/quotas and relatively low subscription costs (for instance, Lovable’s paid plan is in the tens of dollars per month range).
Supabase offers a free tier that is plenty for MVP usage.
The AI coding assistants like Cursor and Windsurf have free versions with usage caps.
Vercel’s hobby tier is free and can support a surprisingly large amount of traffic for a basic app.
All told, you can certainly keep the total cost under $100 for the time it takes to build and validate your MLP. The only paid version of a tool I needed here was Lovable which cost me $20 for one month of access (the free usage of 5 prompts per day didn’t cut it for me).
Compare this to hiring a developer (even a freelance developer might cost $50+ per hour, quickly exceeding our budget) or a designer or paying for server infrastructure – we saved enormously on those fronts.
For a cash-strapped startup or solo founder, this cost efficiency can be the difference between being able to pursue an idea or not.
Accessibility
Perhaps the biggest win is that you don’t need to be an expert coder or designer to execute this plan. Non-technical or semi-technical founders can self-serve a portion of the product development cycle. This stack lowers the barrier to entry.
ChatGPT helps you articulate product ideas without needing product management training.
UX Pilot designs interfaces so you don’t need a UX degree.
Lovable writes code so you don’t have to (and it uses best-practice frameworks under the hood, so you’re automatically following decent architecture).
The coding abilities of this latest generation of AI models mean that even if you’re not comfortable with some programming language, the AI can bridge the gap.
It’s empowering – if you have a vision for a product, you no longer must have a CTO or dev team to start building it. You can prototype it yourself and even launch an initial version.
This is not to say experts are obsolete (far from it, as we’ll note in weaknesses), but the point is you can go quite far on your own now with a little bit of knowledge.
Weaknesses
Despite these strengths, it’s important to acknowledge the limitations and weaknesses of this AI + no-code approach:
Limited Originality/Customization:
The outputs from AI and templates can be somewhat generic. Without further customisation yoir app might look a little similar to others or follow standard patterns that the AI knows. While that’s not inherently bad (users are comfortable with familiar patterns and if you don’t know what you’re doing, your app looking like other apps and not like it was drawn with crayon is actually a good thing!), truly cutting-edge design or novel interactions will require human creativity beyond what current AIs offer.
No-code builders like WeWeb also have preset components – if you want a very unique UI, you might feel constrained (once again unless you’re willing to customise them manually). We mitigated this by doing custom coding in Phase 4 when needed, but if your product’s differentiation is heavily tied to a custom user experience or complex functionality, a no-code approach might struggle.
In those cases, you may eventually need to rebuild parts of the app with custom code written by developers or engage a designer to overhaul the UI beyond the AI’s suggestions.
Performance and Scalability Constraints:
No-code platforms, while convenient, might not be as optimized as hand-written code for specific use cases. If your app needs to handle extremely high throughput or very data-intensive operations, you could hit performance issues. For instance, an app built with lots of visual elements in a no-code tool might load slower than a hand-optimized equivalent.
Also, while Supabase and Vercel scale well, some no-code platforms have usage limits and can get expensive as you scale. An approach that’s fine for 100 users might choke on 100,000 users.
The flip side is that by the time you have that many users, you will likely have resources to invest in scaling or rewriting parts of the system. But it’s a consideration: an MLP built quick and dirty may need re-engineering later (which is okay as long as you plan for it).
Vendor Lock-in and Tool Longevity:
Relying on specific platforms means you are somewhat tied to them. If one of these services changes pricing or shuts down, it could impact your product.
We mitigated this by exporting code from Lovable, so we have an escape hatch. But if you built heavily inside a proprietary platform and can’t get access to the raw code easily (some no-code platforms are like walled gardens), migrating away can be like trying to get chewing gum out of your hair. It’s something to be aware of.
The strategy of using open-source friendly services like Supabase and having your code in GitHub helps reduce this risk.
Learning Curve and Team Collaboration:
While these tools are easier than coding everything from scratch, there is still a learning curve to each. You have to learn how to prompt ChatGPT effectively, how to phrase instructions for UX Pilot to get the design you want, how Lovable expects you to describe features, etc. It’s a different skill set (prompt engineering, essentially).
If you have a team, not everyone may be familiar with these tools initially. Additionally, collaborating in no-code environments can be trickier than in code (where you have Git). Thankfully Lovable allowed Git sync, so teams could collaborate via GitHub. But not all no-code platforms have good multi-user collaboration features, which can hamper a larger team’s workflow.
If you’re solo or a pair, it’s fine; if you have 5+ people, you might need to establish processes for how you all work with the AI tools.
Quality Control and Bugs:
Just because AI builds it doesn’t mean it’s perfect. AI can introduce bugs or make incorrect assumptions. No-code logic can also have quirks that are hard to debug without code visibility. You still need to test your product thoroughly.
So as a founder, you should allocate time to really use your app and maybe get a technically-minded friend to poke around it.
The plus side is AI can also help fix the bugs as we saw, but you have to notice them first.
Summary
Despite these weaknesses, the net benefit of this approach is huge for getting to a lovable initial product quickly. The strategy is to use this stack to validate your idea and delight early users, and if you hit a ceiling, you can gradually replace or augment parts of it with more custom solutions.
Many successful startups began with a scrappy no-code or low-code MVP and then rebuilt with a full engineering team once they proved the market and raised funds.
There’s no shame in that – in fact, it’s often the smartest route to avoid over-investing upfront.
For more insights into AI and no-code platforms, make sure you follow the Atlas Woods Newsletter.
Conclusion and Next Steps
In 2025, building a tech product is no longer reserved for those with deep pockets or coding superpowers. As we’ve illustrated, you can go from idea to a Minimum Lovable Product in mere days, for under $100, by smartly combining AI and no-code tools.
Instead of a clunky MVP that users endure, you can deliver a polished, loveable experience from the outset – one that makes your early adopters say “Wow, I can’t believe this is version 1!”
That kind of delight is invaluable in today’s landscape where users have seen countless apps and have little patience for half-baked efforts. As Jason Cohen reminded us, “The Darwinian success loop of a product is a function of love, not of features”.
By focusing on what makes users fall in love – great design, smooth functionality, solving a real problem elegantly – and by leveraging modern tools to execute fast, you dramatically increase your odds of building something that sticks.
So, what are you waiting for? The barrier to try has never been lower. If you have a product idea nagging at you, take a week and build your MLP.
Start by talking it through with ChatGPT; you might be surprised how quickly it evolves from a concept to a concrete plan.
Use UX Pilot or even pen-and-paper to sketch it out.
Fire up Lovable or Bolt and see your app come to life before your eyes.
Don’t worry if you’re not “technical” – let the AI helpers do the heavy lifting on the code, while you steer the vision. And if you are technical, this approach will just save you a ton of time, letting you focus on the interesting parts rather than boilerplate.
When you do launch your MLP (and do launch it – even to a small group of friends or beta users), pay close attention to how people use it and what they love or don’t love. That feedback is your compass for where to go next. The beauty of having used this stack is that you can iterate rapidly. Need to change a feature? Update your prompt or tweak the design and redeploy – easy. In essence, you’ve set yourself up to be super agile.
My goal with Atlas Woods is to help founders, businesses and creators get their ideas off the ground. The landscape of product development is changing fast with AI and no-code, and those who embrace it can move at lightning speed.
I encourage you to experiment with these tools and share your experiences. Have you built something with AI assistance? What worked and what didn’t? I’d love to hear your stories. The more we all learn to navigate this new paradigm, the better products we’ll collectively create.
Remember that technology is a means to an end. Our end goal is a product that people love. AI and no-code are just the accelerants to that goal – the spark is still your unique idea and understanding of your users’ needs.
So take that spark and set it ablaze with the process outlined above. You might be astonished at how much you can accomplish in a short time. Your Minimum Lovable Product is within reach – go build it and let the world see what you’ve got! 🚀
Whenever you’re ready there are 2 ways that I can help you
The Atlas Woods Newsletter: Subscribe to the Atlas Woods Newsletter to be updated when more free articles and tutorials like this become available. We publish one article per week on business transformation, AI and no/low-code to help you stay ahead of your competition and thrive in the rapidly changing world of tech!
The Atlas Build with AI and No-Code Course: Join the Waitlist for our new online course. Want to build an MVP for your new startup and raise funding, build internal tools for your team and cut costs, or build something to make the lives of your community better? Learn how to use AI and no/low-code development tools to bring your ideas to life, even if you aren’t technical. Save years of trial and error and thousands of dollars on development fees.