122 days until WTSFest London 🇬🇧 Meet the speakers & explore the live agenda

Back to Knowledge Hub

From Prompt to Product: Lessons from Building 100+ Web Apps with Lovable

Author: Hawwah Okunmoyinbo

Last updated: 17/11/2026

Hawwah Okunmoyinbo joined us for a WTSTalk to share what she’s learned from building more than 100 web apps with Lovable, from choosing which ideas to pursue to prompting, testing, debugging and knowing when to stop adding features.

Watch the conversation below, then read Hawwah’s own article for a deeper look at the lessons, mistakes and product-thinking questions behind her builds.

What happens when a software engineer with too many ideas discovers AI app builders?

Apparently, over 100 web applications, a lot of experimentation, a few questionable decisions, and some lessons I wish I’d learned earlier!

These are the lessons I’ve learned building 100+ web apps with Lovable.

How I got started

First a confession: I have too many ideas!

Whenever I come across something that could be done better, experience a frustrating process, or notice a problem, my first thought is: could I build something to solve this?

Sometimes it’s a tool. Sometimes it’s an idea that gets so big in my head that I’m already imagining the dashboard, the features and what the finished product could look like before I’ve even started building it.

The funny thing is that I actually enjoy the building process. I’m a software engineer, so I’m familiar with the traditional development process: writing code, connecting APIs, working across the frontend and backend, debugging and trying to get everything working together.

Then I discovered AI-powered app builders, and let’s just say my already long list of ideas got even longer.

I started experimenting with different tools, including Lovable, and became fascinated by how quickly I could turn an idea into something I could actually interact with. Eventually, I built over 100 web applications with Lovable. Yes, over 100.

Before you imagine me sitting in front of my laptop launching 100 successful SaaS products, let me stop you there. Not every application was finished, not every idea was worth pursuing, and certainly not every first build was something I’d proudly show anyone.

Some were experiments. Some were prototypes. Some taught me what I needed to know precisely because they didn’t work.

And some made me realise that having AI build something for you is one thing. Knowing what to build, how to build it properly and when to stop making changes is another.

Here’s what happened when I went from simply experimenting with prompts to thinking more seriously about products.

My relationship with Lovable started with free credits

Let’s talk about something that doesn’t always make it into conversations about AI development: money!

When I first started experimenting with Lovable, I didn’t have an unlimited budget for building applications. I had ideas I wanted to explore, but I also had to think about how much I could afford to spend doing so.

And if you’ve ever used an AI app builder, you’ll know how quickly you can get carried away. You start with one idea. You generate something. You want to change the layout. Then you want to add another feature. Something doesn’t work, so you try again. Before you know it, you’ve used more credits than you expected.

I wanted to keep experimenting without constantly worrying about running out of credits.

At one point, I found myself creating multiple accounts so I could access more free credits and continue building. It wasn’t exactly the most sustainable development strategy!

But it says something about how curious I was and how much I wanted to keep exploring what was possible.

My relationship with Lovable has changed since then. I now pay for it because I’ve reached a point where I recognise the value it brings to my workflow. I know what I use it for, I understand how it fits into my building process, and I see it as something worth investing in. That shift taught me something beyond the platform itself: there is a difference between experimenting with a tool because it’s available and investing in a tool because it genuinely helps you achieve something.

It also taught me to be more intentional with my usage.

When you’re working with limited credits, you quickly become aware of how expensive vague instructions and unnecessary changes can be. You start thinking more carefully about what you want before asking the builder to do it.

Which brings me to my first lesson…

Lesson One: I stopped treating prompts like magic spells

When I first started building with AI, I was excited by how much I could get from a single instruction. You describe what you want, the builder generates an application, and suddenly you have something that looks like a real product.

It’s tempting to think that the secret is finding the perfect prompt.

But I learned that a prompt isn’t a magic spell. You can’t throw a few impressive words at an AI builder and expect it to understand every decision you’ve made in your head. The AI builder doesn’t know what you haven’t told it.

Imagine asking it:

“Build me a platform for investigating suspicious email messages.”

That sounds straightforward enough. But what does the platform actually need to do? What information should someone provide? What should happen after submission? What should the results look like? What happens when the information is incomplete? There are so many decisions hidden inside that one sentence.

