How to build a full outbound prospecting system with Lovable

Outbound prospecting automation is the process of using software to discover potential clients, qualify them, generate personalised outreach, and send follow-up emails, all with minimal manual effort. Instead of stitching together five or six SaaS tools, you can now build an entire prospecting engine yourself using vibe-coding platforms like Lovable, connected to APIs like Firecrawl, Hunter, and Gmail.

This article breaks down exactly how I built a working outbound system in under two weeks. One that has already discovered over 600 companies, sent 135 personalised emails, and scheduled 200+ follow-ups automatically.

How the system works: end-to-end workflow

The prospecting system follows a seven-stage pipeline. Each stage is visible in the UI, editable by a human, and powered by LLM reasoning behind the scenes.

Stage 1: Discovery run

Everything starts with a discovery run. You define the target industry (e.g. accounting firms), the country (e.g. the United Kingdom), and a batch size. The system then generates intelligent search queries, breaking them down by major cities within that country, so for the UK it will search Birmingham, Glasgow, London, Manchester, and so on.

These queries are sent to Firecrawl, which turns live websites into structured, LLM-ready data. The system filters out noise like job boards, software vendor pages, and recruitment sites, returning only actual company websites.

Stage 2: Human-in-the-loop approval

AI is not perfect, and the system is designed around that fact. After discovery, you get a list of proposed companies to review. Directory pages, “Top 10 accountants in Birmingham”-style articles, and other irrelevant results can be quickly removed.

This is a deliberate design choice. Rather than fully automating and hoping for the best, the UI makes it as fast as possible for a human to scan, approve, or reject each result. Building that intervention layer into the product from the start saves you from sending embarrassing outreach to the wrong targets.

Stage 3: Website analysis and buying signal detection

Once companies are approved, the system scrapes each website and evaluates it against predefined buying signals. These signals are fully configurable. In my case, I focused on:

• Outdated website design: template-based layouts, generic aesthetics, lack of mobile optimisation
• Active hiring signals: career sections indicating growth, which suggests budget availability
• Weak brand differentiation: stock imagery, neutral palettes, no clear visual identity

Each signal has its own detection prompt with specific evidence criteria. For example, the outdated website signal instructs the model to look for “layout patterns that feel template-based or generic” and to exclude sites that are “modern, fast, mobile-first, and app-like.”

The detected signals are stored per company and later fed into the email generation step to make every message specific.

Stage 4: Contact enrichment

Approved company domains are sent to Hunter.io, which returns verified email addresses along with contact names and roles. The system maps these contacts back to each company record so everything stays connected.

Stage 5: Personalised email generation

