This week, we're getting a bit nerdy.

For the last three weeks, I've mostly written about fear, comfort and the occasional identity crisis.

This week, I thought I'd show you the other side of Life of Jake.

The actual backend of trying to build something.

If you have an online business idea, especially a service, this is a very gritty but effective way to test whether there is a market for it.

No massive budget.

No crazy tech stack.

Just a specific audience, a clear offer, a scraped lead list, some enriched emails and a small outreach campaign.

Clickrabbit needs its first pilot clients.

So today, I'm going to show you exactly how I'm trying to find them.

From choosing who to contact, to sourcing the leads, finding their emails and showing the exact outreach emails I'm using.

It could land me my first clients.

It could also get completely ignored.

We'll find out.

STEP 1: PICK THE RIGHT MARKET

Before finding leads, I needed to decide what a good Clickrabbit client actually looked like.

My criteria was fairly simple.

They needed to sell a high-value service through booked calls.

Have a sales cycle under roughly 60 days.

Be able to invest a few thousand pounds into acquisition.

Already have proof people want their service.

And have someone capable of closing the leads once they came in.

After testing a few industries, I decided to focus the first Clickrabbit pilot campaign entirely on outsourced finance and advisory firms.

Accountants.

Fractional CFOs.

Finance consultancies.

It's a pretty scary niche because it is very professional, but the potential is strong.

And to be honest, I find finance quite interesting.

So that was the decision.

One market.

One offer.

One proper test.

STEP 2: BUILD THE SALES NAVIGATOR LIST

For sourcing, I used LinkedIn Sales Navigator.

Sales Navigator lets you filter LinkedIn's company and lead database by things like industry, location, company size and job title.

The best part is I found a LinkedIn referral link on Reddit that gave me two months for free.

So step one was doing an account search.

Using the Clickrabbit ideal client profile, I filtered for finance firms that broadly matched the type of business I wanted to work with and added them to a list.

That gave me around 550 companies based in the UK.

The next problem was getting them out of Sales Navigator and into something I could actually work with.

I used the script below in the browser console.

1const accounts = [...document.querySelectorAll('a[href*="/sales/company/"]')]
2  .map(a => ({
3    company: a.innerText.trim(),
4    url: a.href.split("?")[0]
5  }))
6  .filter(x => x.company)
7  .filter((x, i, arr) => arr.findIndex(y => y.url === x.url) === i);
8 
9console.table(accounts);
10copy(accounts.map(x => `${x.company}\t${x.url}`).join("\n"));

It scans the companies currently loaded on the page, extracts the company name and Sales Navigator URL, removes duplicates and copies the results to your clipboard.

I then pasted each page into a spreadsheet.

Simple.

STEP 3: CUT THE BAD FITS

A LinkedIn filter can get you close to your ideal client.

It cannot tell you whether a company actually makes sense for your offer.

So the next stage was research.

I took the account list and used GPT-5.5 to analyse each company against my ICP.

Any high-reasoning model should work.

What does the company sell?

Who do they sell to?

Does their service appear valuable enough?

Would a booked-call acquisition system actually make sense for them?

Anything that clearly did not fit was removed.

The goal was not to build the biggest list possible. It was to build a list worth contacting.

Once the account list was cleaned, I went back into Sales Navigator.

This time, I searched for people within those companies.

Founders.

Owners.

Managing directors.

CEOs.

The people most likely to make a decision on testing a new client acquisition system.

I filtered that list again and removed poor-fit roles and leads.

The result was 389 finance decision-makers.

STEP 4: SCRAPE THE LEADS

I then used a second browser console script to extract the lead data.

