# The Pre-Raise Repo-Momentum Pipeline: Thesis to Timed Queue

*You can turn a thesis-scoped repo universe into a ranked queue of 15 to 25 projects, each mapped to company and founders with a dated outreach window.*

- Canonical URL: https://www.refolk.ai/guides/pre-raise-repo-momentum-pipeline
- Pillar: Investing and deal sourcing
- Format: Playbook
- Published: 2026-10-14
- Last reviewed: 2026-10-14
- Reading time: 15 min
- Keywords: how to find open source startups before they raise, github star velocity deal sourcing, measuring open source project momentum, sourcing commercial open source companies, open source fundraise benchmarks

## Key takeaways

- Redpoint's panel puts seed-stage dev-tool projects at a median of 2,850 GitHub stars and Series A at 4,980, with contributors moving from 25 to 50 - use these as a price list, not a target.
- The leading edge of a raise is commit velocity rising in the 14-day window; a 50%-plus contributor jump usually means the round already closed, so weight velocity above headcount.
- Stars are the most gameable signal: buying the 2,850-star seed median costs $85 to $285, an ROI of 3,500x to 117,000x against a seed round, so never rank on stars alone.
- Time is the cheapest fake-star filter - 75% of bought stars vanish within a month, so a two-snapshot net-growth read over 4 to 8 weeks auto-removes most purchased spikes.
- GitDealFlow's panel of 219 observations across 55 startups shows the signal appearing 21 to 47 days before a public funding announcement, which is your conservative outreach window.
- In Refolk's index, US open-source founders outnumber Germany's 7.7 times (792 versus 103), San-Francisco-weighted, so set per-geography star floors rather than one global bar.

This is the sit-down-Tuesday procedure for catching an open-source project on its way to a fundraise, before the deck circulates. It is for early-stage investors, platform and talent partners at funds, and angels running a repo-driven thesis. Run it weekly and you will produce a ranked queue of roughly 15 to 25 projects accelerating toward a raise, each resolved to its backing company and founders, with a dated window to reach out.

The library already covers the monetization read, the investability bar, the bought-stars teardown, and the signal reference. This guide is the running process that ties them together: thesis in, timed queue out, with named benchmarks at every gate instead of a single star scrape.

## What this pipeline produces and why stars are the wrong anchor

The output is a de-noised, ranked queue of open-source projects whose engineering momentum is accelerating weeks before any funding is announced, each mapped to a company, a funding status, named founders, and a dated outreach window. The input is a thesis-scoped universe of repositories you define on Monday. Everything between is a weekly process you can hand to an analyst and audit.

The reason this is a process and not a leaderboard lookup is that the obvious metric lies. Published star medians function as a price list. Redpoint's analysis of 80 dev-tool companies puts the seed-stage median at 2,850 GitHub stars, and buying that many costs roughly $85 to $285. Against a typical seed round, that is an ROI between 3,500x and 117,000x. Any pipeline anchored on stars is selling to the metric most cheaply faked.

**3,500x-117,000x - ROI of buying the 2,850-star seed median against a typical seed round**

Buying that star count costs roughly $85 to $285, which is why stars are the first signal gamed.

The leading edge of a raise is not a star count at all. It is commit velocity rising in a short window, weeks before the team expands. By the time contributor count jumps, the round has usually closed and the new hires are the proof. So this pipeline weights velocity above headcount, uses contributors as a phase gate rather than a ranking variable, and treats stars as a last-resort tiebreaker only.

> Published star medians are a price list, so the metric everyone ranks on is the one most cheaply faked.

## The benchmarks that qualify a project

Use a small set of published, panel-grounded benchmarks to decide whether a project is in the fundable band at all. These are qualification gates, not scoring weights. The cleanest set comes from Redpoint's panel of 80 dev-tool companies, which separates seed-stage from Series A projects on three durable axes.

| Metric | Seed median | Series A median |
|---|---|---|
| GitHub stars | 2,850 | 4,980 |
| Contributors | 25 | 50 |
| Slack/Discord members | 300 | 1,274 |
| MoM star growth (seed to A avg) | 7.9% | - |

