The Atlas 2025 MVP Guide - Part 1
How to build your MVP or internal tool with AI and No-Code even if you’re not technical.
This is Part 1 of 2 of the Atlas 2025 MVP Guide. You can click here to read Part 2. An in-depth video tutorial is also being developed for subscribers. Subscribe to receive an update when it launches.
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 going to build 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.")
Without further ado, here is the application I created (in 1-day) 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
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 organisations 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.
Who is this guide 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.
My startup journey and building MVPs (Minimum Viable Products)
Back in 2017, when we built our first startup, we followed the traditional path: we hired a third-party development team, spent tens of thousands of euros, and after a year of effort, we had an MVP.
But even after launch, development cycles remained slow, limiting our ability to iterate and scale.
On the side, I experimented with no-code tools to create landing pages, automate workflows, and build simple integrations. But back then, these tools were fairly limited. They weren’t powerful enough to create fully functional applications—especially the kind that could replace custom development.
I had so many ideas, but I couldn’t execute them without relying on expensive engineers. As a business and law major (not a computer science graduate), it was frustrating to know exactly what I wanted to build but not have the technical skills to make it happen.
That’s why the AI and No-Code/Low-Code revolution is such a game changer and why I’ve been obsessed with these tools for almost a decade now.
How I found the solution
Fast forward to today, and the landscape has changed entirely.
Over the years, I’ve worked across multiple industries and global teams—from the UK and US to Ukraine and India—helping businesses navigate digital transformation. In my work as a Management Consultant and Product Manager, I’ve had a front-row seat to the rapid advances in AI, automation, and no-code technologies.
I’ve spent years working with engineers, designers, and product teams to build and launch digital products. I’ve also helped businesses become more agile and adaptable, preparing for an uncertain future where the ability to quickly create and iterate on software is a competitive advantage.
The truth is, we’re already living in the future.
Those of us deeply embedded in AI and no-code development see the world differently. My peers and I often joke that it feels like we’re five years ahead of everyone else, already operating in a world where AI co-builds software and where anyone—regardless of technical background—can create applications.
That’s why I feel a responsibility to share this knowledge. To help more people—entrepreneurs, business owners, consultants—understand what’s now possible. To show you how you can build, automate, and scale with AI and no-code tools.
Because if you’re not leveraging these technologies, you’re leaving money on the table.
Here’s what I’m seeing today
I’ve watched small teams build AI-generated MVPs in a matter of weeks—raising millions in venture funding.
I’ve seen businesses create custom internal tools that save tens of thousands of dollars per year, replacing clunky third-party software with something tailor-made for their teams.
I’ve even seen people build video games just for the fun of it.
The barriers to building software are crumbling. We are no longer limited by technical complexity, high development costs, or long timelines.
The tools are finally here to let anyone become a builder.
The new world of MVP development in 2025 and beyond
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.
Here’s what you’ll learn by following this guide
If you want to:
Build an MVP for a startup and raise funding
Create a new tool for your community
Develop internal software to replace overpriced, inefficient systems
This article will show you exactly how to turn your ideas into reality using the latest AI and No-Code/Low-Code tools.
I’ll walk you through a step-by-step framework that allows you to build and launch functional software faster and cheaper than ever before—without needing to write a single line of code.
Welcome to the future of software development.
The 2025 MVP Stack
The road ahead
Until recently, building even a simple product people enjoy was a costly, time-consuming endeavour. A decade ago you might spend 6+ months and tens of thousands of dollars to develop an Minimum Viable Product (MVP) with a team of engineers and designers.
Today, thanks to AI and no-code tools, that same process is dramatically faster and cheaper. Generative AI can help write you brainstorm ideas, create product specifications and code, while no-code platforms handle the heavy lifting of design and infrastructure.
In 2025, the barrier to creating an MVP is lower than ever – you can often go from idea to a working app within a week and for under $100 in tool costs.
This guide will walk you through a practical step-by-step framework and tech stack for doing just that, using AI and no/low-code: from brainstorming the concept → designing the interface → building the app → adding advanced features → and finally deploying the app to the world.
Each phase highlights the tools (ChatGPT, UX Pilot, Lovable, Bolt.new/WeWeb, Cursor/Windsurf, Vercel) and how to use them effectively.
By the end, you’ll see how what once took an army of experts can now be accomplished by a solo founder armed with AI – and why focusing on lovability over mere viability leads to better products.
Key Idea: With the right approach, you can build a Minimum Lovable Product – a simple but delightful app that users truly enjoy – in a matter of days for under $100.
Let’s see how, step by step.
Minimum Lovable Product (MLP) vs Minimum Viable Product (MVP)
Before we start building our MVP, let’s make sure we understand what an MVP should actually be. This way we set ourselves up for success from the start.
Wisdom brought down from the mountains of Silicon Valley holds that you should launch something very basic very quickly, and get it into the hands of users so you can start getting feedback and improving on it from there. Basically, launch early enough that you’re embarrassed by your version 1.0 release.
While I think this is directionally correct, the problem is, if you hand users something that looks rubbish and doesn’t really do anything, then how valuable is the feedback actually going to be? They’re not going to have much interest in you or your big idea.
Instead, we should try to build something small but complete. Our app should actually solve a real problem end to end. And it should look decent as well. As we go through this guide you’ll see why there is little excuse anymore for your apps to look like they were designed in Microsoft Word, even if you don’t know the first thing about design.
As entrepreneur Jason Cohen argues, most MVPs often lean more “minimal” than they do “viable”. Customers end up hating MVPs that feel half-baked or incomplete. A Minimum Lovable Product (MLP) by contrast, focuses on a delightful core experience.
Cohen suggests the first version should be “Simple, Loveable, and Complete” – in other words, narrow in scope but polished and satisfying to use.
For example, early Google Docs had only a fraction of Microsoft Word’s features, but it did a decent job at what it was primarily designed for – real-time collaboration – and users loved it. As Cohen succinctly puts it, products that do less but are loved, are more successful than products which have more features and are disliked.
So rather than building a Minimum Viable Product (MVP) we should aim for a Minimum Lovable Product (MLP) instead. We should create the smallest version of our idea that customers truly love, not just tolerate. It’s a step beyond the classic MVP.
For this reason, I’m going to use the term MLP rather than MVP throughout this guide as a reminder of what our end goal is.
The takeaway: aim for love at first sight with your product’s initial version.
Phase 1: Defining the Product Requirements (PRD) with ChatGPT
The first step in any product journey is defining what you’re going to build. This usually takes the form of a Product Requirements Document (PRD) – a blueprint outlining the product’s purpose, features, target users, and scope.
In the past, writing a good PRD meant long brainstorming sessions, stakeholder meetings, and multiple revisions. The responsibility of writing a PRD normally rests on the shoulders of a Product Manager who collaborates with the Business, Customers, Engineering and Design, to build out the vision and requirements for a new app or feature.
Now you can accelerate this process dramatically with AI assistance. ChatGPT, OpenAI’s conversational AI, can act as a sounding board, research assistant, and copywriter all in one, helping you craft a solid PRD in a fraction of the time.
Start by brainstorming your product concept with ChatGPT
Open a chat (or use voice input for a more free-flowing experience) and describe your idea.
You can signup and get started with a free ChatGPT account. Upgrading to a paid plan gives you access to some “smarter” AI models. But the GPT-4o model that comes with the free plan is all you need for now (I have a paid plan and regularly use this still as it is fast and allows for quick iterations.)
So I have a rough idea for an application. Here’s the first prompt that I’m going to give ChatGPT.
“I want to build an AI-powered meeting notes app that helps people sound smarter in meetings - let’s brainstorm what it should do.”
ChatGPT can reply with suggestions for key features (e.g., real-time collaboration, AI-generated meeting summaries, jargon enhancement, and action item extraction) and even potential user personas.
Treat it like a colleague in a whiteboard session: ask follow-up questions, clarify the user’s needs, and have it to elaborate on interesting suggestions.
Because ChatGPT has knowledge of countless apps and user preferences from its training data, it can surface ideas you might miss and help refine vague thoughts into concrete features.
Next, have ChatGPT draft the PRD
With our brainstorming complete, w’ere going to ask ChatGPT to help us create a PRD. AI tools can significantly simplify the process of drafting and updating PRDs, freeing you to focus on higher-level thinking.
“Generate a Product Requirements Document for this app. Include an overview, core features (with descriptions), and target user profiles.”
In a few seconds, you’ll get a structured draft.
ChatGPT (or similar generative models like Anthropic’s Claude) will analyse common patterns from existing products and user feedback to produce a comprehensive first draft. For instance, it might propose sections like “Objectives”, “User Stories”, “Feature Set”, and “Metrics for Success” without you having to remember all those headings.
Now, iterate on that draft with ChatGPT.
Great, so at this point ChatGPT has a draft PRD for us. We now want to start prioritising what we’re going to build first.
We’re going to ask ChatGPT for help with this:
“Good start. Now, which features are absolutely essential for version 1, and which can wait?”
ChatGPT can help prioritise the feature list, identifying what will make the product lovable. Perhaps it suggests that AI-powered note summarisation is a must-have, whereas real-time collaboration features and integrations with Slack can be phase 2.
You can also prompt it to critique the PRD:
“Do you see any gaps or risks in this plan?”
It can point out missing considerations (like moderation of user content or the need for an onboarding tutorial), acting as a second pair of eyes.
By iterating in conversation, you refine the PRD each round. This back-and-forth is essentially an AI-powered brainstorming loop, and it’s even more natural in voice mode – you can talk out ideas and hear ChatGPT’s responses, making the process feel like a real-time discussion.
Below is the full PRD that ChatGPT and I came up with (yes we’re going to have some fun with this idea).
Is this a perfect PRD? No, we could improve it, but it’s good enough for our purposes today.
Product Requirements Document (PRD) for “BluffNote”
1. Overview
Product Name: BluffNote – The AI-Powered BS Generator for Meetings
Description:
BluffNote is a collaborative, AI-powered note-taking app designed for professionals who want to sound smarter in meetings—without actually paying attention. It generates intelligent-sounding meeting notes, key takeaways, and action items from minimal input, ensuring users always appear engaged and proactive. With built-in AI summarization, jargon enhancement, and collaborative features, BluffNote makes any meeting seem productive—whether or not you actually were.
Target Audience:
Busy professionals who sit through endless meetings and need instant notes.
Remote teams who want collaborative note-taking but don’t always listen.
Startup founders & executives who need AI-generated insights and action points.
Students who want AI to summarize lectures they only half-heard.
Core Value Proposition:
Turn vague meeting topics into professional-sounding notes and action items, instantly. Users input a few key points, and BluffNote generates:
✔️ Comprehensive meeting summaries (even if you zoned out).
✔️ Smart action items (for other people to do).
✔️ Profound-sounding quotes to drop into conversations.
✔️ BS Mode: AI-generated insights based on buzzwords alone.
✔️ Real-time collaboration so teams can collectively “align” (without effort).
2. Core User Flows
To make BluffNote intuitive and useful, we define the following core user flows:
User Flow 1: Creating a New Meeting Note
User logs in (or uses guest mode).
Clicks “New Meeting Note.”
Enters a few key topics (or leaves blank for pure AI BS Mode).
Clicks “Generate Notes.”
AI generates full meeting notes, key takeaways, and action items.
User can edit, refine, or accept the AI-generated output.
User saves or shares notes with the team.
User Flow 2: Collaborating on Meeting Notes
User creates a note and selects “Enable Collaboration.”
Shares a link with teammates (no login required for viewing).
Teammates can edit, comment, or react to AI-generated content.
Finalized notes are saved/exported to PDF, Slack, or email.
User Flow 3: Using BS Mode (No Input Needed!)
User selects “BS Mode.”
AI generates meeting notes from thin air (or vague buzzwords like “synergy” and “alignment”).
User copies and pastes into emails or reports.
User Flow 4: Exporting & Sharing Notes
User finalizes notes.
Selects export options:
PDF
Email
Slack
Google Docs integration
Shares with team or manager.
3. Main Screens & Functionality
1️⃣ Home/Dashboard
Purpose: Quick access to new or existing notes.
Features:
“New Meeting Note” button
“Recent Notes” list
“BS Mode” shortcut
User profile & settings
2️⃣ New Meeting Note Page
Purpose: Capture topics and generate AI-powered meeting notes.
Features:
Input field for meeting topics (optional)
“Generate Notes” button
AI-generated meeting summary, key takeaways, and action items
Edit mode for manual refinements
“Save” and “Share” options
3️⃣ Collaboration Mode
Purpose: Allow teams to edit and refine AI-generated notes together.
Features:
Live multi-user editing
Commenting & reactions
Version history
“Finalize & Export” button
4️⃣ BS Mode Page
Purpose: Instantly generate random but believable meeting notes.
Features:
No input needed
AI auto-generates meeting notes, action items, and smart quotes
“Regenerate” button for alternative versions
5️⃣ Settings & Integrations
Purpose: Customization and third-party integrations.
Features:
User profile & preferences
AI settings (formality level, verbosity, tone)
Export integrations (Slack, Google Docs, Notion, Email)
Subscription management (if premium features added)
4. Technical Considerations
Tech Stack:
Frontend: React (for web), React Native (for mobile)
Backend: Supabase (for database & authentication)
AI Features: OpenAI API (GPT-4o for text generation)
Database and Authentication: Supabase
Hosting: Vercel or Netlify (for instant deployment)
AI Prompts & Functionality:
Meeting Summary Prompt: “Summarize this meeting in business language with clear takeaways.”
BS Mode Prompt: “Generate a professional-sounding meeting summary using only these keywords: [synergy, alignment, stakeholders].”
Action Item Extraction Prompt: “List action items based on this meeting text.”
Smart Quotes Prompt: “Generate an insightful business quote relevant to [topic].”
5. Future Roadmap (Beyond MVP)
🔹 Voice Transcription: AI listens and transcribes key meeting points.
🔹 Sentiment Analysis: AI detects “mood” of meetings (optimistic, tense, neutral).
🔹 Integrations with Calendar Apps: Auto-pulls meeting topics.
🔹 Premium Version: Pay for advanced AI features or unlimited BS Mode.
🔹 McKinsey Mode: A specialised setting where AI-generated meeting notes and recommendations consistently suggest cutting costs and increasing revenue—regardless of the actual discussion.
6. Summary
BluffNote is a humorous but highly practical AI-powered meeting notes app that enables users to fake it till they make it in professional settings. With AI-generated summaries, action items, and smart quotes, users will always sound prepared—even if they weren’t listening. Built for speed, collaboration, and fun, this MVP is both easy to develop and a potential viral hit.
Beware of limitations
Of course, AI has its limitations in this role. ChatGPT doesn’t inherently know your specific vision or constraints except what you tell it, so be sure to feed in context. It may also propose features that sound good in theory but aren’t feasible for you to build; you’ll need to apply your judgement. Use ChatGPT’s suggestions as a springboard, not gospel.
Additionally, the AI might sometimes produce generic outputs – e.g. boilerplate text or assumed requirements that don’t fit your usecase – so you’ll want to edit the PRD to give it your team’s (even if “team” is just you!) unique perspective and voice.
Phase summary
Overall, writing the PRD with ChatGPT saves huge amounts of time. It’s like having a product manager and technical writer on call 24/7. You can generate a solid first draft in an hour instead of a week. More importantly, ChatGPT helps ensure you haven’t missed any obvious features or user expectations for a lovable product.
By the end of Phase 1, you should have a concise PRD that clearly defines the problem you’re solving, the core features that will make users love the solution, and the goals for success.
With that in hand, you’re ready to move from “what to build” to “how it looks and feels.”
Phase 2: Designing the UX/UI with UX Pilot
With a PRD outlining the features of your MLP, the next step is to design how users will interact with those features. This is where UX (User Experience) and UI (User Interface) design comes in – creating wireframes and mockups of your app’s screens and user flows.
Traditionally, you might sketch layouts on paper or draw them in tools like Figma, then refine through many feedback cycles. Now, AI can give your design process a serious boost.
UX Pilot is one such AI-powered design tool that can transform your written ideas into interface designs within seconds.
UX Pilot AI acts like an on-demand UX designer. You feed it a description of a screen or flow, and it generates a proposed design for you. It’s capable of suggesting design patterns that enhance usability and consistency and even producing complete wireframes and UI layouts based on your specifications.
For example, imagine you want to design the main dashboard for BluffNote. You could prompt UX Pilot with something like:
“Design a home screen for an AI-powered meeting notes app called BluffNote. It should show a welcome message, a “New Meeting Note” button, a list of recent notes, and a shortcut to BS Mode. Use a clean, modern style.”
In seconds, the AI will generate a wireframe or even a high-fidelity mockup that meets those criteria.
Here’s a closer look.
Looks good, doesn’t it?
UX Pilot’s strength is speed and iteration. You can rapidly explore different layouts by tweaking the prompt. Want to see the same screen with a dark theme and a bottom navigation bar instead? Just ask the AI and you’ll get a new variant.
This ease of iteration means you can try multiple ideas before settling on the one that feels right – something that would be labor-intensive manually. It’s especially useful in early stages when you’re not entirely sure what the best UX approach is; the AI can give you concrete starting points to evaluate.
UX Pilot also ensures consistency by using common UI patterns. When prompted correctly, your generated screens will follow a coherent style, so you won’t end up with a jumble of mismatched designs.
For instance, let’s say from the PRD you know your app needs three main screens: a login/signup screen, a home dashboard, and a meeting note editor. You can have UX Pilot generate rough wireframes for each, guided by the PRD’s requirements.
Login/Signup screen: Input form for user login and sign up.
Home Dashboard: List of recent meeting notes, a “New Meeting Note” button, and a shortcut to BS Mode.
Meeting Note Editor: Input field for key topics, AI-generated meeting summary, action items, and a “Regenerate” button.
Here we’ve designed the Meeting Note Editor Screen using the following prompt:
Let's now create the Meeting Note Editor page. When a user clicks on an existing meeting note from the list of notes on the dashboard page, they will be brought to the Meeting Note Editor page. On the meeting note editor page the user will see the meeting note, an AI-generated meeting summary, action items, and also a 'Regenerate' button."
In a few minutes, you’ll have a first draft prototype of the entire app’s flow, ensuring a seamless AI-powered note-taking experience. The results might look like simple grey boxes and placeholder text (if wireframes), or more styled if you use its hi-fi design mode like we’ve done here.
Either way, you now have something tangible to look at and evaluate the user experience. Ask yourself the following questions - Does the navigation make sense? Is anything important missing on these screens that the PRD mentioned? It’s much easier to answer those questions when you have a visual prototype.
Of course, design is an iterative process and AI is just a helper. UX Pilot might not nail your perfect vision on the first try. Maybe the generated layout needs better spacing, or you want a different icon here or there. The tool allows you to edit the output or export it to Figma (a professional design tool) for further hands-on refinement.
Think of the AI-generated design as a first draft that you (or a human designer) can then polish. In some cases, the AI might propose an unconventional layout that doesn’t match what you had in mind – you’re free to discard those and guide it with more specific instructions.
Another consideration is user testing: while AI can create aesthetically pleasing designs, you’ll still want feedback from real users or team members to ensure the UX is genuinely intuitive and “lovable.” So be ready to adjust the design based on that feedback, just as you would in a normal design cycle.
Despite those caveats, the combination of AI and human touch can get you to a finalised UX/UI much faster than traditional methods.
By the end of this design phase, you should have a series of high fidelity designs outlining all the key screens of your product. This prototype embodies the “lovable” experience defined in your PRD – it’s what you’ll eventually put in users’ hands. And incredibly, you might reach this point just a day or two after having the initial idea, thanks to AI acceleration.
Now it’s time to actually build the app with working code behind those designs.
Phase 3: Building the Application with Lovable (or Bolt.new / WeWeb)
Designs in hand, you’re ready to start bringing your product to life.
Traditionally, this is where you’d hand off to software engineers to code the front-end interface, set up a back-end server, connect databases, etc. But our goal is to build an MLP in a week for under $100, so we’ll lean heavily on no-code/low-code tools and AI to construct the app quickly.
Several powerful tools emerged around 2024 that can generate full-stack applications from descriptions or visual inputs. In this phase, we’ll focus on Lovable, an AI-powered web app builder.
I’ll will also highlight some alternatives including Bolt.new if you want to build a mobile app, and also WeWeb if you want a more hand-on tool. (WeWeb in particular has been around for several years now and is a leader in the more traditional no-code app builder space.) More on these later.
For this tutorial we’re going to use a tool called Lovable. Lovable is an AI-driven app builder that acts as your coder. In simple terms, “Lovable is a text-to-app service that allows anyone to create functional applications without any programming skills”. Right now, they’re one of Europe’s fastest growing startups.
You describe your app in a chat interface, much like talking to ChatGPT, and Lovable generates the code for a working web application. Under the hood, it uses familiar tech - React + Vite for the front-end and Supabase for the backend services - but you don’t need to worry about that initially – it abstracts the code behind a conversational UI.
Lovable’s tagline is “Idea to app in seconds”, and while a full app might take a bit longer than seconds, it’s not far from the truth.
Create a new project in Lovable and start building your front-end
To get started, create a new project in Lovable. The interface will ask you essentially: ‘What do you want to build?’ This is where you enter the description of your app (you can copy the succinct summary from your PRD).
For example:
BluffNote is a collaborative, AI-powered note-taking app designed for professionals who want to sound smarter in meetings—without actually paying attention. It generates intelligent-sounding meeting notes, key takeaways, and action items from minimal input, ensuring users always appear engaged and proactive. With built-in AI summarisation, jargon enhancement, and a “BS Mode“ for automatic note generation, BluffNote makes any meeting seem productive—whether or not you actually were.
Once you submit the prompt, the AI goes to work. In a short time, Lovable will produce an initial app scaffold for you. This typically includes a few things: a suggested navigation structure, some dummy data or content, and styling/themes.
If asked, it can even provide a “project plan” or list of features it assumed for the first version. This is a great moment to review and make sure it aligned with your intentions.
Just to give you an example, here’s what Lovable created when left to it’s own devices (remember that we didn’t feed it any of our UX pilot designs yet).
Not that close to what we had in UX Pilot but it looks pretty good nonetheless.
My point here is that you can jump straight into designing in Lovable if you want, and skip the UX Pilot part, but I find that generating designs upfront actually saves time later down the line and it more closely mirrors professional product design workflows.
If you used UX Pilot for the design phase, you can actually screenshot your UX Pilot designs and paste them into your Lovable prompts. This allows the AI to reference those screens when generating your app, ensuring that the implementation aligns with your original vision and the PRD.
With a paid UX Pilot you can even copy the source code for your various screens and paste it into the Lovable chat. We’ll keep things simple for now though.
Iterate screen by screen
Typically it’s best practice to work on one screen at a time to avoid the AI getting overwhelmed and confused (just like a real person might).
Let’s start with redesigning the dashboard page to make it look more like our UX Pilot design. Attach the screenshot of th dashboard page and write a prompt for Lovable:
Recreate the dashboard screen as pictured in the attached screenshot for my AI meeting notes app. Pay careful attention to the fonts, colours and overall structure. This is the overall design language that we will use throughout our application.
And boom, we’re in business just like that.
Let’s build out the next screen.
Let's now create the Meeting Note Editor page. Use the attached screenshot for reference. When a user clicks on an existing meeting note from the list of notes on the dashboard page, they will be brought to the Meeting Note Editor page. On the meeting note editor page the user will see the meeting note, an AI-generated meeting summary, action items, and also a 'Regenerate' button.
Here Lovable did a decent job recreating the screenshot we gave it but there’s a problem. I don’t like this weird drop shadow appearing in the middle of the page.
Fixing an issue with the design in Lovable
Let’s screenshot the page and ask Lovable to fix it.
There's a problem with the design of this page. In the attached screenshot you can see there is this weird line in the centre of the page making it look like the page is cut in half. We don't want this. Tidy this design up please.
Of course, we say please here so that when the AI overlords come, they’ll remember we were nice to them…
I’m being intentionally vague in this prompt to show you that you don’t really need to speak the language of design to get Lovable to assist (although it can help to know some terminology as it allows you to be more specific when guiding Lovable.)
Lovable analyses the issue, comes up with an explanation why this might be happening and then proceeds with a code fix.
Page fixed! Thank you Lovable.
Next, I asked Lovable to give us the ability to create a new Meeting note, make existing meeting notes editable and to actually save new meeting notes so that they appear on our dashboard page once created.
I made all of these requests as separate prompts one-by-one to avoid overwhelming the AI. I strongly recommend that you take the same approach when working with any of these AI development tools.
Creating a new feature
I now want Lovable to implement our “BS Mode” feature. Let’s look back at our PRD to see what we’re aiming for here.
4️⃣ BS Mode Page
Purpose: Instantly generate random but believable meeting notes.
Features:
No input needed
AI auto-generates meeting notes, action items, and smart quotes
“Regenerate” button for alternative versions
I’ve gone back to UX Pilot to generate a design to give to Lovable as a reference. You don’t have to do this. You could just prompt lovable to create it, but Lovable is more likely to get this right in one go (“one-shot it”) if we do it this way. We reduce the risk of Lovable making unnecessary code changes which we may otherwise need to rollback.
Of course, if Lovable does make mistakes, it’s easy to revert these changes and go back to a previous version where things were working fine. So if things start to spin out of control for you, just rollback to an earlier stable version from the chat and try again.
Here is the prompt we’re going to give to UX Pilot.
Given I am on the dashboard page, when I press the BS Mode button, a modal loading screen will appear. The modal will contain the following - it will display a title saying "Warning, BS Mode Activated!". Beneath this there will be a loading bar, and beneath this loading bar we will see text saying "Achieving cross-functional alignment."
In the prompt box, I’ve also used UX Pilot’s “use existing screen as reference” feature, and selected our dashboard page". This way, the AI knows to build our new design as an extension of something that has already been created, rather than starting from scratch.
Here’s what it gave us:
Let’s screenshot this and share it with Lovable. We’ll just alter the prompt slightly so it references the screenshot. We’ll also feed it some more logic for how we want the loading state text to work.
“We are now going to work on the BS Mode feature. Given I am on the dashboard page, when I press the BS Mode button, a modal loading screen will appear for 5 seconds. The modal will contain the following:
1.It will displaying a title saying "Warning, BS Mode Activated!".
2.Beneath this there will be an animated loading bar that fills up as time passes,
3.Beneath this loading bar we will randomly cycle through a number of text options that I have copied below. Display one of these options every 1.5 seconds.
Use the attached screenshot for design reference.
Here are the randomly generated text options:
Maximising synergies
Achieving cross-functional alignment
Circling back
Hoping this email finds you well
Leveraging best practices
Gaining actionable insights
Doing a deep dive
Touching base
Moving the needle
Assessing bandwidth
Picking low-hanging fruit
Ensuring scalability
Avoiding boiling the ocean
Pivoting
Securing stakeholder buy-in
Operationalising
Focusing on core competencies
Running it up the flagpole
Providing value-add
Taking it offline
4.Given the time has elapsed, close the modal, and create a new completed note (use boilerplate text for now based off these key words, we will use AI to actually generate this later but not now.)
5.Finally, open the newly created note for the user.”
Here’s a video showing what it returned (along with a quick overview of some of the other functionality that we now have in place).
Not quite what we had in UX Pilot. The Modal appears on its own screen rather than as an overlay on the dashboard page, and some of the UI elements like the icon are different, but that’s fine for now. We can just ask Lovable to tweak the design later.
Continue to iterate on your app like this for a while and you’ll eventually arrive at a functioning front-end.
Test it out! Click through the screens in the Lovable editor preview. Ask yourself the following questions:
Have you implemented the prioritised features from your PRD?
Does the app roughly match your UX design from Phase 2?
Are the core interactions working (can you navigate from one page to the next)?
It’s really exciting to see your idea come to life at this point. So congratulations for getting this far! You’re quickly becoming an app builder!
Lights, camera, action…?
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.
Or 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, 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. 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.
In our PRD, to enable our app to raise millions in AI venture capital hype-money, we also 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, prompt one of the OpenAI models to generate a summary of our meeting note, and also extract 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 show this information to the user on the front-end.
(If that sounds confusing, don’t worry, I’ll explain all of this step-by-step later).
Essentially, we make our app real by adding a backend. We’ll cover all of this and more in Part 2 of the Atlas 2025 MVP Guide.
Part 2 is available to subscribers of the Atlas Woods Newsletter, so subscribe now using the button. I’ll also be sharing a video walkthrough version of this guide so if you’re interested, make sure you subscribe to get access.
Recap of Part 1 and what’s next in Part 2
Recap of Part 1
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 generate a fully functional front-end
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.
What’s Next? Part 2 – Making Your MVP Real
Part 1 was all about defining, designing, and constructing the front-end of your product.
In Part 2, we take it further by integrating a backend, authentication, and AI-powered features to make the MVP fully functional.
➡️ Power Up Your App with a Backend
Integrate Supabase for authentication, database, and storage.
Add user login (email/password) so people can sign up and log in.
Store and retrieve real meeting notes with AI-generated summaries and action items.
Lovable will handle all the heavy lifting, from database setup to UI integration.
➡️ Explore Alternative AI App Builders
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
One-click deployment with Lovable & Netlify – get your MVP live instantly!
Generate a public URL to share with users, investors, and testers.
See your idea go from concept to reality
But We’re Not Stopping There…
Once your app is functional, we’ll go even deeper into the low-code world to customise and enhance your MVP.
➡️ Phase 4: Taking Control with GitHub + AI Coding Assistants
Export your app’s code to GitHub—so you’re never locked into a no-code platform.
Let AI assist you in modifying the UI, adding new API integrations, and even writing new functions.
➡️ Phase 5: 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—perfect for startups.
Get your MVP production-ready with minimal effort.
We’ll also break 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?
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 even 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.
👉 Click here to read Part 2 now.
Check out what we have to offer at Atlas Woods below.
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. I 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 with this course. Join the waitlist now by clicking the link.