Refolk
FrameworkEngineering and open source

Scoring Maintainer Concentration Risk Before You Depend on a Repo

You can score any repository's maintainer concentration risk from public history and reach one of three verdicts, with the number that justifies it.

14 min readLast reviewed August 9, 2026Read as Markdown

You are about to add a dependency, and one question decides whether that is safe: does this project die if one or two people walk away? This guide is for engineering managers, technical founders, and technical diligence readers who need to turn that question into a repeatable score from public commit history, review activity, and release cadence. It delivers a scoring model that ends in one of three verdicts - safe to depend on, depend with a named mitigation, or avoid - each backed by the number that justifies it.

The dependency adoption standard already tells you when a library is fit to add, and the repository reference already defines what each signal proves. Neither turns the human question into a score. This guide is the one dimension both skip.

What maintainer concentration risk is, and why last-commit-date misses it

Maintainer concentration risk is the chance that a project stops being maintained because too few people carry it. The measure of that risk is the bus factor, now formally the CHAOSS Contributor Absence Factor: the smallest number of contributors responsible for 50% of total contributions. A factor of 1 means one person's departure orphans the project.

Generic "is this dead?" checklists stop at the last commit date. That proxy has broken. Auto-merged bot pull requests keep a departed maintainer showing as the merge author, so a cadence check now reports "alive" for a project no human is steering. The metric reports the same number for one engaged maintainer and one departed maintainer whose token still works. Concentration risk is a different axis from liveness, and you need both.

The uncomfortable baseline is how normal concentration is. In the foundational study of 133 popular GitHub applications, 65% have a truck factor of two or less, and within that corpus 46% sit at exactly 1 and 28% at exactly 2. A later validation oracle of 35 well-known systems found 57.1% at a factor of 1 and 14.3% at 2, with only two systems above 10: saltstack/salt at 11 and symfony/symfony at 15. A recomputation over the top-starred repositories reached the same 65%.

65%
Popular GitHub projects with a truck factor of two or less
Across 133 popular applications; nearly half sit at exactly one contributor covering half of all work.

The lesson is that a low factor cannot by itself be disqualifying. An "avoid everything with bus factor 2" rule rejects most of the ecosystem. The score must weight replaceability and cadence, not the raw number alone.

The concentration distribution: what "normal" actually looks like

Before you score a single repo, calibrate against what the literature found, so a factor of 1 or 2 reads as common rather than alarming. The table below aligns three independent studies on the same measure. Read it as your reference distribution.

Study (corpus)Factor = 1Factor <= 2High-factor tail
Avelino 2016 (133 popular apps)46%65%under 10% above 6
Ferreira oracle (35 systems)57.1%71.4%2 systems above 10
Metabase 2022 (top-1000 starred)not reported65%10% at 6 or more

Three studies, three corpora, one shape: most projects are carried by one or two people, and the high-factor tail is thin. When your own number lands at 1 or 2, you are in the majority, not the outlier. That is why the danger threshold of 1 or 2 is a trigger to investigate, never an automatic verdict. CHAOSS puts the mechanism plainly: with an absence factor of 1, burnout or other factors could mean the sole contributor stops maintaining the project.

The signals to compute, and what each proves

There is no single number. You compute a small family and reconcile them, because each catches a failure the others miss. Here is what each proves and what it looks like when it lies.

  • Contributor Absence Factor (pony factor). Counts the smallest set of contributors covering more than 50% of contributions, all time. Proves how concentrated the workload is. It lies when bots inflate contribution counts, making a departed maintainer look present.
  • File-ownership truck factor (degree of authorship). For each file, finds the single contributor who wrote the most lines, then simulates removing owners in order until 50% of files are orphaned. Proves who holds the code knowledge. It lies less than commit counts, which is why you run it as the cross-check.
  • Elephant factor. Applies the same 50%-share calculation over employer affiliations. Proves organizational concentration. It lies when five contributors all work for one vendor and the individual factor reads 5 while the real risk is 1.
  • Scorecard Maintained check. Highest score requires at least one commit per week over the previous 90 days; archived scores lowest. Proves liveness. It lies when bot commits carry the cadence.