Read the table as a band, not a bar. A project sitting near the seed medians with rising velocity is the sweet spot; one already past the Series A medians is probably raised. Redpoint's Top-25 community thresholds sharpen the seed end: around 2,000 stars, a forks-to-stars ratio above 5%, and roughly 50 contributors. The forks-to-stars ratio matters because forks cost effort, so a healthy ratio is harder to fake than a raw star count.

Two other anchors bound the universe. The ROSS Index computes star growth only for repos that start the period with at least 1,000 stars, then manually verifies that the entry is a startup. That 1,000-star floor is a useful minimum to keep low-base noise out. And Oxx's research finds a genuine phase change: once a project crosses 50 to 100 active monthly contributors, it often enters a compounding phase that is technical, communal, and commercial at once. That contributor band is a sharper qualification gate than any absolute star count, because it reflects sustained human effort rather than a one-time click.

> **Rule:** Gate on the 1,000-star floor before you rank
>
> Compute percentage growth only on repos that start the period above 1,000 stars. A repo going 1 to 54 shows a 54x gain on trivial volume, and ranking on percentage alone will float it to the top.

## The signals that actually lead, ranked by how they fail

Rank on the signals that decay when interest fades, because those are the ones money cannot buy cheaply. The order below runs from most leading and least gameable to most trailing and most gameable.

- **Commit velocity (14-day window).** The change in commit activity versus the prior 14 days. This is the leading edge; it rises before the team grows. When it lies, it is a single contributor's refactor sprint, so confirm the velocity is spread across more than one author.
- **Contributor growth (30-day window).** A real phase gate at 50 to 100 active monthly contributors. When it lies, it is a sudden 50%-plus jump that reflects post-round hiring, which means you are late.
- **Watchers and watcher growth.** Two Sigma weights watchers at 40% and watcher growth at 25%, deliberately dropping stars, because users un-watch when they lose interest. That decay makes watchers a more sustained signal than stars.
- **Issue and PR throughput.** Real projects generate sustained issue engagement and pull-request activity. When it lies, it is a burst of low-quality issues around a launch.
- **Registry downloads (npm, PyPI, release assets).** Directional adoption. When it lies, it is CI robots inflating the count, so compare the weekly-to-monthly ratio and inspect the user-agent breakdown before trusting it.
- **Stars.** Last resort. The most published, most benchmarked, and most cheaply faked signal in the set.

#### Signal stack, leading edge on top

1. **Commit velocity (14-day)** - Rises weeks before the team expands; the true leading edge
2. **Contributor growth (30-day)** - A phase gate at 50-100 active monthly contributors
3. **Watchers and throughput** - Two Sigma weights watchers 40%; decays when interest fades
4. **Registry downloads** - Directional adoption, prone to CI inflation
5. **GitHub stars** - Most published, most benchmarked, most cheaply faked - tiebreaker only

*Rank on the top layers because they decay with disinterest; use the bottom layer only to break ties.*

## Run the weekly pipeline

Execute these seven steps in order every week. The timings assume one analyst with a pulled snapshot; the only published timing anchor is the 21 to 47 day lead-time window, so treat the queue size and cadence as your own settings.

#### The weekly repo-momentum pipeline

1. **Scope the thesis universe** - Define sectors, languages, and a star floor (ROSS starts at 1,000). Build the candidate org and repo watchlist for the week. Done when you have an enumerated list of orgs to monitor.
2. **Pull the velocity snapshot** - Compute the 14-day commit-velocity change, 30-day contributor growth, new-repo count, and two-snapshot net star growth per repo. Done when you have a metrics table, one row per repo.
3. **De-noise the window** - Exclude funding-announcement and release spikes, then run fake-star heuristics on zero-follower share, fork-to-star ratio, and account-creation clustering. Done when each repo is flagged or clean.
4. **Score and rank** - Apply a weighted 0-100 composite with velocity and contributor growth dominant and stars as a last resort. Cut to the top 15 to 25. Done when you have a ranked queue.
5. **Resolve to company and founders** - Use FUNDING.yml, the .github repo, org members, public Crunchbase and professional-graph records, and Refolk for people. Done when each repo maps to a company, a funding status, and named founders.
6. **Estimate stage and time outreach** - Estimate stage from contributor count, flag any contributor step-function as late, and set a dated window 21 to 47 days before the projected deck. Done when every target has a dated outreach window.
7. **Run outreach** - Contact founders directly, before a round formally exists, inside the dated window. Done when each contact is logged against the target.