1const clean = (text = "") =>
2  text.replace(/\s+/g, " ").trim();
3 
4function cleanName(name = "") {
5  return clean(name)
6    .replace(/\s+was last active.*$/i, "")
7    .replace(/^select\s+/i, "")
8    .trim();
9}
10 
11function findLeadCard(nameEl) {
12  let node = nameEl;
13 
14  for (let i = 0; i < 20 && node; i++) {
15    node = node.parentElement;
16 
17    if (!node) break;
18 
19    const jobTitle = node.querySelector(
20      '[data-anonymize="job-title"]'
21    );
22 
23    const company = node.querySelector(
24      '[data-anonymize="company-name"]'
25    );
26 
27    const addAccount = [
28      ...node.querySelectorAll(
29        ".list-detail-account-matching__text"
30      )
31    ].find(
32      el => clean(el.textContent) === "Add Account"
33    );
34 
35    const leadLink = node.querySelector(
36      'a[href*="/sales/lead/"]'
37    );
38 
39    if (
40      jobTitle &&
41      leadLink &&
42      (company || addAccount)
43    ) {
44      return node;
45    }
46  }
47 
48  return null;
49}
50 
51function cleanSalesNavUrl(url = "") {
52  const match = url.match(
53    /https:\/\/www\.linkedin\.com\/sales\/lead\/[^,?]+/
54  );
55 
56  return match ? match[0] : url.split("?")[0];
57}
58 
59const leads = [
60  ...document.querySelectorAll(
61    '[data-anonymize="person-name"]'
62  )
63]
64  .map(nameEl => {
65    const name = cleanName(nameEl.textContent);
66    const card = findLeadCard(nameEl);
67 
68    const titleEl = card?.querySelector(
69      '[data-anonymize="job-title"]'
70    );
71 
72    const companyEl = card?.querySelector(
73      '[data-anonymize="company-name"]'
74    );
75 
76    const addAccountEl = card
77      ? [
78          ...card.querySelectorAll(
79            ".list-detail-account-matching__text"
80          )
81        ].find(
82          el => clean(el.textContent) === "Add Account"
83        )
84      : null;
85 
86    const leadLink = card?.querySelector(
87      'a[href*="/sales/lead/"]'
88    );
89 
90    let company = clean(
91      companyEl?.textContent || ""
92    );
93 
94    if (!company && addAccountEl) {
95      company = "No Company";
96    }
97 
98    return {
99      name,
100      title: clean(titleEl?.textContent || ""),
101      company,
102      linkedin_profile: cleanSalesNavUrl(
103        leadLink?.href || ""
104      )
105    };
106  })
107  .filter(lead => lead.name)
108  .filter(
109    (lead, index, array) =>
110      array.findIndex(
111        other =>
112          other.name === lead.name &&
113          other.linkedin_profile ===
114            lead.linkedin_profile
115      ) === index
116  );
117 
118console.table(leads);
119 
120const output = leads
121  .map(
122    lead =>
123      `${lead.name}\t${lead.title}\t${lead.company}\t${lead.linkedin_profile}`
124  )
125  .join("\n");
126 
127copy(output);
128 
129console.log(
130  `✅ Copied ${leads.length} leads to clipboard`
131);

This pulls four fields from each loaded lead:

Name.

Job title.

Company.

Sales Navigator profile URL.

The data is formatted so it can be pasted directly into a spreadsheet.

After working through the list, I had a CSV containing 389 people I actually wanted to contact.

There was just one fairly important thing missing.

Their emails.

STEP 5: ENRICH THE EMAILS WITH CLAY

This is where I originally planned to build an n8n workflow.

I spent a while looking at different data providers and trying to work out how I could enrich the CSV myself.

Small issue.

Most of the providers I found wanted a monthly subscription, then credits on top.

My first solution was obviously to make multiple free trial accounts and rotate the API keys in n8n.

I got IP blocked.

Fair enough.

Then I remembered Clay.com exists.

As of writing this, you get 2,000 credits when you sign up for the 14-day trial.

I uploaded the CSV I extracted from Sales Navigator and used Clay to find two things.

The person's actual LinkedIn profile and their work email.

Clay is honestly crazy and has so many different features.

So I'll keep the guide simple.

Upload the CSV, connect the Find LinkedIn Profile and Find Work Email enrichment waterfalls, then export.

One annoying limitation with the trial is that you can only enrich and download 50 rows at a time.

So my process was:

50 leads.

Enrich.

Download.

Delete them.

Next 50.

Repeat.

End result was 204 usable leads.

WHY THE LIST GETS SMALLER

I know what you're thinking.

Jake, you started with 550 companies.

How are you down to 204 people?

That's perfectly normal.

As you research, filter and enrich the data, the list gets smaller and the leads get more qualified.

That's the point.

You also don't need some crazy, complex AI personalisation agent researching the founder's childhood before every email.

As long as you understand the sector, understand the problem and write something relevant, you're fine.

People are always going to know cold outreach is cold outreach.

Your only focus should be whether that outreach actually resonates with them.

THE COLD EMAIL TEST

I then wrote three emails for the campaign.

I'm testing three slightly different angles.

The first is around making new business more predictable.

The second asks whether they could even handle 10 good conversations if they landed next month.

The third questions where their next 10 good client conversations are actually coming from.

I'm not going to pretend I know which one will work.

I've been properly looking at this sector for about a week.

If one angle performs well, I'll probably double down on it.

If they all perform badly, I'll find three new angles.

That's the test.

CAMPAIGN LIVE

For sending everything, I'm using Lemlist.

It's the only thing I've actually paid for throughout this entire process.

I'm using the lowest plan because, for what I'm doing, I don't really need anything else.

Cue the fireworks...

The campaign is now live.

204 leads, three different angles and three pilot clients needed.

Let's see what happens.

But that's enough business talk for one week.

I now need to pack my suitcase.

I'm graduating next week.