Fundraising: not a database problem, but a graph problem

Most founders approach fundraising like a search problem. Open PitchBook, filter by stage and sector, export a list of 200 investors, start emailing. Three months later, they’ve sent 600 follow-ups and landed 4 meetings.

The issue isn’t effort. It’s the model. Fundraising isn’t a search problem, it’s a graph problem. The right investor isn’t the one whose website says the right things. It’s the one whose last 20 deals match your profile, who is actively deploying right now, and who you can reach through someone who already has their trust.

That’s the bet Fundraisly is making. Built by founders who raised over $1B and an ex-investment analyst from a $600M+ AUM VC fund, it’s an AI agent that scans 300,000+ investors and millions of deals, then does the research, matching, and outreach for you. The result, they claim: 20–40 qualified investor meetings within 90 days.

Let’s look at how it actually works and what’s happening under the hood.

The four-step engine

Fundraisly’s matching pipeline has four distinct layers. Each one filters and enriches the candidate list before passing it to the next.

The Fundraisly pipeline overview

1. Hard Filter: First, cut the noise

300,000+ investors is an unusable list. Step one is a basic but critical triage: filter to only investors who actually match your hard constraints i.e. investment stage, geography, check size, and sector. This is the part every database tool does. It gets you from 300K down to a qualified pool of maybe a few hundred.

Think of it as an SQL query over a structured investor dataset:

-- Pruning 300K investors to a qualified candidate pool
SELECT investor_id, fund_name, partner_name, check_size
FROM   investors
WHERE  investment_stage IN ('seed', 'series_a')
  AND  geography IN ('US', 'India')
  AND  sector_tags @> ARRAY['fintech', 'b2b_saas']
  AND  min_check <= 1000000
  AND  max_check >= 500000
ORDER BY last_deal_date DESC;

This alone isn’t enough. Most investors keep their stated thesis vague or outdated. The next step is where Fundraisly starts to diverge from a regular database tool.

2. Behaviour Score: Ignore what investors say. Watch what they do.

A fund’s website might say “we invest in enterprise software.” Their last 20 deals might show 60% consumer fintech. That gap is called thesis drift and it’s common enough that pitching against a fund’s stated thesis is genuinely risky.

Fundraisly’s second layer runs automated analysis on completed deals only, not the fund’s description page. For each investor in the filtered pool, it builds a behavioral profile: what sectors did they actually back in their last fund cycle? What stage, check size, and business model patterns emerge from real portfolio data? How recently have they deployed capital in your specific sub-vertical?

What the behavioural scoring model looks like?

Under the hood, this is a supervised ranking model trained on historical deal data. Each investor in the pool gets a vector of behavioral features, and a learned scoring function ranks them by predicted fit to the founder’s company profile.

# Simplified behavioral scoring model
import numpy as np

def score_investor(investor_deals, founder_profile):
    """
    investor_deals: list of past portfolio companies with metadata
    founder_profile: dict with sector, stage, model, geography
    """
    features = {
        "sector_overlap": compute_sector_overlap(
            investor_deals, founder_profile["sector"]
        ),
        "recency_score": deals_in_last_18_months(
            investor_deals, founder_profile["sector"]
        ),
        "stage_match": stage_alignment(
            investor_deals, founder_profile["stage"]
        ),
        "check_size_fit": check_size_alignment(
            investor_deals, founder_profile["raise_amount"]
        ),
    }
    # Weighted dot product — weights learned from historical outcomes
    weights = np.array([0.35, 0.30, 0.20, 0.15])
    score   = np.dot(np.array(list(features.values())), weights)
    return round(score * 100, 1)

The key insight: recency is heavily weighted. A fund that was active in your space two fund cycles ago but hasn’t deployed there recently is ranked down. Only current deployment signals count.

3. Warm Path Map: The graph underneath your contacts

This is the most technically interesting step and the one that most tools skip entirely.

A perfectly scored investor you have to cold-email is worth significantly less than a moderately good fit you can reach through someone who already knows them. Warm introductions convert at 10–20x the rate of cold outreach. The challenge is that most founders don’t know their own network well enough to find these paths.

Fundraisly connects your Gmail, Outlook, and LinkedIn to build what is effectively a relationship graph, a network where you are a node, investors are nodes, and edges represent real connections weighted by communication frequency, recency, and responsiveness.

Relationship graph: Finding warm paths

# BFS-based warm path finder over a weighted relationship graph
from collections import deque

def find_warm_path(graph, founder_id, target_investor_id, max_hops=3):
    """
    graph: dict of {node_id: [(neighbor_id, edge_weight), ...]}
    Returns shortest warm path if one exists within max_hops
    """
    queue   = deque([[(founder_id, 1.0)]])  # (node, cumulative_weight)
    visited = {founder_id}

    while queue:
        path = queue.popleft()
        current_node, _ = path[-1]

        if current_node == target_investor_id:
            return path

        if len(path) >= max_hops:
            continue

        for neighbor, weight in graph.get(current_node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(path + [(neighbor, weight)])

    return None  # no warm path found -> falls back to cold outreach

Edge weights in this graph come from three sources: Gmail and Outlook metadata (how often do you email this person, do they reply, how recent?), and LinkedIn second-degree connections via a GDPR-certified third-party service. Fundraisly is CASA certified for its Google integration, meaning its data handling practices have been independently audited.

“A perfectly matched investor you can reach through two degrees of your network is worth 10x a cold contact with identical criteria on paper.”

4. Sequenced Outreach: The agent that does the asking

Once the ranked, warm-path-mapped investor list is ready, Fundraisly runs the actual outreach. For investors with a warm path, it drafts intro request messages. For the rest, it writes personalized cold emails; personalized against actual deal history, not just a name-swap template.

What separates this from a mass-email tool is the sequencing logic: messages are spaced, follow-ups are measured, and the sequence stops the moment a reply comes in. The target list is built for accuracy; investors who aren’t a genuine fit don’t make it onto the list in the first place, which is why the open rates Fundraisly reports (60–70%) run far higher than typical cold outreach averages (~27%).

# Sequencing logic - > simplified state machine
class OutreachSequence:
    STEPS = [
        {"day": 0,  "type": "intro_or_cold", "personalized": True},
        {"day": 5,  "type": "follow_up_1",   "personalized": True},
        {"day": 12, "type": "follow_up_2",   "personalized": False},
    ]

    def next_action(self, investor_id, current_day):
        status = self.get_status(investor_id)

        # Hard stop -> reply received at any point
        if status["replied"]:
            return {"action": "stop", "reason": "reply_received"}

        for step in self.STEPS:
            if current_day < status["start_day"] + step["day"]:
                continue
            if not status["sent"].get(step["type"]):
                return {"action": "send", "step": step}

        return {"action": "complete"}

What this adds up to

Taken together, the four steps form a pipeline that moves from a 300K+ raw universe to a personalized, warm-path-sorted shortlist of investors who are actually deploying capital in your space right now and then executes the outreach automatically.

The underlying architecture, a bipartite investor-founder graph with behavioral embeddings and shortest-path warm routing is the same class of system that recommendation engines at Netflix or Spotify are built on. The difference is that here, the stakes of a bad recommendation aren’t a forgettable movie. They’re months of a founder’s time.

If Fundraisly’s numbers hold at scale, the implication is significant: the network advantage that top-tier founders in major startup hubs have always had, knowing the right people, getting warm intros, reading which VCs are actually active right now, may finally be something you can run as an algorithm.