The scoring step deserves a concrete default. GitDealFlow's open signal-engine computes commit velocity over a 14-day window, contributor growth over 30 days, and new public repos over 30 days, then folds them into a weighted 0 to 100 composite with a four-way classification and a stage estimate from contributor count. Two Sigma's index normalizes each variable to a 0 to 100 scale and weights watchers at 40%, watcher growth at 25%, and contributors at 15%. Borrow that shape: velocity and contributor growth dominant, watchers next, stars as the tiebreaker.

**Composite score skeleton (0-100)**

```
composite =
  0.35 * commit_velocity_14d_change   (capped, multi-author only)
+ 0.25 * contributor_growth_30d
+ 0.20 * watcher_growth
+ 0.10 * issue_pr_throughput
+ 0.10 * net_star_growth_two_snapshot
penalties:
  -40 if window overlaps a known launch or funding post
  -40 if zero_follower_star_share > 30%
  -20 if fork_to_star_ratio < 0.1 of baseline
flag "LATE" if contributor_count jumped > 50% without a prior velocity surge
```

*Tune the weights to your thesis, but keep velocity and contributor growth above stars.*

## De-noising: how this pipeline gets fooled

The de-noise step is the most valuable part of the process, because every false positive here costs you a wasted outreach and a damaged reputation with a founder who already raised. Here are the failure modes the evidence documents, what each looks like, and the check that catches it.

| Failure mode | What it looks like | The check |
|---|---|---|
| Bought-star spike | Hundreds of stars right after repo creation or before a release | Zero-follower share >30%, fork-to-star <10% of baseline, 75% evaporate at re-snapshot |
| Announcement spike | A launch or HN front page inflates one window | Exclude any window overlapping a known launch or funding post |
| Contributor step-function | A 50%-plus contributor jump reads as acceleration | Timestamp the jump against velocity; prioritise velocity surges that precede it |
| Stars-only ranking | A high-star, low-engagement repo floats to the top | Cross-weight watchers, contributor growth, and issue/PR throughput |

Two of these deserve more weight. The **bought-star spike** is the most common trap, and time is the cheapest detector. Dagster's teardown found that 75% of purchased stars disappear within a month, and CMU's StarScout study found the fake-star promotion effect reverses in under two months. A two-snapshot net-growth measurement over 4 to 8 weeks therefore auto-filters most purchased spikes without any per-account forensics. When you do need forensics, Dagster's obvious-fake heuristics apply: accounts created recently, one or zero followers and following, no gists, a handful of empty-profile repos, and a star date equal to the account-creation date. Third-party sampling found 36% to 76% of stars on flagged repos came from zero-follower accounts.

> **Watch out:** A contributor jump is a lagging signal, not a leading one
>
> A sudden 50%-plus contributor jump usually means post-round hiring, so ranking on contributor count alone catches companies after they raise. Prioritise the commit-velocity surge that precedes the jump; that is the fundable window, and it closes before the headcount moves.

The **download-inflation** trap is subtler. Registry counts from npm and PyPI spike from CI robots, not humans, so one project showing 191,392 asset downloads across 30 releases tells you little on its own. Compare the weekly-to-monthly ratio and inspect the installer and user-agent breakdown before you treat downloads as anything more than directional.

## Resolving a repo to its company and founders

