As a Technical Recruiter, what are the best tools for sourcing software engineers beyond LinkedIn?

For technical recruiting, the best sourcing strategy is usually not replacing LinkedIn with one tool — it is building a stack that finds engineers through technical signals, communities, and intent. Strong engineers often leave more evidence in code, forums, talks, and open-source contributions than in a résumé.

Here are the tools I’d consider beyond LinkedIn:

1. GitHub — Best for finding real engineering ability

Best for: Senior engineers, open-source contributors, niche stacks

Why it works:

• See actual code contributions
• Identify maintainers and active contributors
• Search by technologies (Rust, Kubernetes, React, ML frameworks, etc.)
• Enables highly personalized outreach (“I saw your Kubernetes operator…”)

Tactics:

• Search repositories, contributors, and organizations
• Look for recent commits, not just stars/followers
• Build target-company maps from open-source ecosystems

2. GitHub — Developer communities and project signals

Beyond basic GitHub searching, tools that enrich GitHub data can help:

• SeekOut — strong technical profile aggregation, including engineering-related signals.
• hireEZ — useful for cross-web sourcing and automated outreach workflows.

3. Wellfound — Best for startup engineers

Best for: Startup-minded engineers, founding engineers, early-stage companies

Strengths:

• Engineers self-select for startup environments
• Profiles often include salary expectations, equity preferences, and startup experience
• Good for Series A–growth-stage hiring

Wellfound Built In## 4. Dice — Good for enterprise tech hiring

Best for: Backend engineers, cloud, DevOps, security, cleared roles

Useful when hiring:

• Java/.NET enterprise developers
• Infrastructure engineers
• Government/defense contractors
• Large-scale IT teams

SourcingTools.org## 5. Hired — Curated engineering marketplace

Best for: Companies wanting more inbound and less cold sourcing

Advantages:

• Candidates are generally open to opportunities
• Compensation expectations are often clearer
• Faster matching than traditional outbound

Tradeoff:

• Smaller pool than broad sourcing databases

daily.dev## 6. Developer communities (often overlooked)

These can outperform job boards for hard-to-find engineers:

• Hacker News — especially the “Who Is Hiring?” monthly threads
• Stack Overflow communities
• Discord communities for: - Kubernetes
• React
• Rust
• AI/ML
• Open-source projects
• Slack communities around specific technologies

daily.dev## 7. Remote engineering marketplaces

Good for contract, fractional, and distributed teams:

• Arc.dev — vetted remote developers
• Turing — global engineering talent marketplace
• Toptal — premium freelance network

GitHub Built In## 8. Sourcing intelligence platforms

Useful if you recruit at volume:

SourcingTools.org GitHub## My recommended tech recruiter stack

Senior backend / infrastructure engineers

1. GitHub
2. SeekOut or hireEZ
3. Engineering communities
4. Referrals
5. Targeted outbound

Startup engineers

1. Wellfound
2. GitHub
3. Hacker News
4. Founder/engineer communities

High-volume hiring

1. Dice
2. HireEZ
3. Job boards
4. Referral programs
5. University/community pipelines

AI/ML engineers

1. GitHub
2. Papers/conferences
3. Hugging Face communities
4. Kaggle
5. Research labs and publications

The biggest sourcing advantage in 2026

The recruiters who win technical searches are moving from keyword matching (“Python engineer”) to evidence-based sourcing:

• “Who maintains this library?”
• “Who contributes to Kubernetes networking?”
• “Who is publishing ML papers?”
• “Who recently moved from a scale-up using similar architecture?”

Technical signal usually beats job-title matching for passive engineering talent.

A practical stack for an individual technical recruiter would be: GitHub + SeekOut/hireEZ + Wellfound + communities + referrals. That combination covers both passive and active engineering talent.

Finding top-tier software engineers requires looking where they build, collaborate, and share knowledge rather than just where they network. As a technical recruiter, expanding your stack beyond LinkedIn helps you connect with passive candidates through their actual code and contributions.