And when you don’t make those decisions yourself, the AI has to make assumptions.

Sometimes those assumptions are useful. Other times, you end up with something that looks nothing like what you had in mind.

I quickly realised that I needed to spend more time thinking about the product before asking AI to build it.

Instead of immediately writing a prompt, I now find it useful to ask myself:

  • What problem am I actually trying to solve?
  • Who is going to use this?
  • What should they be able to do?
  • What does the first version genuinely need?
  • How will I know whether it works?

These questions might seem basic, but they change the quality of the instructions you give.

I also began to think of prompts as product specifications. The more clearly you communicate your requirements, the easier it becomes to evaluate what the builder produces.

The goal isn’t to write the longest prompt possible. It’s to give the builder enough context to understand what you’re trying to achieve.

Lesson Two: The first version is not the finished product

One thing I wish more people understood about AI app builders is that generating an application is not the same as finishing one.

You can have a beautiful homepage, an attractive dashboard, navigation, buttons, and forms. Everything looks fantastic. You might even feel tempted to show it to everyone.

But have you actually tested it?

Does the form submit correctly? Does the information go where it should? Does the main workflow work from beginning to end? What happens when someone enters something unexpected?

A button that looks clickable is not necessarily a button that works. And a dashboard full of impressive-looking information doesn’t automatically mean the underlying data is correct.

This is where having a software engineering background has been particularly useful to me. I’m naturally interested in what is happening behind the interface, not just what appears on the screen. I want to understand the logic, the data, the connections and how the different parts of the application work together.

But even with that background, I still have to test and refine what I build.

I’ve learned not to celebrate too early just because the first generation looks good. The real question is whether the application can actually do what I intended it to do.

Lesson Three: Sometimes, you have to admit that your build isn’t working

Let’s be honest: not every AI-generated tool or web app is going to turn out like you imagined.

Sometimes you think you’ve explained something clearly, but the builder interprets it in a way you didn’t anticipate. Sometimes you make a change but cause something else to break. Sometimes you keep adding instructions, only to realise that the application is moving further and further away from what you originally imagined.

It’s super-frustrating! But I’ve learned that being frustrated isn’t a particularly useful debugging strategy.

When something goes wrong, I try to be more specific.

  • What was I expecting?
  • What actually happened?
  • Can I reproduce the issue?
  • What exactly needs to change?

I’ve also learned that sometimes the best decision is to step back and rethink my overall approach rather than keep on trying to patch an application.

Not every app needs another feature. Not every disappointing result needs another prompt. Sometimes the original requirements need to be revisited.

This is especially important when an application has multiple workflows. A change that seems small in one place, can affect something big elsewhere.

I now pay much more attention to testing after making changes. If I think I’ve fixed something, I want to know whether the original problem is resolved and whether the rest of the experience still works.

The important thing is not to become so attached to the first version that you’re unwilling to change it.

Lesson Four: You can have too many features

This is something I have to constantly remind myself of because, as someone who enjoys building, I’m always thinking about what else I could add.

There’s always another feature I could introduce. Another workflow I could improve. Another integration I could explore. And because AI builders make experimentation so accessible, it becomes very easy to keep expanding an idea.

But more features don’t automatically make a better product.

In fact, adding too much too early can make it harder to understand what the application is actually doing, and where things are going wrong.

As a result, I’ve become much more invested in first identifying the smallest useful version of an idea: What is the main problem? What is the one journey that needs to work? What can wait until later?

For someone building an SEO tool, for example, it might be tempting to create a platform with keyword research, competitor analysis, content optimisation, reporting and ten other features.

But perhaps the original problem is much simpler: a particular research task that takes too long. Could you start by solving that one problem?

A tightly-focused first version gives you something concrete to test. You can learn from the experience before deciding what else the product needs.

And sometimes the best feature is the one you decide not to build yet.

Building Oryvane: the project that brought many of these lessons together

One of the projects that has made me think particularly deeply about product development as a process, or “product thinking” is Oryvane.

Oryvane is a trust and identity intelligence platform built around a problem I wanted to explore: how can people investigate information, suspicious claims and identities instead of simply accepting what they’re presented with?

