Browse docs
Updated September 15, 2026

Custom Contact Search

Custom Contact Search turns a dev-tool's product description into a repeatable process for finding developers who are technically close to the problem it solves. It builds product-specific search angles, matches them against public technical signals — GitHub activity, repositories, and other public developer context — and returns a short list where each candidate comes with the evidence behind the match and the specific reason they fit.

It is built for two related situations: GTM teams that need a repeatable way to find relevant developers and technical champions on an ongoing basis, and founders who need a first batch of people to talk to and get feedback from. The mechanism is the same in both — what changes is how the output gets used.

It is not a generic contact search built on job titles and company filters, and it is not a lead list built around a single GitHub event such as a star or a fork. It starts from what the product actually does and builds the criteria from there.

Two Ways To Use The Workflow

The same mechanism supports two different jobs, and it helps to be explicit about which one you are running:

ModeGoalTypical use
Founder-led discoveryFind early users and feedbackSmall shortlist, deeper manual review
Repeatable GTM researchBuild a consistent flow of relevant developers or technical championsReusable search angles, recurring searches, team review

For Repeatable Developer Lead Research

This is the main case for GTM and founder-led sales teams already running outbound. Apollo, Clay, and broad title filters return volume, but for a technical product the signal that predicts fit is rarely a job title — it is what someone actually works on, and that is not something a role or seniority filter can express.

Developer lead research scales when the reasoning is repeatable, not simply when the list becomes larger. In practice that means the product description turns into a fixed set of search angles, the same evidence-and-reasoning structure gets applied to every candidate, and weak matches get discarded before anyone looks up a contact. The angles themselves are reusable — a team refines them after a search and runs them again, instead of rebuilding the criteria from scratch each time.

That is the difference between a bigger list and a better process. See Custom Contact Search for the workflow itself.

For Finding First Users And Feedback

Founders use the same mechanism differently: fewer candidates, reviewed more closely, usually feeding a direct first conversation rather than a running pipeline. At this stage, one developer who is genuinely close to the problem — someone who can try an early version, push back on an assumption, or explain why the workflow does not fit — is often worth more than a long list of generic contacts.

First Users Search is the entry point built specifically for this case, for founders without a sales team yet.

Why Generic Filters Miss The Signal

Job titles, company filters, and technology tags describe a market. They do not describe a specific person's proximity to a problem. Two developers with the same title, Software Engineer, can work on completely different systems — one maintaining CI infrastructure across dozens of repositories, the other building application UI and never touching CI configuration. A title filter treats them as equivalent even though only one is close to the problem this dev-tool solves.

Single-event lists have the opposite gap. A star, a fork, or an issue comment is a real action, but on its own it does not say whether it reflects active evaluation, a bookmark that never gets reopened, or a favor for a colleague.

The 2025 Stack Overflow Developer Survey found that 48% of developers endorsed or influenced a technology purchase in the last year — developers are often part of the buying process, but that does not mean every developer is a buyer, or that one public action is commercial intent. A useful search needs technical evidence that a developer is close to the problem, and enough product context to explain why that evidence matters for this specific product.

From Product Description To Shortlist: A Worked Example

The walkthrough below is illustrative — a representative example of how the pieces connect, not a real candidate or customer record.

The product: a dev-tool that helps teams identify flaky CI tests. From that description, three search angles come out — concrete hypotheses about who is likely to run into this problem, not a generic persona like QA engineers:

  • Developers maintaining repositories with substantial automated test infrastructure
  • Contributors working across CI, test runners, and build tooling
  • Maintainers of projects where test reliability is operationally important

A candidate matched against those angles might show public repositories using GitHub Actions with visible integration-test workflows, recent commits touching CI configuration, and an open issue thread about intermittent test failures.

The product-specific reason: maintains public projects that rely on GitHub Actions and automated integration tests, and recently opened an issue about intermittent failures — a plausible signal of firsthand exposure to flaky-test overhead.

The uncertainty worth naming: the issue could describe a one-off infrastructure problem rather than a recurring flaky-test pattern. The reasoning is a hypothesis worth verifying, not a confirmed need.

A possible opener: "Saw your issue about intermittent CI failures — I'm building a tool focused on flaky test detection and your project looked like a relevant case. Worth a quick look?"

What happens with the result depends on the mode from the section above. A founder doing first-user outreach reviews this one candidate closely before reaching out. A GTM team running the repeatable version reviews a batch built from the same three angles, keeps the ones where the evidence holds up, and reuses the angles on the next search.

What Actually Scales

A fixed score based on event type is easy to scale but difficult to trust — if every fork is worth ten points and every contribution twenty, the system ranks activity without knowing whether it matters to this product. The same developer can be highly relevant to one dev-tool and irrelevant to another, even though their public profile has not changed.