This is where the system earns its value. A reasoning model (in this case, OpenAI's API) takes in all of the following context to generate each email:

• The company's website content
• Detected buying signals with evidence
• The contact's name and role
• Your service offering and positioning
• Language-specific rules (e.g. formal address conventions for Spanish or German recipients)

The result is a personalised cold email that references something real about the prospect's website. Not a generic template, but an actual observation, like noting that the site leans heavily on stock imagery and a neutral palette, and suggesting how focused brand-led design and clear typographic hierarchy would better reflect the firm's expertise.

Stage 6: Review, edit, and send

Every generated email can be reviewed, manually edited, or regenerated before sending. You can change the subject line, tweak the body copy, or bulk-approve a batch once you are happy with the tone.

Emails are sent directly through Gmail, from your own email address, which means they land in real inboxes rather than going via a third-party sending service that might trigger spam filters.

Stage 7: Automated follow-up sequences

The system schedules multiple follow-up emails automatically. Each follow-up is spaced out (e.g. three days, then a week, then another week) and is smart enough to skip weekends. If a follow-up would land on a Saturday, it gets pushed to Monday.

The follow-up sequence is designed to escalate gently:

1. 01First follow-up: a short nudge referencing the original message
2. 02Second follow-up: adds a bit more detail or a slightly different angle on the value proposition
3. 03Final follow-up: a polite close-the-loop message that makes it easy for the recipient to say no

Each follow-up is generated with full context from the previous emails, keeping the thread coherent.

The tech stack behind it

The entire system runs on a lean stack, orchestrated through Lovable:

One of the most important architectural decisions was making every prompt editable directly from the UI. Instead of needing to go back into the codebase every time you want to tweak how emails are written or how signals are detected, there is a dedicated prompt settings panel where you can modify the instructions, see which variables are being injected, and test changes immediately.

Why build it yourself instead of buying SaaS

The typical outbound stack (a combination of tools like Apollo, Lemlist, Clay, Instantly, and a CRM) can easily cost hundreds of euros per month, and you are still locked into each tool's assumptions about how prospecting should work.

Building your own system is compelling for three reasons:

• Cost. The API calls for Firecrawl, Hunter, and OpenAI combined cost a fraction of what a SaaS stack would. For a solo operator or a small agency, the savings are significant.
• Control. You define the workflow. If you want to add a new buying signal, change the follow-up cadence, or adjust the tone of emails for a specific market, you just do it. No feature requests, no waiting for a vendor's roadmap.
• Learning. The process of building the system teaches you things about outbound that using pre-built tools never would. You understand exactly why certain emails perform better, because you wrote the prompts that generate them.

Lessons from building with Lovable

Building something real with a vibe-coding tool is not the same as building a demo. A few things became clear during the process.

Speed is genuinely remarkable. Going from idea to a working, deployed product in under two weeks is not an exaggeration. Lovable handles the UI, Supabase handles the backend, and you can focus entirely on the logic and workflow.

You have to impose structure. Lovable's default tendency is to pile new logic on top of existing logic. If you are not disciplined about refactoring, abstracting variables, and maintaining clean separation of concerns, the codebase becomes difficult to debug. At some point, you need to stop vibe-coding and start engineering.

Visibility is everything. The single most valuable decision I made was forcing the system to show me exactly what it was doing at every step: the prompts it was generating, the queries it was running, the data it was passing between stages. Without that transparency, debugging AI-driven workflows is nearly impossible.

Human-in-the-loop is non-negotiable. For any outbound system, you need a human reviewing output before it reaches prospects. The system is designed to make that review as fast and painless as possible, but it should never be skipped entirely.

Frequently asked

Questions about building an outbound system

Q.How long does it take to build a prospecting system with Lovable?

The core system (discovery, scraping, signal detection, email generation, and sending) took under two weeks to build. That includes the UI, database schema, prompt engineering, and API integrations. Ongoing refinement of prompts and edge cases is continuous, but the functional product was live very quickly.

Q.Can Lovable handle complex multi-step workflows?

Yes, but you need to be deliberate about architecture. Lovable is excellent at building the individual pieces (forms, API calls, database writes) and connecting them. Where it needs more guidance is in maintaining clean abstractions as the system grows. Treat it as a very fast collaborator that you need to direct, not a tool that will make architectural decisions for you.

Q.What does an outbound system like this cost to run?

The running cost is almost entirely API usage. Firecrawl, Hunter, and OpenAI charge per request, but for a prospecting volume of a few hundred companies and emails per month, the total is typically well under €50. Compare that to a SaaS stack that might cost €300 to €500 per month for equivalent functionality.

Q.How do you avoid emails sounding generic or AI-generated?

Three things help here. First, every email is grounded in real data from the prospect's website: detected signals, specific observations, actual content. Second, the prompts include deliberate instructions to vary tone, avoid clichés, and even introduce minor imperfections to sound human. Third, every email passes through a human review step before being sent.

Q.Is this approach only for web design agencies?

No. The system is built around configurable signals and prompts, so it can be adapted to any industry or offer. If you sell accounting software, you would define different buying signals (e.g. manual processes, outdated tools mentioned on the site) and adjust the email prompts accordingly. The architecture is the same regardless of the vertical.

Q.What are buying signals and why do they matter for outbound?

Buying signals are observable indicators that a company might be ready to purchase a specific product or service. In this system, they are detected automatically by analysing a prospect's website. For example, an outdated design suggests the company might be open to a website redesign. Grounding your outreach in real signals makes emails relevant rather than generic, which significantly improves response rates.