The reconciliation step is where most reads go wrong. Someone with many trivial commits looks like a co-maintainer but owns no files. The commit-count lens counts them; the file-ownership lens does not. When the two numbers split, the file-ownership number is usually closer to the truth about who the project cannot survive losing.

The four lenses, outermost first

  1. Liveness (Scorecard Maintained)
    Is anyone, human or bot, still committing?
  2. Contribution share (pony factor)
    How few people do more than half the work?
  3. File ownership (truck factor)
    Who actually holds the code knowledge?
  4. Employer clustering (elephant factor)
    Do the owners all answer to one company?
Each layer catches a failure the layer below cannot see.

How to score a repository, step by step

Score in a fixed order so two analysts reach the same verdict. The academic literature leads with authorship concentration; activity-first checklists lead with cadence. This procedure leads with concentration and treats cadence as the liveness gate, because concentration is the durable property and cadence is the one bots can fake.

The eight-step concentration score

  1. Scope the unit of analysis
    Decide whether you score the repo, the package, or the whole dependency tree, and pin the canonical repo URL. Know which files you actually depend on.
  2. Compute the concentration number
    Run a truck or bus-factor tool, or the CHAOSS Contributor Absence Factor: sum each contributor's contributions in decreasing order until you cross 50%. Record the integer and the named people behind it.
  3. Cross-check with a second lens
    Compute the file-ownership truck factor and the pony factor separately from raw commit count. Get two independent numbers that agree, or a documented reason they diverge.
  4. Score cadence and liveness
    Apply the Scorecard Maintained rule and check release history. Label the project maintained, borderline, or stale.
  5. Run the feature-complete override
    Test whether the project is small and stable and whether maintainers still answer issues and security reports before penalizing low activity.
  6. Attribute the humans
    Identify who the 50%-share contributors are, their employer affiliation, and whether they are active elsewhere but absent here. Produce a named list with current activity.
  7. Assess replaceability
    Estimate whether you could hire, fund, or fork if the key people left, using the size of the relevant contributor talent pool. Name and cost a mitigation, or rule it out.
  8. Assign the verdict
    Choose safe, depend-with-mitigation, or avoid, and cite the concentration figure that justifies it.

Steps 1 through 5 are analyst work, roughly two hours. Steps 6 through 8 pull in the engineering manager or founder who owns the adoption decision, because replaceability and verdict are judgement calls about your own team and budget, not properties of the repo.

Attributing the humans: who are the fifty-percent contributors

The score is a number; the mitigation is people. Once you have the concentration factor, you have to name the individuals it points to and find out where they are. Step 6 is where a filed metric becomes a decision you can act on, and it is the step most desks skip.

You need three things about each 50%-share contributor: who they are, who employs them, and whether they are active elsewhere but absent here. The employer question feeds the elephant factor directly - if the top contributors all draw a paycheck from one vendor, your real exposure is that vendor's roadmap, not the count of names. The elsewhere-but-absent question is your early warning: a maintainer still shipping on other projects while going quiet on yours is drifting, and the drift precedes abandonment.

This is contributor sourcing, and it is slow by hand: cross-referencing commit emails against public profiles, checking current employers, and confirming who is still active. Refolk collapses that into one query. Instead of manually reconstructing a maintainer's current footprint, you ask in plain English and get the person, their employer, and their recent activity across the public GitHub graph, LinkedIn, and the open web.

The output of step 6 is a named list with current activity. That list is the raw material for step 7, because you cannot cost a mitigation you cannot name.

Replaceability decides the verdict, and it is geographic

A low factor is only fatal if you cannot replace the person. Replaceability is the load-bearing variable, and the sobering statistic is the recovery rate: only 41% of projects fully recovered their maintenance activity after losing their truck-factor developers. "It's open source, someone will fork it" is wrong more than half the time. The mechanism is that forking requires re-accumulating the file-level knowledge that the file-ownership metric already told you was concentrated in the person who left.

So replaceability is not a hope; it is a costed plan. It has three forms, ranked by cost: fork and staff it yourself, fund the existing maintainer, or hire a replacement from the open market. Whether the last one is real depends on the talent pool for that skill, and the pool is lopsided.

