coding Archives - KevinAmayi

Photo by Eduardo Rosas on Pexels Build an App with Lovable AI: From Zero to Deployed By Kevin Amayi · May 7, 2026 · 10 min read Quick answer To build an app with Lovable AI: go to lovable.dev, describe your app in a prompt — screens, data, user actions — and Lovable generates a working React + Supabase application in under 90 seconds. Iterate through the chat interface to refine it, connect Supabase for real data persistence, and deploy with one click. The generated code is exportable to GitHub when you're ready to continue development in a code editor. Contents The App We're Building Writing an Effective Initial Prompt What the First Generation Gives You Connecting Supabase for Real Data Iterating to a Working App Start Simple. Extend When the Product Demands It. When NOT to Build with Lovable AI Conclusion Frequently Asked Questions A client's presentation was on Monday. By Friday noon, the spec was finalized: a deal tracker where the sales team could log pipeline opportunities with a status and estimated value. Nothing architecturally complex. But building it from scratch — authentication, database schema, React components, deployment — would mean a weekend I didn't have. The Lovable generation took ninety seconds. Getting it to something usable took about two hours of iteration. The client got a live demo link Friday afternoon and didn't ask how it was built. This post walks through how to build an app with Lovable AI using a real example — a task management application — with the specific prompts, decisions, and iteration steps that get a generated app from rough first draft to something you'd put in front of a user. The App We're Building The example project throughout this post is a task manager. It's a common enough pattern that most readers can evaluate whether the output is right, and complex enough to illustrate the features that matter. Target spec: Email and password authentication — sign up, sign in, sign out A sidebar showing the user's projects — they can create and delete projects A main panel showing tasks for the selected project Each task has a title, due date, priority (High / Medium / Low), and status (To Do / In Progress / Done) Users can add, edit, and delete tasks A filter bar to view tasks by status or priority Clean, minimal design — dark sidebar, light main area Why this example: A task manager covers the four things Lovable handles well — authentication, relational data (projects contain tasks), CRUD operations, and basic UI state (filter, selection). If you understand how to build this in Lovable, you can build most standard web apps the same way. The same pattern applies to CRMs, booking tools, inventory systems, client portals, and internal dashboards. The prompt structure and iteration approach transfer directly. Writing an Effective Initial Prompt Photo by Nemuel Sereti on Pexels The initial prompt is the most important input you make. The first generation creates the structure that all subsequent iteration builds on. Structural changes mid-project are harder than getting the structure right at the start. Describe three things: the screens, the data, and the user actions. Avoid describing the technology stack — Lovable makes those decisions. Here's the prompt used to generate the task manager for this post: Build a task management web app with the following features: Authentication: - Email and password sign-up and sign-in - Users only see their own data Layout: - A fixed sidebar on the left showing the user's projects - Users can create new projects (name only) and delete them - The main area shows tasks for the selected project Tasks: - Each task has: title, due date, priority (High / Medium / Low), and status (To Do / In Progress / Done) - Users can add, edit, and delete tasks - A filter bar above the task list to filter by status and priority Design: - Dark sidebar (#1a1a2e), white main area - Clean card design for tasks with priority shown as a colour badge - Fully responsive That's 130 words. It's specific about layout (fixed sidebar), data fields (title, due date, priority, status), user actions (create, edit, delete, filter), design details (dark sidebar colour), and access control (users see only their own data). Common prompt mistakes to avoid What to avoid Why it creates problems Describing the stack ("use Next.js, Prisma, PostgreSQL") Lovable generates React + Supabase regardless. Conflicting instructions produce inconsistent output. Vague layout ("a nice dashboard") Lovable's interpretation of "nice" may not match yours. Specify the structure. Too many features in one prompt Complex prompts produce apps that work partially. Start with the core, add features through iteration. Omitting auth requirements If you don't mention authentication, Lovable may not include it — and retrofitting auth later is tedious. Not specifying data relationships If the prompt doesn't make it clear that tasks belong to projects, Lovable may generate a flat structure. Submit the prompt. Lovable generates the app in 60–90 seconds. Don't iterate yet — review the full output first. What the First Generation Gives You The first generation will be mostly right and partially wrong. That's the correct expectation. Lovable produces a working structure with real logic, not a final product. After the task manager prompt above, the first generation typically produces: A working sign-in and sign-up flow — usually correct on the first pass The sidebar with a project list and a "New Project" input — layout is close, sometimes needs spacing adjustments A task list in the main area with status badges — usually renders the data fields correctly Add and delete buttons for tasks — functional, sometimes missing the edit flow Mock data populated in the UI — real database comes in the next step Review the preview pane systematically. Click through every interaction: sign in, create a project, add a task, switch between projects, apply a filter. Note what works and what doesn't before writing a single iteration prompt. The filter bar is the feature most likely to be incomplete after the first generation. It renders correctly but often filters against mock data in local state rather than applying the correct logic. That's expected — it's one of the first prompts you'll send in iteration. Do not regenerate the whole app because one feature is wrong. Target the specific issue with a specific prompt. Regenerating resets all your previous iteration, including the parts that worked. (Lovable's version history lets you revert to any previous state, but you'll still lose the work done since. Use it surgically.) Connecting Supabase for Real Data Photo by Firos nv on Pexels The first generation uses local state for its data. Tasks exist in memory — refreshing the page resets everything. To make the app actually useful, you connect Supabase for a real persistent database. Steps to enable Supabase Open the Supabase panel in the Lovable sidebar (the database icon) Click "Connect to Supabase" — this provisions a Supabase project on your behalf if you don't already have one connected Sign in to Supabase if prompted Once connected, send this iteration prompt: "Connect all data to Supabase. Tasks and projects should persist in the database. Authentication should use Supabase Auth. Users should only be able to read and write their own projects and tasks." Lovable generates the database migrations, updates the queries, and wires up the auth tokens After the Supabase connection, open the Supabase dashboard directly and inspect the generated schema. The task manager should produce two tables: projects (id, user_id, name, created_at) and tasks (id, project_id, title, due_date, priority, status, created_at). Verify that foreign keys are set correctly and that row-level security (RLS) policies exist on both tables. RLS matters: Without row-level security policies on your Supabase tables, any authenticated user can read any row. Lovable usually generates basic RLS policies, but confirm in the Supabase SQL editor that policies exist before treating the app as user-ready. This is the one check worth doing manually rather than trusting the generated output. Once Supabase is connected and the data persists, test the full flow: sign up, create a project, add tasks, refresh the page, verify the data is still there. If it is, the database layer is working. Iterating to a Working App With authentication and the database working, you refine the app through targeted prompts. Each prompt should change one thing. Multiple changes in one prompt make it harder to debug when something breaks. Example iteration prompts for the task manager 1. "Add an edit button to each task card that opens a modal to edit all fields. Save changes to Supabase on submit." 2. "Show the count of incomplete tasks next to each project name in the sidebar." 3. "When a task status is set to Done, apply a line-through style to the task title." 4. "The filter bar is only filtering the local array. Make it filter the Supabase query so completed tasks don't load when 'To Do' is selected." 5. "Add a confirmation dialog before deleting a project. Warn that all tasks in the project will also be deleted." 6. "The task cards are too narrow on screens under 768px. Make them full-width on mobile with slightly more padding." These are the prompts that turn a generated app into one you'd actually use. Each targets a specific behaviour, names the element, describes the expected change, and in some cases explains why (prompt 4 explains the root cause — local array vs Supabase query). Lovable is better at cosmetic and behavioural changes than at restructuring data models mid-project. If you need to add a column to a Supabase table, write the migration in the Supabase SQL editor and then tell Lovable what changed: "I added a `notes` column to the tasks table. Add a notes text field to the task add and edit forms." For deeper Lovable integration patterns, the guide to using Lovable AI covers iteration strategies including the version history and when to use the visual editor. Start Simple. Extend When the Product Demands It. "Most apps don't need a microservices architecture. Start with a monolith. You'll know when you need to split it — the pain will be impossible to ignore. Splitting it prematurely just distributes your problems across more services." The same logic applies before you even write the first Lovable prompt. Every codebase I've joined that was architected for scale before anyone had used the product spent the first three months solving infrastructure problems that no user had actually encountered yet. The architecture was impressive. The product was late. Lovable's generated stack — React frontend, Supabase backend — is a working monolith with auth and storage included. That's the right starting point for the majority of apps people want to build: MVPs, internal tools, client portals, prototypes. These don't need distributed infrastructure on day one. They need to exist so you can find out whether they're worth building at all. The Lovable-generated stack has real limits. When your app outgrows them — when Supabase's free tier fills up, when you need server-side rendering for SEO, when the data model becomes complex enough to need custom business logic — you'll know. The pain will be clear. That's when you export the code, open it in a proper editor, and extend it deliberately. If you're at the point of extending an exported Lovable project, the Windsurf AI code generation tutorial or the Cursor IDE course for developers covers what the next stage of development looks like inside a real code editor. When NOT to Build with Lovable AI Lovable's value is clear for the right project type. For others, starting there costs time rather than saving it. The app's core value is the algorithm, not the UI. Recommendation engines, search systems, financial calculators, machine learning pipelines — these require the logic layer to be right before anything else. Lovable generates UI and CRUD operations well. Custom algorithms need to be designed and implemented, not generated. Start in a code editor where you can write, test, and iterate on the logic before building the interface around it. Real-time features are a core requirement from day one. Chat applications, collaborative editing, live dashboards with sub-second updates — Supabase has real-time capabilities, but generating a reliable real-time architecture through a prompt-based interface is hit-or-miss. The generated subscription logic often needs significant manual correction. If real-time is the product, build it intentionally. You're building on top of an existing codebase. Lovable generates fresh projects. It doesn't integrate into an existing React application, refactor legacy code, or add a feature to a repo you already own. For existing codebases, an AI code editor is the right tool. The Windsurf vs Cursor comparison covers the options for that situation. The security model is complex. Basic RLS policies — users see only their own rows — generate reliably. Multi-tenant applications with complex access control (organisation-level permissions, role hierarchies, field-level security) require policies that Lovable may not generate correctly. Review every generated RLS policy against your actual requirements, not just against whether the app appears to work. You need to own and understand every line from the start. The generated code is readable, but it isn't written by someone who can explain the decisions. If the app will be maintained by a team for years, or if you need to demonstrate understanding of the codebase in a technical review, building it yourself is the right call. Lovable is fastest for shipping; building by hand is best for learning and long-term ownership. Conclusion The deal tracker that shipped Friday afternoon was built in two hours, not two days. The client used it in Monday's presentation. The sales team used it for six weeks before the company decided they wanted more features than Lovable could generate cleanly — at which point the code was exported to GitHub and development continued in a proper editor. That's the trajectory most Lovable projects follow when they work: fast start, real use, deliberate extension. Building an app with Lovable AI follows a consistent pattern once you've done it once. Write a specific initial prompt that covers screens, data, and user actions. Review the first generation systematically before iterating. Connect Supabase early. Target each iteration prompt at one specific change. Export when the generated approach stops being the fastest path forward. Key takeaways: Describe screens, data fields, and user actions — not the technology stack Review the full first generation before sending any iteration prompts Connect Supabase immediately and verify row-level security policies manually Send targeted prompts for one change at a time — multiple changes in one prompt are harder to debug Export to GitHub when the generated structure stops being faster than custom development Start simple; extend deliberately when the product actually demands it One thing worth noting: Lovable will generate authentication that looks correct and occasionally has a subtle edge case in the session handling. Test sign-out and sign-in from a private window before sharing any demo link. It takes three minutes and saves an embarrassing demo moment. Back to top Frequently Asked Questions How long does it take to build an app with Lovable AI? The initial generation takes 60–90 seconds. Getting to a usable first version through iteration typically takes one to two hours for a medium-complexity app. A full MVP with authentication, a live database, and core features can be ready to demo in a single focused session — assuming your prompts are specific and you're iterating on one change at a time. What kind of apps can you build with Lovable AI? Lovable handles CRUD applications well: task managers, dashboards, CRMs, booking tools, client portals, and internal tools. These follow standard patterns that Lovable generates reliably. Apps with complex business logic, real-time requirements, advanced algorithms, or specialized domain rules need significant engineering beyond what Lovable generates out of the box. Do I need to know how to code to build with Lovable AI? You can get a working app without writing code. Understanding React and Supabase at a basic level improves both your iteration prompts and your ability to identify when something is wrong. Lovable handles the coding; your job is describing the product accurately and evaluating whether the generated output does what you asked. How specific should my Lovable AI prompt be? Specific enough to describe the screens, the data fields, and the user actions. "Build a task manager" produces a generic result. "Build a task manager with a sidebar for projects, tasks with due dates and priority levels, a filter bar, and email authentication — users see only their own data" produces something close to useful. The more specific the description, the less iteration you need afterward. Can Lovable AI connect to Supabase? Yes — Supabase integration is built in. Open the Supabase panel in the sidebar, connect your account, and prompt Lovable to migrate the app to use real database persistence. Lovable generates the schema migrations, updates the queries, and wires up Supabase Auth. You should still verify the generated row-level security policies in the Supabase dashboard before treating the app as ready for real users. Can I add Lovable AI apps to a custom domain? Yes. Custom domains are available on paid Lovable plans. Connect your domain in the project settings. Alternatively, export the code to GitHub and deploy it yourself on Vercel or Netlify — both support custom domains on their free tiers, which gives you more control over the hosting configuration. What happens to my Lovable AI app code? The code is yours. Lovable lets you export the full project to a GitHub repository at any time. The export is a standard React project with no Lovable-specific dependencies — open it in Cursor, Windsurf, or any editor and continue building. There's no lock-in to the Lovable platform once you have the code. Kevin Amayi Full stack developer with 5+ years building TypeScript, Next.js, and Node.js applications. Writes about AI coding tools, developer productivity, and the practical gaps between what tools promise and what they actually deliver. More from Kevin

Tag: coding

Build an App with Lovable AI: From Zero to Deployed

Windsurf vs Cursor Comparison

Windsurf AI Code Generation Tutorial: A Practical Guide

How to Use Cursor AI for Coding (2026 Guide)

Quick Links

Resources

Support