Resolve each ranked repo to a real company and named people through a fixed chain of public handles, confirming attribution with at least two independent sources before you trust it. The academic precedent is solid: one peer-reviewed study linked 14,881 GitHub organization accounts to Crunchbase company profiles using the public event log, and found open-source engagement tied to at least 36% higher funding likelihood.

Work the handles in this order:

1. **FUNDING.yml and the .github repo.** The organization's funding file names its GitHub Sponsors setup, which allows one organization and up to four sponsored developers. This is the most direct link from repo to sponsored people.
2. **Org member list.** The public roster of the organization, which surfaces maintainers and often the founding team.
3. **Public Crunchbase and professional-graph records.** Funding status, round history, and named founders.
4. **Refolk for people.** Resolve the named founders and maintainers to reachable profiles, and expand from a single maintainer to the full founding team.

The hard limit: the creator of a GitHub organization is never publicly visible, and only current owners and admins can see certain administrative details. So you can confirm who runs an org today but not who started it. That is why a personal fork or a namesake org gets misattributed to a company. Confirm the match through FUNDING.yml or .github plus the member list plus a professional-graph record before you log it.

I ran this search: `Co-founders of open-source AI-infrastructure projects in the US with 2,000+ GitHub stars and rising contributor counts.` - [see the full result list](https://www.refolk.ai/s/naxcehgp64).

*Returns named co-founders mapped to profiles you can reach, pre-filtered to the US AI-infrastructure band near the seed star median.*

Geography is part of resolution, not an afterthought, because the resolvable supply concentrates. In Refolk's index, US open-source founders outnumber Germany's by 7.7 times. Set your per-geography star floors accordingly rather than applying one global bar.

| Market | Founders/Co-Founders w/ Open Source skill | Top hub (sample) |
|---|---|---|
| United States | 792 | San Francisco |
| Germany | 103 | Berlin |
| US/Germany ratio (derived) | 7.7x | - |

That concentration also sets expectations for how scarce the open-source founder is inside the broader technical-founder pool. Against the machine-learning founder population, open-source specialists are a thin slice.

| Skill | US Founders/Co-Founders | Share of ML pool (derived) |
|---|---|---|
| Machine Learning | 13,479 | 100% |
| Open Source | 792 | 5.9% |

**792 - US Founders and Co-Founders with an open-source skill in Refolk's index**

Just 5.9% of the US machine-learning founder pool, San-Francisco-weighted, so the resolvable universe is small and worth working precisely.

## Timing the outreach window

Set a dated window 21 to 47 days before the projected deck circulates, and treat that as the conservative bound. GitDealFlow grounds the 21 to 47 day figure in a panel of 219 startup-period observations across 55 startups, with a rule that the signal must predate the event by at least 30 days to count. The same operator elsewhere cites 3 to 6 weeks and 6 to 12 weeks, so the sources disagree internally. Take the tightest number and verify it against your own closed deals.

#### From velocity surge to timed outreach

1. **Commit-velocity surge** - 14-day window rises across multiple authors; the leading edge
2. **Two-snapshot confirmation** - Net growth sustains over 4 to 8 weeks, filtering bought spikes
3. **Projected deck date** - Estimate stage from contributor count and momentum slope
4. **Dated window** - Set outreach 21 to 47 days before the projected deck

*The fundable window opens at the velocity surge and closes when the contributor step-function fires.*

The stage estimate comes from contributor count, with the Redpoint medians as reference: around 25 contributors reads seed, around 50 reads Series A. Then watch for the step-function. If contributors jumped 50% or more without a prior velocity surge, flag the target LATE and deprioritise it; the round has likely closed. The targets worth your window are the ones where velocity is climbing and the team has not yet expanded.

#### Velocity versus headcount quadrants

Horizontal axis runs from Flat contributors to Contributor step-function fired. Vertical axis runs from Rising commit velocity to Flat commit velocity.

| Quadrant | What it means |
| --- | --- |
| Rising velocity, flat headcount | Reach now - the fundable window is open |
| Rising velocity, headcount jumped | Likely closing; move fast or deprioritise |
| Flat velocity, flat headcount | Watch; re-snapshot next week |
| Flat velocity, headcount jumped | Already raised; log as late and drop |

*Reach the top-left; the top-right has usually already raised.*

## Keep the pipeline honest

Before you call a week's queue done, verify it against this checklist. The pipeline degrades when any gate is skipped, and the failure is silent: you will not know you queued a raised company until the founder tells you.

#### Queue acceptance check

- [ ] Every ranked repo started the growth period above the 1,000-star floor
- [ ] Every window overlapping a known launch or funding post is excluded
- [ ] Net star growth is confirmed across two snapshots 4 to 8 weeks apart
- [ ] Repos with zero-follower star share above 30% or fork-to-star below 10% of baseline are flagged
- [ ] Ranking is driven by commit velocity and contributor growth, with stars as a tiebreaker only
- [ ] Each target is resolved to a company via at least two independent handles
- [ ] Any contributor step-function without a prior velocity surge is flagged LATE and dropped
- [ ] Each remaining target carries a dated window 21 to 47 days before its projected deck

To keep the process current, re-verify the lead-time anchor against your own outcomes. The 21 to 47 day figure is one operator's panel, and that operator's own pages disagree. Log the gap between your first contact and the eventual announcement for every target that raises, and let your median replace the borrowed one. Do the same for the composite weights: when a queued project raises, note which signal led, and shift weight toward it. The benchmarks in Redpoint's and Oxx's research are a sound starting band, but the only numbers you should fully trust after a few quarters are the ones your own pipeline earned.

Refolk removes the two slowest manual steps here: expanding a single maintainer handle into the full founding team, and filtering a thesis-scoped universe down to founders who have not yet raised. Describe the people you want in plain English and get them back resolved and reachable, which turns the resolution step from a two-to-three hour chase into a query. Spend the time you save on the de-noise step, where the judgement actually lives.

## Frequently asked questions

### How many weeks before a raise can repo momentum be detected?

Treat 21 to 47 days as the conservative window. GitDealFlow grounds this in a panel of 219 startup-period observations across 55 startups where the signal appeared 21 to 47 days before the public announcement. The same operator elsewhere cites 3 to 6 weeks and 6 to 12 weeks, so the sources disagree. Use the tightest published figure and verify against your own closed deals rather than trusting a single lead-time claim.

### Why not just rank projects by GitHub stars?

Stars are the single most gameable signal. Buying the 2,850-star seed median costs roughly $85 to $285, an ROI of 3,500x to 117,000x against a seed round, and CMU's StarScout study found about 6 million suspected fake stars across 18,000-plus repos. Two Sigma dropped stars entirely, weighting watchers at 40%. Rank on commit velocity and contributor growth, and use stars only as a last resort tiebreaker.

### What contributor count signals a project is maturing commercially?

Oxx finds that crossing 50 to 100 active monthly contributors often triggers a compounding growth phase that is technical, communal, and commercial at once. Redpoint's medians put seed at 25 contributors and Series A at 50. A sudden 50%-plus jump, though, usually signals post-round hiring, which means you are already late. Prioritise commit-velocity surges that precede the contributor jump.

### How do I map a repo to its backing company and founders?

Start with FUNDING.yml and the organization's .github repo, then the org member list. Cross-check funding and named founders against public Crunchbase and professional-graph records, and resolve people through Refolk. A peer-reviewed study linked 14,881 GitHub orgs to Crunchbase this way. Note the org creator is never publicly visible, so confirm attribution through at least two independent handles before trusting it.

### How do I tell bought stars from real traction?

Time is the cheapest detector. Roughly 75% of purchased stars disappear within a month, so a two-snapshot net-growth measurement over 4 to 8 weeks auto-filters most spikes. For per-window forensics, flag a zero-follower account share above 30% and a fork-to-star ratio below one-tenth of the organic baseline, and watch for account-creation dates clustered on the star date.

---

*From the Refolk guide library. I revise these guides rather than replacing them, so the current version is always at https://www.refolk.ai/guides/pre-raise-repo-momentum-pipeline*