MarketProfiles with maintainer titlesShare of the two-country total
United States1,41296.8%
Germany473.2%
US-to-Germany ratio30.0x-

In Refolk's index, the United States returns 1,412 profiles whose title includes maintainer or core-maintainer variants, against 47 in Germany - a 30x gap. The same fork-and-hire mitigation that is credible in the Bay Area is far thinner in Berlin, where that German pool concentrates. Top US employers for that pool include Akuity, Okta, and Svix, which tells you where the hire-able people actually work. The practical consequence: for a US-centric skill you can plausibly cost a hire; for a niche or non-US ecosystem, forking and staffing internally may be your only real option, and you should say so in the verdict.

The verdict matrix

Easy to replace (deep pool, forkable)Hard to replace (thin pool, deep file ownership)
Safe
Depend freely; note the factor and move on.
Depend with mitigation
Fund or fork-ready; name and cost the plan.
Watch
Low concentration but a thin pool; monitor for drift.
Avoid
High concentration and no credible replacement; do not build a load-bearing dependency here.
Low concentration (factor 3+)High concentration (factor 1-2)
Concentration on one axis, replaceability on the other, decides which of the three verdicts applies.
41%
Projects that fully recovered maintenance after losing key developers
Computed across roughly 2,000 repositories; the majority did not recover, which is why forking must be planned, not assumed.

How this goes wrong: the failure modes

Most bad scores come from trusting one signal that lied. These are the seven ways the read fails, each with the check that catches it. Treat this section as the one you reread before you sign off.

  • Bot-inflated cadence. A repo scores maintained because Dependabot commits weekly. The metric reports the same number for an engaged maintainer and a departed one whose token still works. Check: filter bot and auto-merge authors before counting.
  • Commit-count versus file-ownership disagreement. Many trivial commits make someone look like a co-maintainer who owns no files. Check: compute the file-ownership truck factor alongside the pony factor and reconcile them.
  • Feature-complete false positive. A stable utility gets an "avoid" for low activity. A library that determines if an integer is even does not normally need maintenance. Check: apply the feature-complete override and test issue and security responsiveness before penalizing.
  • Elephant-factor blind spot. Five contributors all work for one vendor; the factor looks like 5, the real risk is 1. Check: cluster contributors by employer.
  • Fork illusion. High fork count is read as community resilience, but most forks are dead clones. Check: confirm forks have divergent, recent commits, not just clones.
  • Recovery optimism. Assuming a popular abandoned project attracts a rescuer, when only 41% recover. Check: require a named, costed mitigation, not "someone will fork it."
  • Social-engineering inversion. A new co-maintainer relieving a burned-out solo owner reads as an improved bus factor but was the exact XZ attack vector. Check: verify the identity, tenure, and review history of newly added maintainers.

The XZ case is worth holding in view because it inverts the whole model. The threat actor began contributing almost two years before the payload, slowly building credibility until they were handed maintainer responsibility. The first backdoor commit landed on 22 January 2024, version 5.6.0 shipped on 24 February, and Andres Freund disclosed it on 29 March. Distributions reverted within 24 hours. The metric said the project got safer at the moment it got fatally compromised.

A rising bus factor is a signal to verify a new maintainer, not a reason to relax.

The other landmark, Heartbleed, is the resourcing failure the model is meant to catch upstream. OpenSSL ran on roughly two-thirds of SSL sites while receiving about $2,000 a year in donations. After disclosure the foundation took in nearly $9,000, and the Core Infrastructure Initiative then funded two full-time developers and a security audit. The concentration was structural and visible in advance; nobody was scoring for it.

IncidentIntroducedPublic disclosureMitigation window
XZ Utils (CVE-2024-3094)22 Jan 2024 (commit)29 Mar 2024under 24h distro revert
Heartbleed (OpenSSL)2011 (two-year-old bug)Apr 2014funding within about a month

Both incidents share a root cause the concentration score is built to surface: a load-bearing dependency carried by too few, too tired, too unfunded people.

The sign-off checklist and keeping the score current

A verdict is done when every item below is true. Run this before you record safe, depend-with-mitigation, or avoid.