The idea brings together two functions:

  • The first focuses on investigating suspicious information, such as messages, websites, claims, and opportunities
  • The second focuses on investigating identities using publicly accessible information

What makes this interesting to me is that it isn’t simply about creating a box where someone enters a question and receives an AI-generated answer.

Think about what happens when someone is investigating a suspicious job offer, for example. They might want to understand whether the opportunity is legitimate, examine the claims being made, and look at the information available about the organisation or person behind it.

The application needs to bring together information in a way that helps the user understand what they’re looking at.

And this is where “product thinking” becomes particularly important.

There is a difference between something supported by evidence and something an AI system has inferred. There is also a difference between information that could not be verified and information that has been proven false.

Those distinctions matter.

I couldn’t think only about what features I could build. I had to think about how the investigation should work, how findings should be presented and how users could understand the limitations of the results.

Oryvane has gone through various rounds of development and refinement, and I’ve used it myself when investigating suspicious messages. Friends have also tried it.

I’m not suggesting that it is perfect or that every possible question you could ask can be conclusively resolved. But it is a project that has allowed me to put many of the things I’ve learned into practice.

And perhaps most importantly, it has reminded me that a product should be built around the problem it is trying to solve.

You don’t have to be a developer to start thinking like one

One of the things I find exciting about AI builders is the opportunity they create for people who have ideas but don’t necessarily have a software engineering background.

And I think this is particularly interesting for people working in SEO and digital marketing.

Think about how many repetitive tasks happen in those roles. There are research processes, reporting workflows, content-related tasks, data collection and all sorts of small frustrations that people deal with every week.

What if you could prototype a tool to help with one of them?

You don’t necessarily need to begin by building a complete SaaS platform. You could start with a small internal tool or a simple workflow that makes one task easier.

But I would encourage you to approach it with a product mindset.

Don’t just ask, “What can AI build for me?”

Ask: “What problem do I understand well enough to solve?”

You already have knowledge of your industry, your clients and/or stakeholders, and the problems you encounter every day. That knowledge is invaluable when deciding what to build.

AI can help you experiment with a solution, but it doesn’t replace the understanding that comes from knowing the problem.

Do this BEFORE you open Lovable (or your AI app builder of choice)

If there’s one practical thing I’d like you to take away from my experience, it’s this: Spend more time thinking about, and defining your idea before you start building.

These are the five questions I ask myself before I start building anything:

  1. Why am I building this? What is the actual problem, and why does it need solving?
  2. Who is it for? Be specific about the person who will use it and what they’re trying to achieve.
  3. What should they be able to do? Describe the main user journey, from the first interaction to the intended outcome.
  4. What does version one need? Identify the essential functionality. Leave the nice-to-haves for later.
  5. How will I know it works? Decide what you need to test, and what a successful result looks like.

Make sure you’ve answered all five questions BEFORE writing your first prompt.

You don’t need a complicated planning process. You just need enough clarity to avoid asking AI to make every important decision for you.

Final thoughts: Build with purpose and intention

Looking back, building more than 100 web applications has taught me so much. It has taught me to think more carefully about the problems I’m trying to solve, to be more intentional with my instructions and to accept that the first version is rarely the final one.

I’ve gone from trying to stretch every free credit to paying for a tool because I know the value it brings to my work. I’ve experimented, made mistakes, rebuilt things and learned not to confuse a polished interface with a finished product.

I still have more ideas than I know what to do with, and I suspect that isn’t going to change anytime soon!

But now, before I get carried away imagining the next big application, I try to pause and ask myself a much more important question:

Am I building something because I can, or because someone actually needs it?

Whilst going from a prompt to a working tool or application is exciting; creating something that genuinely solves a problem and/or helps someone is the thing that I find most fulfilling.

122 days until 15 brilliant speakers take the Barbican stage

Spend the day learning from 15 brilliant speakers, with practical ideas, thoughtful conversations & plenty to take back to your work.

The full agenda is live, so you can explore the talks & find the sessions you're most excited about.

Promotional graphic for Women in Tech SEO Festival London featuring 17 speaker headshots. Text reads: “Women in Tech SEO Festival — March 19th 2027 — London.”