Building a real prospecting system with Lovable (and what actually happens when you do)

For a long time, the default way of automating business workflows was to stack SaaS tools on top of each other. One for scraping, one for enrichment, one for email, one for follow-ups, one for CRM. It works, but it is expensive, rigid, and you end up adapting your process to the tools instead of the other way around.

Over the last couple of weeks I wanted to test a different approach: build the whole thing myself using a vibe-coding tool, in this case Lovable.

The goal was simple: create a system that can discover companies, qualify them, generate personalised outreach, send emails, and schedule follow-ups, without relying on half a dozen separate products.

I recorded a video walkthrough of what I built, partly to show the result, but mostly to share what it is actually like to build something real with tools like this.

What I built in under two weeks

The system is a custom prospecting and outreach engine. It is not a demo or a toy project, it is something I am actively using.

In less than two weeks, it has:

• Discovered and qualified 600+ companies
• Sent 135 personalised emails
• Scheduled over 200 follow-ups automatically

All of this runs inside a single product with a simple UI, backed by:

• Firecrawl for turning websites into LLM-ready data
• Hunter for contact discovery
• Gmail for sending and tracking
• External LLM APIs for reasoning and copy
• Supabase for the database and edge functions

Everything is orchestrated through Lovable, including the UI, the prompts, and the logic.

How the workflow actually works

At a high level, the flow looks like this:

1. 01Discovery run. You define an industry, country, and a few filters. The system generates search queries, scrapes results, and proposes a list of companies.
2. 02Human-in-the-loop approval. You quickly review the list and remove rubbish (directories, job boards, aggregators).
3. 03Website analysis. For each approved company, the system scrapes the website and looks for buying signals like outdated design, poor mobile experience, or active hiring.
4. 04Contact enrichment. Domains are sent to Hunter to find relevant email addresses.
5. 05Email generation. A reasoning model generates personalised emails based on the company website, detected signals, the role of the contact, and your offer.
6. 06Review and send. You can edit everything manually, regenerate if needed, and then send in bulk.
7. 07Follow-ups. The system automatically schedules multiple follow-ups, skipping weekends and spacing them out.

The key part is that every step is visible. I forced the system to show me the actual prompts, inputs, and outputs at each stage, so I could understand what it was doing and tweak it properly.

What worked well

A few things genuinely surprised me in a good way.

Speed. It is extremely fast to get something real running. Not a mockup, not a prototype, but an actual working product.

Supabase integration. Supabase plus edge functions is a very strong combo. Auth, database, background jobs, all just work.

Iteration loop. The feedback loop is tight. You see something break, you change the prompt or logic, and you test again immediately. This makes it very good for exploratory products where you are still figuring out the workflow itself.

What did not work so well

This is the part that most hype posts skip.

1. 01It keeps adding instead of refactoring. By default, the system tends to pile logic on top of existing logic. If you are not disciplined, the codebase gets messy very quickly.
2. 02Hardcoding is the default instinct. You have to actively push it to use proper variables, configs, and abstractions. Otherwise, everything ends up baked into prompts and functions.
3. 03Debugging gets painful without structure. Without proper logs, naming conventions, and separation of concerns, it becomes hard to understand why something broke three layers deep.

At some point you have to stop vibe-coding and start doing real engineering, even if the tool makes it feel optional.

The real takeaway

Tools like Lovable are powerful, but they are not magic. They do not replace thinking. They do not replace product sense. They do not replace discipline.

What they do replace is a huge amount of boilerplate and friction. If you know what you want to build, and you are clear about the workflow, you can move ridiculously fast.

Try it yourself

If you are curious, you can play with the exact system shown in the video here: outreachdemo.odysi.studio.

It is far from perfect, but it is already saving me hours every week, and it costs essentially nothing compared to a typical SaaS stack.

That, for me, is the most interesting part. Not the AI. Not the prompts. But the fact that building your own internal tools is suddenly cheaper, faster, and more realistic than buying them.