Before you record the verdict

  • Bot and auto-merge authors are filtered out of the contribution count.
  • The pony factor and the file-ownership truck factor are both computed and reconciled.
  • Contributors are clustered by employer and the elephant factor is checked.
  • The Scorecard Maintained label is set, and release history confirms or contradicts it.
  • The feature-complete override has been run: issue and security responsiveness tested.
  • The 50%-share contributors are named, with current employer and activity.
  • A replacement mitigation is named and costed against the real talent pool, or explicitly ruled out.
  • Any newly added maintainer has had identity, tenure, and review history verified.
  • The one-line verdict cites the concentration figure that justifies it.

The score decays, so treat it as a living record, not a one-time gate. Two things move: cadence and people. Re-run the Scorecard Maintained check on your own schedule - it is only valid for projects older than 90 days and measures the trailing 90-day window, so a quarterly recheck matches its native resolution. Re-attribute the humans whenever a release slips or an issue thread goes unanswered, because a maintainer active elsewhere but silent here is your earliest drift signal. When a new co-maintainer appears, do not update the factor upward until you have verified them; the XZ pattern is that the addition looks like good news the moment before it becomes the incident.

Keep one artifact per dependency: the factor, the named contributors, the mitigation, and the date you last checked. That record is what turns a one-off read into a standard your team can rely on, and it is what lets you answer the only question that matters when a maintainer walks away - "do we already have a plan?" - with a yes.

Questions practitioners ask

How do I calculate bus factor on a GitHub repo?

Sort every contributor by contribution, then add them up from the top until you cross 50% of total contributions; the count of people needed to reach that threshold is your factor. This is the CHAOSS Contributor Absence Factor, formerly called bus factor. For a stronger read, also compute a file-ownership truck factor using degree of authorship, which measures who actually owns the code rather than who commits most often. Reconcile the two numbers before trusting either.

Is a bus factor of 2 automatically a reason to avoid a project?

No. Across 133 popular GitHub applications, 65% have a truck factor of two or less, so a strict avoid-everything-with-factor-2 rule would reject most of the ecosystem. A low factor is a flag to investigate replaceability and cadence, not a verdict on its own. The verdict comes from combining the factor with whether the project is still maintained and whether you could realistically fork or hire if the key people left.

How do I tell an abandoned project from one that is simply feature-complete?

Run the feature-complete override before penalizing low activity. Test whether the project is small and stable, like a utility that determines if an integer is even, and whether maintainers still respond to issues and security reports. No commits in 12 or more months is a strong signal but not definitive; combine it with issue and pull-request responsiveness. Silent absence, where a maintainer is nominally active but practically absent, is the hardest case and needs the responsiveness check.

Why can adding a maintainer make a project less safe?

Because event-counting metrics reward the exact move that caused the XZ Utils backdoor. A hostile contributor spent nearly two years building credibility, was handed maintainer rights to relieve a burned-out solo owner, and planted CVE-2024-3094 at CVSS 10.0. The measured bus factor improved at that moment while real safety collapsed. Always verify the identity, tenure, and review history of a newly added maintainer rather than treating the addition as automatic risk reduction.

Does high fork count mean a project will survive its maintainers leaving?

Not reliably. Most forks are dead clones, and only 41% of projects fully recovered maintenance activity after losing their key developers. Forking requires re-accumulating the file-level knowledge that was concentrated in the departed person, which is precisely what a low file-ownership truck factor tells you is missing. Confirm that forks have divergent, recent commits before counting them as resilience, and require a named, costed mitigation rather than assuming a rescuer appears.

Try it on your own search

Stop building boolean strings. Just describe the person.

Type one sentence and I plan the search, read GitHub, public LinkedIn and Crunchbase records, and the open web live, then hand back a ranked shortlist with the reasoning behind every name. No filters to learn, no export to clean up, no sales call to sit through.

  • One sentence in, a ranked shortlist out. No boolean, no filters, no seat to buy.
  • Read live at search time, not from a database that went stale last quarter.
  • Watch every step as it runs, and see why each name made the list.

500 free credits on sign-up. No card, no demo call. See real searches.

Read next