What scales instead is the process: product positioning turns into a set of search criteria, those criteria produce several search angles, and the same angles get applied consistently across a batch of candidates. Weak matches get dropped before a contact is looked up. The angles get refined based on which ones actually produced good candidates, and reused on the next search rather than rebuilt each time.

  • Product fit between the search angle and the developer's visible work
  • Evidence quality, and recency where it is available
  • Uncertainty that stays visible instead of being collapsed into a score

This does not mean unlimited volume or automatic outreach — see the responsible-use section below. It means the same reasoning can be run again next week, on a different search angle, without starting over.

How This Differs From Other Tools

Apollo, Clay, and developer-signal platforms are not direct substitutes for Custom Contact Search — they solve adjacent problems, usually a step later in the process:

ToolStarting pointWhat it is for
ApolloCompany, role, or person already identifiedSearching and enriching contact records once the target is known
ClayAn existing list or workflowOrchestrating enrichment and activation across multiple data providers
Developer-signal platforms (Common Room, Reo.dev)Predefined events across community, product, and company sourcesConnecting developer and community activity into a broader GTM workflow
Custom Contact SearchA specific product, problem, and search hypothesisWorking out which developers are worth investigating in the first place, and why

Custom Contact Search sits earlier in the process. Its output — a reasoned shortlist — can feed into Apollo, Clay, or a CRM afterward; it is not trying to replace what those tools do once you already know who to contact. Common Room and Reo.dev sit closer to signal feeds — they connect predefined developer and community events into a broader GTM workflow rather than reasoning from a specific product description.

Responsible Use Of Public Technical Signals

Public does not mean unrestricted. GitHub's Acceptable Use Policies place real limits on using GitHub information for spam or the sale of personal information, and privacy and direct-marketing rules vary by jurisdiction and channel.

The default result is a short, evidence-backed shortlist — a public profile, supporting signals, and a reason, without an email address. Finding a possible contact method does not by itself make outreach appropriate — the applicable laws, platform rules, and opt-out expectations for that person still apply, and that responsibility stays with whoever sends the message.

A Practical Review Checklist

Before treating a candidate as relevant, ask:

  • Is the reason based on more than a title or one isolated event?
  • Can I inspect the public evidence behind the match?
  • Does the reasoning connect directly to my product's workflow?
  • Would I still consider this person relevant if no email were available?
  • Is the suggested opener grounded in what is actually public?

Morsa Field Note

We built this workflow after using the same process to find early users for our own developer tools. Finding profiles was never the hard part — GitHub search gets you a list fast. The hard part was making the search angles specific enough that a candidate's fit is obvious from the evidence alone, so weak matches get filtered out automatically instead of turning into noise you have to sort through.

FAQ

How do dev-tool companies find relevant developers for outreach?+
By starting from what the product does rather than a title or company filter — describing the technical problem it solves, deriving search angles from that description, and matching those angles against public developer context such as GitHub activity and repositories. That produces a shortlist grounded in evidence instead of a keyword match.
Can this workflow be used repeatedly by a GTM team?+
Yes. The search angles are reusable — a team runs a search, reviews which angles actually produced good candidates, refines them, and runs the same process again. It is built for recurring searches, not a one-time list.
How is this different from Apollo or Clay?+
Apollo helps search and enrich contact records once you already know the company, role, or person you want. Clay orchestrates enrichment and activation across data providers. Custom Contact Search works earlier — it turns a product description into search angles to work out which developers are worth investigating in the first place.
Is a GitHub star a buying signal?+
Not by itself. A star can mean active evaluation, casual interest, or a bookmark that never gets reopened. It becomes useful only when combined with other context relevant to the product and the search angle.
Does Custom Contact Search prove that someone has a problem?+
No. Public technical signals support a relevance hypothesis, not certainty about a private need or purchase intent. Every result should expose its evidence and leave room for human review before outreach.
Does the result include email addresses?+
Not by default. The default shortlist is a public profile, supporting signals, and a reason. Finding contact details for an individual candidate is a separate, explicit step for someone you have already decided is worth contacting.
How can a founder find the first users for a developer tool?+
Start from the technical problem the product solves, build a small number of search angles from it, and review a short list of candidates closely rather than collecting a large one. The First Users Search flow on this site is built for exactly this case.
Does the workflow search all of GitHub in real time?+
Yes — each search runs against GitHub in real time, built around the specific search angles from your product description. It's a targeted real-time search, not an unfiltered crawl of the entire platform, which is what keeps the shortlist relevant instead of turning into a firehose of loosely related activity.

Find Developers Worth Talking To