The Self-Hosted Install-Base Sweep: Deployment Evidence to a Ranked Queue
Run a dated sweep of public deployment evidence for one open-source project and finish with resolved accounts, named operators and buyers, and a trigger-ranked queue.
Key takeaways
- The GitHub dependents list is a floor, not a census: the dependency graph is off by default, covers public repositories only, and one study puts dependents error at up to 10%, with only 70.94% of Python dependents correctly identified in a second paper.
- GitHub code search returns at most 1,000 results per query at 10 requests per minute, so each capped query variant takes at least a minute, and a 50-variant sweep takes at least 50 minutes.
- Code search only indexes repositories active in the last year, so the sweep over-represents recently touched installs and under-represents stable, long-running production deployments.
- In Refolk's index there are 5,279 US platform, SRE, and DevOps engineers with the Kubernetes skill against 79 named infrastructure leaders, about 67 operators per budget owner, which makes buyer mapping the bottleneck.
- A departed-operator trigger only counts once the job change is confirmed, because a months-old last commit often means a stable deployment rather than an empty seat.
- The only published conversion baseline for single-vendor commercial open source is 0.5 to 2% of all users, so a trigger-ranked queue that cannot beat that band in your own closed-won data is not working.
This playbook is for founders, account executives, SDR leads, and partnerships teams who sell the paid edition of an open-source project and need to know which companies run the free version in production. It takes one project from public deployment evidence to a deduplicated account list where every company is resolved to a legal entity, tagged with the version it runs and when that was last touched, linked to a named operator and a named budget owner, and ranked by the trigger that gives it a reason to pay this quarter. Every stage has an owner, a time budget, and a definition of done.
What counts as deployment evidence, and what does each kind prove?
Deployment evidence is a file in a company-owned repository that configures your project to run: a manifest or lockfile that pins it, a container or chart reference that pulls it, infrastructure code that provisions it, or a CI config that builds against it. Stars, forks, and issues measure attention. A pinned version in an org-owned repo with CI and environment-specific config measures an install.
That distinction is the reason this playbook exists. Most public advice on how to find companies using your open source project sends you to a proprietary signal feed and treats a star as intent. A star-derived list in one published case reached 6,989 leads, opened at 28.5%, and reported no meetings. Engagement tells you who looked. Deployment evidence tells you who depends on you.
| Evidence | What it proves | How it lies |
|---|---|---|
| Manifest or lockfile pin | Code depends on a named version | Tutorial, sample app, or vendored copy |
| Container image reference | Your project runs as a service | Tag held in a variable, or a demo repo |
| Helm chart and values files | Deployed to a cluster, often per environment | Values copied from upstream examples |
| Terraform module reference | Provisioned in real infrastructure | Workshop or module-example repo |
| CI config | Built or tested on every change | Fork that inherited upstream CI |
Read the table as a ladder. One manifest hit on its own is weak. A manifest pin in an org-owned repository that also has CI and separate staging and production values files is about as strong as public evidence gets.
A star costs one click. A production values file with separate environments costs an engineer and a change review.
Download-telemetry playbooks start somewhere else: they count download or usage events from your distribution channel rather than code footprint. Telemetry sees private installs that code never shows, but it needs instrumentation you may not have. Code footprint needs nothing but public data and patience. The two complement each other. One telemetry provider reported finding 18.75% more companies when it added download data to web traffic, which is a reminder that any single source undercounts.
Why is the GitHub dependents list a floor and not a census?
The dependents tab only lists public repositories that have the dependency graph switched on and manifests GitHub could parse, and even that subset is partly wrong. Use its count as the minimum number of adopters, never as your open source install base account list.
Three filters stack on top of each other:
- Off by default. The dependency graph is "not enabled by default", so a repository only shows up if its owner turned the graph on.
- Public only. GitHub's docs say dependents are "other public repositories" and that this information "is not reported for private repositories". Most production config lives in private repos.
- Parse limits. GitHub ignores manifests over 10 MB and by default processes no more than 150 manifests per repository (GitHub Enterprise Server 3.18 documents 600). Manifests that use variables are dropped, because the graph "can't resolve variables used within manifests".
GitHub also warns that "dependent counts are approximate and may not always match the dependents listed."
What the dependents tab can see
- All production installsPrivate and public repos, plus installs with no repo at all
- Public repositoriesThe only repos the dependents tab ever reports
- Graph enabled and parseableGraph switched on, under 10 MB and the manifest cap, no variable pins
- Correctly identified dependentsWhat survives the published error rates
How much of that inner layer can you trust? The published research disagrees. Bifolco, Romano, Nocera, Francese, Scanniello, and Di Penta report that dependencies are over 27% inaccurate and dependents up to 10%. The same group's journal paper reports 96.62% of dependents correctly identified for Java, but only 70.94% for Python. The two Python figures conflict, so I cite both. If your project is Python-heavy, plan as if the lower figure applies.
What do code search limits do to a single sweep?
Code search caps every query at 1,000 results, 10 requests per minute, and 4,000 repositories, and it only sees the default branch of repositories active in the last year. So a sweep has to be split into many narrow queries, and it will still miss stable installs nobody has touched.
| Limit | Value | Effect on the sweep |
|---|---|---|
| Results per query | 1,000 | Wider queries are cut off without warning |
| Request rate | 10 per minute | A full capped query takes about 1 minute |
| Repos per query | 4,000 | Broad filters stop early |
| Indexed scope | Default branch, files under 384 KB, repos under 500,000 files | Pins on release branches are invisible |
| Recency | Active or surfaced in search in the last year | Long-stable installs drop out |
| Archived and forks | Archived never searchable; forks only if more stars than parent and a pushed commit | Most forks vanish, which is mostly good |
The time arithmetic is derived, not published. A query that returns the full 1,000 results takes 10 pages, which at 10 requests per minute is about one minute. A sweep of 50 query variants therefore takes at least 50 minutes before any filtering. Third-party tool documentation adds two more limits: a maximum query length of 256 characters, and forks excluded by default. I have not checked those against GitHub's own docs, so test them on your first run.
Search for your image and chart names, not just your package name. Container and chart deployments often never mention the package, and variable-pinned manifests never reach the dependency graph at all. The query set below covers the common file types. Run each line as its own query.
PKG filename:package.json PKG filename:package-lock.json PKG filename:requirements.txt PKG filename:go.mod PKG filename:pom.xml IMAGE filename:Dockerfile IMAGE filename:docker-compose.yml IMAGE extension:yaml path:k8s CHART filename:Chart.yaml CHART filename:values.yaml PKG extension:tf IMAGE extension:tf PKG path:.github/workflows IMAGE path:.github/workflows # Split rule: any line that returns 1,000 results is truncated. # Add a path: or extension: qualifier and rerun until every piece returns fewer than 1,000.
Replace PKG, IMAGE, and CHART with your package, container image, and chart names, and drop lines for ecosystems you do not ship to.
The install-base sweep, step by step
The sweep runs in eight stages, from the dependents export to a quarterly check against closed-won, and one project takes most of a working day before operator and buyer mapping. No published source documents this procedure end to end. I put the order together from the documented limits above, and every time estimate here is derived.
From one project to a ranked upgrade queue
- Pull the dependents list as a floorExport the dependents tab, date the file, and mark it partial because it covers public repos only and its counts are approximate.
- Run the code search sweepQuery manifests, lockfiles, Dockerfiles, chart values, Terraform, and CI configs by filename and path, and split any query that returns 1,000 hits.
- Filter out non-deploymentsDrop forks, demo and workshop repos, vendored copies, and personal repos, and keep org-owned repos with CI or environment-specific values files.
- Resolve each org to a legal entityUse the verified badge first, then the org's blog and email fields, then committer email domains, and record the route used.
- Tag the version and recencyRecord the pinned version and the date of the last commit to the manifest, and flag variable pins as unknown.
- Name the operator and the budget ownerTake the last committer to the manifest as operator, and find the Director, Head, or VP of infrastructure or platform as budget owner.
- Assign a trigger and rank the queueTag each account with end-of-life version, advisory exposure, confirmed departed operator, scale-out, or none, and attach dated evidence.
- Check the queue against closed-wonEach quarter, compute hit rate by trigger and compare it with the 0.5 to 2% single-vendor baseline.
| Stage | Owner | Time budget | Done looks like |
|---|---|---|---|
| Dependents export | RevOps or founder | About 1 hour | Dated CSV marked partial |
| Code search sweep | SDR lead | 30 to 90 minutes | Hit list with repo, path, date |
| Filtering | SDR | 1 to 2 hours | Deduplicated org-level list |
| Org resolution | RevOps | 2 to 5 min per org (unverified) | Entity, domain, route |
| Closed-won check | RevOps | Quarterly | Hit rate per trigger |
Filtering a hit down to a deployment
Keep a hit only if it passes all three tests:
- The repository is owned by an organization, not a personal account.
- It has CI configuration.
- It holds environment-specific values or config, such as separate staging and production files.
Drop anything named demo, example, or workshop, any fork, and any repo that contains a copy of your source tree instead of a reference to a released version. Then deduplicate: one company often shows up through several repos, and the account is the org, not the repo.
Resolving an org to a legal entity
GitHub's verified badge is the strongest public route. An organization gets it when "the public information on the organization's profile (website and/or email) match the verified domain(s)", and the GraphQL field isVerified reports it. GitHub launched org domain verification on 6 August 2018. Without the badge, use the REST org object's company, blog, location, and email fields, then the email domains of the committers. Committer domains are thinner than they look, because accounts created after 18 July 2017 can commit from noreply addresses.
Nobody has published what share of orgs resolve cleanly by each route, and no documented procedure goes from a domain to a legal entity. Record which route you used on every account so you can audit it later. That record is the template at the end of this guide.
Who runs the deployment, and who signs for the paid edition?
The operator is the person who last committed to the manifest that pins your project. The budget owner is a Director, Head, or VP of infrastructure or platform at the same company. Operators are easy to find and buyers are scarce: Refolk's index shows about 67 US platform, SRE, and DevOps engineers with the Kubernetes skill for every infrastructure leader who lists that skill.
| Band (United States, Kubernetes skill) | Count | Operators per leader |
|---|---|---|
| Engineers (Platform, SRE, DevOps) | 5,279 | n/a |
| Leaders (Director, Head, VP of Infra or Platform) | 79 | About 67 (derived) |
Two details from the samples change how you search. In a 25-profile sample of the leaders, "Director of Platform Engineering" accounts for 13, so start your buyer title search there and widen to Head and VP afterwards. On the operator side, the top employer in a 25-profile US sample was Apple with 3. Operators are spread thinly across many employers, which is why the sweep goes company first and person second.
Mapping budget owners is the bottleneck of the whole process. Committer names come free with the evidence. Buyer names have to be found company by company. Refolk takes that title search as a plain-English request across LinkedIn, GitHub, and the open web, so the search is one request rather than a separate title hunt for each account.
Germany is a different market
The operator pool in Germany is about a quarter of the US pool, and the titles skew differently.
| Market | Total | DevOps share | SRE share | Platform share |
|---|---|---|---|---|
| United States | 5,279 | 44% | 36% | 4% |
| Germany | 1,294 | 52% | 24% | 8% |
Totals are full counts from Refolk's index. Shares come from 25-profile samples, so read them as direction, not precision. The US pool is 4.1 times the German one. The German sample's top employers were Deutsche Telekom and trivago, with 2 each. In practice, German outreach and title searches should lead with DevOps wording, while US searches need DevOps and SRE wording side by side.
No published policy defines when outreach has to go to the budget owner instead of the engineer. The rule above is mine, not an industry norm. One practitioner summed up commit emails this way: "You can technically read it, and you should not use it."
Which trigger earns a place in this quarter's queue?
Four triggers justify outreach this quarter: the pinned version is end-of-life, the pinned version is exposed to a published security advisory, the operator who owned the deployment has confirmed left, or the footprint is scaling out. No primary source ranks these as conversion drivers. They are hypotheses, and your closed-won history has to confirm them.
Each trigger rests on evidence you can date. The dependency graph shows the version of each dependency, code search returns pinned versions on the default branch, and commit history gives the last manifest edit and the last commit by a named operator.
| Trigger | Dated evidence | What it proves | How it lies |
|---|---|---|---|
| End-of-life version | Pinned version against an EOL date | Running a version you no longer support | The pin sits in a sample file, not the deploy path |
| Advisory exposure | Pinned version matched to an advisory | Config references a vulnerable version | The repo found is not the one deployed |
| Departed operator | Old last commit plus a confirmed job change | Nobody in house owns the install | Stable deployment, operator still in seat |
| Scale-out | New manifests, environments, or values files | Footprint is growing | One-off migration copied across repos |
For end-of-life dates, endoflife.date is a public reference, and OSV.dev is a public advisory database you can match versions against. I have not checked either one's coverage of any particular project here. Confirm your project is listed before you rely on them, and use your own release policy as the source of truth for your own versions.
Where an account sits in the queue
Rank inside the top-right quadrant in this order:
- Advisory exposure, because it carries a deadline the buyer already feels.
- End-of-life version.
- Confirmed departed operator.
- Scale-out.
That order is my judgement, not a published finding. Replace it with the order your own closed-won data supports after the first quarterly check.
How the install-base sweep goes wrong
Most failures come from treating a partial source as complete, or reading a quiet signal as a loud one. Each failure below has a specific check. Run the checks before an account enters the queue, not after an AE has wasted a sequence on it.
- Treating the dependents tab as the population. Python-heavy projects can be badly undercounted, given the 70.94% accuracy figure. Check: always run code search alongside it and work from the deduplicated union.
- Variable-pinned versions. Manifests that set your version through a variable never appear in the graph, so it looks like nobody has adopted you. Check: search for the image or chart name, not the package, and record the version as unknown rather than guessing.
- Silent truncation at the search cap. A query that returns exactly 1,000 hits has been cut off without warning. Check: split by path or filename until every query returns fewer than 1,000.
- Forks and tutorials. The false positive is a repo named demo, example, or workshop, or a fork. Check: is it org-owned, does it have CI, and does it hold environment-specific values files?
- Inactive repos vanish. Repos with no activity in the last year drop out of code search, so long-stable production installs are missed. Check: look for those accounts through other channels, such as image pull data or documentation that mentions your project.
- Wrong-entity resolution. An unverified blog field can point to an agency or a personal site, and you end up attributing a client's deployment to its contractor. Check: require the verified badge or matching committer email domains before an account counts as resolved.
- Departed operator that never departed. A last commit that is months old often means the deployment is stable, not that the operator left. Check: confirm the job change before calling it a trigger.
- Contacting the engineer. Emailing commit addresses goes against the spirit of AUP section 7. Check: route all outreach to the budget owner through business channels.
On failure 7, confirming a job change is a person lookup, not a repo lookup. Asking Refolk for the operator by name and last-known employer shows whether their current role has moved, which is the confirmation the trigger needs.
What hit rate should the queue reach?
Nobody has published a head-to-head comparison of outbound to deployment lists against outbound to star or fork lists, so your target has to come from your own CRM. The floor to beat is the published single-vendor baseline: conversion of 0.5 to 2% across all users.
| Case | List source | Published metric |
|---|---|---|
| Unstructured | Companies known to use its OSS | Open rate 2 to 2.5x industry standard |
| NodeSource | GitHub activity, 4,000 leaders | 7.5% response, 5% positive |
| opendirectory | Stars, 6,989 leads | 28.5% open, no meetings reported |
| Single-vendor COSS (Taylor) | All users | 0.5 to 2% conversion |
None of these measure the same thing. Unstructured targeted companies that used its open source but not its commercial product, and got an open-rate lift. That shows a usage-based list is relevant, not that it converts. NodeSource's 300 responses and 200 positive replies from 4,000 leads are reply metrics. The star list shows high opens can come with no meetings at all. Only the Taylor figure, cited by Riehle, is a conversion rate, and it covers all users, not a ranked queue.
Define hit rate as the share of accounts entering the queue in a quarter that reach closed-won within your normal sales cycle. Then apply three rules:
- First quarter: the target is to beat 2%, the top of the baseline band. A queue built on confirmed triggers that cannot beat the average across all users is not finding the buyers who have a reason to pay.
- After that: set a target for each trigger from your own closed-won history, and drop or demote any trigger that does no better than the no-trigger accounts.
- Always: compare by trigger, not just in total. One strong trigger can hide three useless ones.
Keeping the install base current
Rerun the sweep on a fixed, dated cadence, diff it against the previous run, and recheck every trigger and operator each quarter. The install base shifts as versions age into end-of-life, advisories get published, and operators change jobs. A queue that is not refreshed ranks last quarter's reasons to pay.
Keep the dated file from every run. The diff is where new triggers show up: a version that crossed its end-of-life date, a new environment folder, an operator whose last commit has gone quiet. Store each account in one consistent record so the diff can be done by machine.
account_legal_entity: domain: resolution_route: verified badge | blog or email field | committer email domains evidence_repo: evidence_path: evidence_type: manifest | lockfile | image | chart | terraform | ci pinned_version: (or unknown: variable pin) last_manifest_commit: sweep_date: operator_name: operator_status: in seat | departed, confirmed on DATE | unconfirmed budget_owner_name: budget_owner_title: trigger: eol | advisory | departed_operator | scale_out | none trigger_evidence_and_date: queue_rank: outcome_after_quarter: open | lost | closed-won
One record per resolved company; leave a field as unknown rather than guessing, and update sweep_date on every run.
Before the queue goes to the AEs
- The dependents export is dated and marked as a lower bound.
- Every code search query returned fewer than 1,000 results.
- Image and chart names were searched, not only the package name.
- Every account is org-owned and passed the CI or environment-config test.
- Every account has a legal entity, a domain, and a recorded resolution route.
- Every account has a pinned version or an explicit unknown, plus a last-commit date.
- Every departed-operator trigger has a confirmed job change.
- Every account has a named budget owner, and no outreach goes to commit addresses.
- Last quarter's hit rate by trigger has been compared with the 0.5 to 2% baseline.
Questions practitioners ask
Can I use the GitHub dependents list as my install base?
No. Use it as a lower bound only. The dependency graph is not enabled by default, it only reports public repositories, it drops manifests that use variables, and GitHub itself says dependent counts are approximate. Published studies put dependents error at up to 10%, and one paper found only 70.94% of Python dependents correctly identified. Run code search alongside it and treat the union, deduplicated at org level, as your working list.
Is it okay to email developers whose commits reference our project?
No. GitHub's Acceptable Use Policy section 7 forbids using information from the service, scraped or pulled through the API, to send unsolicited emails, and PyPI and GitLab have equivalent clauses. Use the committer as evidence of who operates the deployment, then reach the company's budget owner through ordinary business channels. No published policy says when you must go to the buyer instead of the engineer, so treat that routing as your own standing rule.
How long does one install-base sweep take?
Plan on most of a working day for one project. The dependents export takes about an hour, the code search sweep 30 to 90 minutes, filtering 1 to 2 hours, and org resolution an unverified 2 to 5 minutes per org. Code search allows 10 requests per minute and 1,000 results per query, so each capped query variant costs at least a minute. Operator and buyer mapping comes on top of that and usually takes the longest.
How do I tell a production deployment from a tutorial or a fork?
Check three things: whether the repository is owned by an organization rather than a person, whether it has CI configuration, and whether it holds environment-specific values files such as separate staging and production overrides. Repos named demo, example, or workshop, forks, and vendored copies of your source are the common false positives. No published study validates a query pattern that separates them automatically, so this filter is a manual review step.
What conversion rate should I expect from an open source install-base list?
No published case links deployment-list outbound to closed-won, so you have to measure your own. The closest baseline is Taylor's, cited by Riehle: conversion of 0.5 to 2% is common for single-vendor commercial open source firms, measured across all users. A trigger-ranked queue should beat that band. Open-rate lifts such as Unstructured's 2 to 2.5x tell you the list is relevant, not that it converts.
Why does my project show few dependents when I know companies use it?
Usually because the evidence never reaches the graph. Most deployments live in private repositories, the dependency graph is off by default, and manifests that pin your version through a variable are dropped because the graph cannot resolve variables. Container and chart deployments often never reference your package name at all. Search code for your image and chart names, and expect long-stable installs to be missing, since code search skips repos inactive for a year.
Try it on the search you came here for
Stop building boolean strings. Just describe the person.
Type one sentence. I plan the search, read GitHub, public LinkedIn and Crunchbase records, and the open web as it is right now, and hand back a ranked list with the reason next to every name.
01Describe them
One plain sentence. Role, city, stack, stage, whatever matters to you.
02I read the web live
GitHub, public LinkedIn and Crunchbase records, the open web. Not a database that went stale last quarter.
03You read the shortlist
Ranked, with the reasoning under every name. Open a profile, ask a follow-up, narrow it down.
- Staff backend engineers in NYC who shipped Rust in production
- Series A fintechs in SF under 50 people, growing headcount this year
- Maintainers of fast-growing Rust web frameworks on GitHub
- No boolean, no filters, no seat to buy. One box.
- Read at search time, so a profile updated yesterday counts today.
- Every step visible as it runs, every name with its reason.
500 free credits on sign-up. No card, no demo call. See real searches.