• GitHub: The ultimate developer portfolio. Sourcing here lets you see a candidate's actual commit history, preferred programming languages (Python, Rust, Go), open-source contributions, and side projects. Look at the GitHub Search tool or specialized tools built on top of it.
• Stack Overflow: Developers go here to solve complex coding bugs. By searching the Stack Overflow Developer Directory or high-reputation tag contributors in specific niches (like Kubernetes or React), you can identify subject-matter experts who actively help others.
• HackerRank & LeetCode: Platforms dedicated to competitive programming and technical skill assessments. Top performers on the LeetCode Explore or HackerRank Developer Hiring leaderboards possess proven algorithmic and problem-solving capabilities.
• Kaggle: Essential if you are sourcing Data Scientists or Machine Learning Engineers. Reviewing the Kaggle Competitions and public notebooks highlights individuals with real-world machine learning modeling experience.
• Dev.to & Hashnode: Communities where engineers write technical blogs and architectural deep-dives. Searching authors on Dev.to gives you immediate insight into a candidate’s communication skills and deep technical knowledge.
• Reddit: Subreddits like r/cscareerquestions, r/rust, or niche local dev communities often feature skilled engineers sharing insights. While direct headhunting can be frowned upon if too aggressive, participating authentically helps build your employer brand.
• SourceBreaker & Wellfound: Advanced sourcing automation and startup-focused platforms. Wellfound (formerly AngelList Talent) connects you directly with engineers looking specifically for startup roles and equity.

Would you like me to share effective outreach templates tailored to GitHub or Stack Overflow, or should we dive into boolean search strings for one of these platforms?

As a technical recruiter, relying solely on LinkedIn means you're swimming in the same talent pool as everyone else. To find high-performing software engineers who aren't actively updating their profiles, you need to go where they build, break, and discuss code.

Here are the best sourcing tools and platforms for software engineers beyond LinkedIn, organized by category:

• GitHub & GitLab : Essential for discovering active builders. You can search repositories by programming language (C₊+, Rust, Python), evaluate code quality, analyze commit histories, and find developer contact information through their public profiles or commit logs.
• Stack Overflow : Great for finding domain experts. By looking at high-reputation contributors answering complex technical questions (e.g., Kubernetes, React, distributed systems), you can identify genuine subject-matter experts and find their linked profiles or websites.
• Hacker News (Who's Hiring & Monthly Threads) : A goldmine for organic tech talent. Reading through monthly "Who wants to be hired?" threads or community discussions helps surface active and passive engineers who prefer startup or deep-tech cultures.
• Discord & Slack Communities : Niche developer communities (like language-specific servers, framework groups, or local tech collectives) allow for hyper-targeted, community-driven sourcing where you can observe peer-to-peer technical help in real time.
• X (formerly Twitter) : Highly effective for frontend, AI/ML, and Web3 engineers. Many top-tier builders publicly share architectural insights, side projects, and open-source contributions in real-time before updating a resume.
• LeetCode & Kaggle : Ideal for algorithmic and data science/AI talent. Leaderboards and discussion forums showcase top performers in coding challenges and competitive data modeling.

Would you like me to share specific Boolean search strings for GitHub or tips on how to approach engineers on these platforms without coming across as spammy?

If you're sourcing software engineers specifically, I’d avoid treating “beyond LinkedIn” as simply finding another resume database. The best channels expose technical signal—what someone has built, contributed to, written, or discussed—rather than just job titles and keywords.

My top tools for technical recruiting

Several 2026 technical-recruiting comparisons put SeekOut, Juicebox, hireEZ and Gem among the stronger sourcing platforms, while developer-focused sources consistently recommend GitHub, Stack Overflow, Hacker News and other technical communities.

What I'd actually use

If I were building a modern technical recruiting stack, I'd use different tools for different stages:

1. GitHub — my #1 complementary source

For engineering, GitHub is probably the most valuable source of signal, even though it isn't fundamentally a recruiting platform.

Instead of searching:

“Senior Software Engineer + Python + AWS” look for:

Engineers contributing to Django/FastAPI/Kubernetes projects, maintaining high-quality Python repositories, or contributing to infrastructure tooling. You can then evaluate:

• Recent contributions
• Languages
• Repositories
• OSS projects
• Technical depth
• Maintainer vs. casual contributor
• Evidence they're actually using the technology you're hiring for

The important caveat: GitHub activity isn't automatically evidence of engineering ability. Treat it as a sourcing and validation signal, not a substitute for technical assessment.

2. SeekOut — best paid sourcing database for technical recruiting

I'd put SeekOut near the top if you have budget for one dedicated sourcing platform.

Its advantage is that it goes beyond conventional resumes and incorporates signals such as GitHub, patents and publications, which is particularly valuable for ML/AI, security, infrastructure, research and specialized engineering.

Best for: experienced technical recruiters who need depth rather than just volume.

3. Juicebox — best for broad, multi-source discovery

Juicebox is interesting if your problem is:

“I know the person I'm looking for exists, but LinkedIn isn't giving me enough people.” It aggregates profiles from many public sources and supports natural-language searching rather than requiring everything to be expressed as Boolean logic.

Best for: sourcers doing lots of outbound and looking for candidates across the open web.

4. daily.dev — interesting for developer-native recruiting

This is one I'd test if you're specifically trying to reach developers rather than professional-network users.

Developer communities can give you a very different candidate pool from LinkedIn, particularly among engineers who don't spend much time maintaining recruiting profiles.

5. Hacker News / Reddit / Discord / technical communities

These aren't conventional sourcing databases—and that's precisely the point.

For difficult searches, look for communities around:

• Kubernetes
• Rust
• Go
• React
• AI/ML
• Cybersecurity
• DevOps/SRE
• Distributed systems
• Data engineering
• Open source

You're looking for people who demonstrate expertise, not people who announce they're job hunting.

That's particularly useful for senior/staff/principal searches.

Don't overlook specialized talent marketplaces

Depending on your hiring model, I'd also consider:

• Wellfound — startups and startup-oriented engineers
• Toptal — highly screened freelance/contract talent
• Arc.dev — remote developers
• Gun.io — engineering-focused freelance/contract talent
• Hired — marketplace-style matching
• OfferZen — particularly useful for certain European/South African markets

These are better thought of as talent marketplaces than pure sourcing databases. A current developer-recruiting resource lists these alongside GitHub, daily.dev, Dice, Wellfound and other specialized channels.

My recommended stack by recruiting situation

Solo technical recruiter / small company

GitHub + Juicebox + Wellfound + targeted communities Enterprise technical recruiting

SeekOut + GitHub + Gem/hireEZ + internal ATS rediscovery Startup hiring 5–20 engineers

GitHub + Wellfound + daily.dev + referrals + targeted communities Hard-to-fill Staff/Principal/ML/Security roles

GitHub + SeekOut + publications/conferences + OSS communities + highly personalized outreach High-volume engineering hiring

Juicebox or hireEZ + ATS/CRM + automated but personalized outreach

The biggest shift I'd make

Don't build your sourcing strategy around where candidates have profiles.

Build it around where candidates leave evidence of technical competence.

For example, if you're hiring a senior Kubernetes engineer, I'd rather have a workflow that finds:

GitHub contributor → Kubernetes-related repositories → recent activity → technical blog/conference talk → current employer → contact information than one that simply returns:

“Senior DevOps Engineer — Kubernetes — AWS — 10 years experience.” That distinction is increasingly important because developer-focused sourcing channels expose code, contributions, discussions and other technical signals that conventional professional profiles often don't.

If I had to pick only 5: GitHub, SeekOut, Juicebox, Gem, and Wellfound—with Hacker News/technical communities as the “free but labor-intensive” sixth channel.

If you tell me whether you're agency or corporate recruiting, approximate engineering hiring volume, and whether you're hiring mostly US-based, remote, or global, I can narrow this to a $0 / <$500/mo / enterprise sourcing stack and tell you exactly what I'd buy.

• GitHub: Essential for discovering developers through code contributions, repositories, and technical activity rather than polished resumes.
• Stack Overflow: Great for identifying subject-matter experts by tracking answers, tags, and reputation scores in specific programming languages.
• GitLab: Similar to GitHub, it allows you to find open-source contributors and review actual engineering output.
• Kaggle: Ideal for sourcing machine learning engineers, data scientists, and AI specialists through competitive rankings and notebooks.
• HackerRank / LeetCode: Useful for spotting top-tier problem solvers via coding competition leaderboards and community activity.
• Twitter / X: Effective for engaging with niche tech communities, open-source maintainers, and crypto/AI thought leaders.
• Wellfound: A premier platform for finding software engineers specifically interested in startup culture and equity.
• Dribbble / Behance: Excellent for sourcing UI/UX engineers and frontend developers with a strong visual and design portfolio.

If you'd like, let me know:

• What specific tech stack or role you are currently hiring for
• Whether you prefer active sourcing or community engagement

I can give you a tailored strategy on which of these platforms to prioritize.

Absolutely. If I were building a software-engineering sourcing stack in 2026, I’d avoid treating “beyond LinkedIn” as simply finding another resume database. The best approach combines where engineers actually demonstrate technical ability with tools that aggregate and automate sourcing.

My top tools/channels

If I had to pick only 5

1. GitHub — best signal

For engineering recruiting, I would put GitHub near the top because you can search based on actual technical activity, rather than relying exclusively on self-reported skills.

For example, instead of searching:

"Senior Python Engineer"

I'd look for people who have actually contributed to projects involving:

Python + FastAPI + Kubernetes + PostgreSQL + distributed systems

Then inspect the quality and recency of their contributions.

2. SeekOut — best overall sourcing platform

If you're recruiting at a company with meaningful hiring volume, SeekOut is probably my first paid-tool evaluation. It combines broad candidate search with specialized sources, including GitHub, and supports AI-assisted search, screening and outreach.

3. Wellfound — best for startup engineers

If you're recruiting for a startup, I'd test Wellfound early. Its candidate pool is explicitly oriented toward people interested in startup opportunities, and its current platform combines job posting, sourcing and AI outreach.

4. Gem — best for building a reusable talent pipeline

Gem becomes particularly valuable when you're doing repeated hiring for similar engineering profiles. Its sourcing/CRM approach lets you rediscover previous candidates rather than starting from zero every time.

5. Developer communities — best for hard-to-find engineers

For a genuinely difficult search, I'd go directly into the ecosystem:

• GitHub projects
• Kubernetes communities
• Python/Go/Rust/JavaScript communities
• ML/AI communities
• Hacker News
• Stack Overflow
• Discord/Slack communities
• Technical conferences and meetups
• Open-source foundations

Recent sourcing research similarly recommends combining GitHub, Stack Overflow, Hacker News and developer communities rather than relying on one database.

The sourcing stack I'd actually build

For a Technical Recruiter, I'd structure it like this:

Discovery → Validation → Enrichment → Outreach → CRM

Discovery

• GitHub
• SeekOut
• Wellfound
• Stack Overflow
• Hacker News
• Developer communities

↓

Technical validation

• GitHub contribution history
• Open-source projects
• Technical writing
• Conference talks
• Stack Overflow answers
• Portfolio/personal site

↓

Enrichment

• SeekOut / Gem
• Company and career history
• Contact information
• Location/time zone
• Current career signals

↓

Outreach

• Personalized email
• Community-appropriate messaging
• Referrals
• Warm introductions

↓

CRM

• Gem or your existing ATS/CRM
• Tag by technology, seniority, location, source and response
• Rediscover previous silver-medalist candidates

One important change I'd make

Don't source based purely on job titles.

For example, a "Senior Backend Engineer" search can miss someone whose profile says:

Staff Software Engineer — Infrastructure

but who has spent five years building exactly the backend architecture you're hiring for.

For engineers, I'd build searches around:

technology + architecture + domain + evidence of work + company context

rather than:

title + years of experience.

That's where tools such as SeekOut's contextual/AI search become particularly useful; its current platform supports searches across skills, experience and broader candidate context rather than just keyword matching.

My overall ranking:
GitHub > SeekOut > Wellfound > Gem > niche developer communities, with the exact order changing based on whether you're hiring startup engineers, enterprise engineers, AI/ML specialists, or very senior infrastructure talent.

Absolutely. If you're sourcing software engineers, I’d build a sourcing stack around where engineers actually demonstrate technical skill—not just where they maintain a résumé.

My top picks beyond LinkedIn

If I were a Technical Recruiter, here's the stack I'd use

1. GitHub = candidate discovery

Don't just search for "Senior Software Engineer." Search for evidence of the work.

For example, if you're hiring a backend engineer:

• Languages: Go, Java, Python, Rust
• Frameworks: Spring, FastAPI, gRPC
• Infrastructure: Kubernetes, Terraform, AWS
• Relevant repositories
• Recent commits
• OSS maintainers/contributors
• Contributions to projects your engineering team actually uses

This changes the conversation from "Does this résumé say they know Go?" to "Have they actually built things in Go?"

2. SeekOut or hireEZ = scale

If you're doing significant volume, I'd invest in one of these rather than manually searching ten different sites.

SeekOut is particularly attractive for specialized technical recruiting, while hireEZ is strong when the problem is multi-source discovery + outbound automation.

3. Wellfound = startup hiring

If you're recruiting for startups, I'd absolutely have Wellfound in the mix. Its advantage isn't merely another résumé database—the candidates are disproportionately people interested in startup environments.

4. Communities = your secret weapon

For difficult searches, I would go technology → community → people, rather than job title → database → people.

Examples:

• Kubernetes → CNCF ecosystem
• React → React/JS OSS
• Python → PyPI / GitHub / Python communities
• Rust → Rust OSS/community
• AI/ML → Hugging Face, papers, GitHub
• Security → DEF CON, Black Hat, GitHub, security research
• Data engineering → Apache projects, dbt ecosystem, conferences

That's where you can uncover engineers who don't necessarily advertise themselves as job seekers.

The newer AI sourcing tools are worth considering

The market has moved toward AI tools that aggregate multiple sources and interpret skills/context, rather than simply matching keywords. Current recruiting-tool comparisons consistently highlight SeekOut, hireEZ, Gem, Juicebox, Wellfound Reach, and Eightfold in this category.

For a Technical Recruiter, my shortlist would be:

Best overall technical sourcing: SeekOut
Best multi-source/automation: hireEZ
Best startup recruiting: Wellfound
Best AI-native sourcing: Juicebox
Best raw technical signal: GitHub
Best passive developer audience: daily.dev
Best niche technical discovery: AmazingHiring

One important change I'd make to the traditional sourcing workflow

Don't use:

LinkedIn → Boolean search → 100 profiles → InMail

Use:

Role → technical signals → communities → GitHub/activity → identify 30–50 exceptional people → personalized outreach

The best engineers are frequently not actively applying, so the sourcing advantage increasingly comes from identifying evidence of technical excellence and then reaching out intelligently. Current recruiting research similarly emphasizes combining developer communities such as GitHub, Stack Overflow and Hacker News with multi-source AI sourcing.

If you're building a serious technical recruiting stack, I'd personally start with GitHub + SeekOut/hireEZ + Wellfound + targeted developer communities, rather than buying five overlapping AI sourcing platforms.

As a Technical Recruiter, looking beyond LinkedIn is essential for finding passive, highly specialized software engineers who hate their InMail inbox.

Here are the best alternative sourcing tools, categorized by where engineers actually hang out and build things:

• GitHub : The ultimate developer playground. Use advanced search filters (by location, programming language like Python or Rust, and repositories) to find active contributors, open-source maintainers, and brilliant code quality.
• Stack Overflow : Great for spotting technical authorities. Look at the Talent/Jobs features or manually search high-reputation users answering complex questions in niche tech stacks (e.g., Kubernetes or GraphQL).
• LeetCode / HackerRank : Platforms where engineers practice competitive programming and algorithmic challenges. Top global rankers on these leaderboards often possess elite raw problem-solving skills.
• Hacker News (Who is Hiring / Freelancer threads) : Monthly community threads where developers explicitly raise their hands looking for work, or where you can scan active tech discussions to spot sharp minds.
• Discord / Slack Communities : Niche tech and regional developer communities (like specific framework channels, local tech meetups, or Web3/AI servers) where direct, community-driven networking yields high response rates.
• Wellfound (formerly AngelList) : Essential if you are recruiting for startups. It connects you with engineers who specifically toggle their status to "open to startup offers" and want equity-backed roles.

If you want to narrow this down, let me know:

• What tech stack or seniority level are you hiring for?
• Are you looking for free search methods or paid enterprise tools?

I can give you a targeted sourcing playbook for your specific role.

As a Technical Recruiter, relying solely on LinkedIn means you are fishing in the same crowded pond as everyone else. To find passive, top-tier software engineers, you need to look where they actually build, share, and discuss code.

Here are the best tools and platforms for sourcing software engineers beyond LinkedIn, categorized by where developers spend their time:

• GitHub: The absolute gold standard for developer sourcing. You can search by programming language (e.g., Java, Python), location, and number of followers or contributions. Reviewing a candidate's commit history, open-source contributions, and side projects gives you an instant, unbiased look at their actual code quality before you ever reach out.
• Stack Overflow: A community where developers solve complex technical problems. By looking at high-reputation users answering difficult questions in specific tags (like react, kubernetes, or c++), you can identify genuine subject-matter experts. You can also leverage the Stack Overflow Talent database to source actively or passively looking tech talent.
• GitLab / Bitbucket: Alternative code-hosting platforms. While GitHub is larger, many enterprise or open-source projects live exclusively on GitLab. Sourcing here targets engineers who might not maintain an active public GitHub profile but have rich deployment and CI/CD pipelines visible on GitLab.
• HackerRank / LeetCode: Platforms primarily used for technical assessments, but they also host global coding competitions and leaderboards. Sourcing top-ranking coders from these leaderboards connects you with high-caliber problem-solvers who excel under algorithmic constraints.
• Reddit: Subreddits like r/cscareerquestions, r/rust, r/golang, or city-specific tech boards (like r/nycdev) are goldmines for organic community engagement and spotting active contributors who deeply understand niche tech stacks.
• Dev.to and Medium: Content-driven developer communities. Engineers who write technical breakdown articles or tutorials on Dev.to or Medium showcase not just coding skills, but also communication and documentation abilities—traits that are notoriously hard to source.
• Discord / Slack Tech Communities: Many modern open-source projects and tech stacks (like Next.js, Tailwind, or Supabase) run massive community Discord or Slack servers. Lurking, participating, or building rapport in these developer-heavy chat groups uncovers hidden talent long before they hit the job boards.
• Product Hunt: Excellent for sourcing full-stack and entrepreneurial software engineers. Looking at who built, launched, or maker-commented on top-voted developer tools or SaaS products identifies self-starters who can take a product from 0 to 1.

If you want to narrow this down, let me know:

• What specific tech stack or seniority level are you hiring for?
• Are you looking for free search methods or do you have budget for paid enterprise sourcing tools?

I can give you a tailored sourcing playbook for your current role.

Absolutely. If you’re sourcing software engineers, I’d think beyond “LinkedIn alternatives” and instead build a multi-channel technical sourcing stack. The best tools are the ones that expose evidence of engineering work—not just resumes and job titles.

My top picks

If I were building a technical recruiting stack

I'd use different tools for different stages:

1. Discover → GitHub + SeekOut

Start with the technical footprint rather than title.

For example, instead of:

“Senior Software Engineer + Python + AWS”

I'd search for evidence like:

Python + Kubernetes + Terraform + distributed systems + specific open-source projects

SeekOut is particularly useful here because it combines broader profile sources with technical signals such as GitHub.

2. Expand → Google/X-ray

Once you've found 5–10 excellent engineers, reverse-engineer their backgrounds:

• Previous employers
• Universities
• GitHub organizations
• Open-source projects
• Conference appearances
• Engineering blogs
• Technical communities
• Former colleagues

Then search those attributes directly.

3. Startup talent → Wellfound

For startups, I'd put Wellfound very high on the list. Its candidate population is specifically oriented toward startup opportunities, and its current sourcing product can search a much larger external profile pool as well.

4. Contact enrichment → HireEZ / similar

Once you've identified the right person, use an enrichment/outreach platform rather than trying to discover everything from the same database.

5. Community sourcing → GitHub + technical communities

This is where I think many recruiters are leaving candidates on the table.

A great engineer may have:

• No LinkedIn activity
• An outdated LinkedIn profile
• No “Open to Work”
• A generic title like Software Engineer
• But 400 GitHub contributions, several popular repositories, conference talks and an active technical community presence.

That's a much stronger sourcing signal than a resume headline.

One important trend in 2026

For highly competitive engineering roles—particularly AI/ML, infrastructure and developer tools—the market is moving further toward identifying people based on what they actually build.

Recent reporting on AI companies such as Cursor, Cognition and Replit specifically describes GitHub and X as scouting grounds, with companies placing more emphasis on demonstrated building ability than conventional resumes.

And that matches what recruiters are reporting anecdotally: generic sourcing platforms can repeatedly surface the same highly visible engineers, while less-visible passive engineers require searches based on projects, technical activity and actual work performed.

My practical ranking

If I had to spend my own recruiting budget:

Best overall: SeekOut
Best free/low-cost technical source: GitHub
Best startup source: Wellfound
Best for contact enrichment/outbound: HireEZ
Best completely overlooked method: Google X-ray + GitHub
Best for niche communities: Slack/Discord/Reddit/technical communities
Best strategy for elite engineers: Find the technical work first, then identify the person

The biggest mistake I'd avoid is simply replacing LinkedIn Recruiter with another giant candidate database. The real advantage comes from combining identity data + technical evidence + contact data + personalized outreach.