Refolk
TeardownEngineering and open source

The Upstream-Contributor Bid Teardown: Two Claims to One Verified Record

Turn each bidder's top-contributor claim into a dated table of current approvers, current-staff share of 12 months of substantive work, and discounted residue.

22 min readLast reviewed November 21, 2026Read as Markdown

Key takeaways

  • The kubernetes/kops OWNERS file lists 9 emeritus approvers alongside 5 current ones, so a vendor counting "approvers we have had" can draw on 14 names when only 5 hold rights today.
  • In Refolk's index, only 4 of 11 US profiles that describe themselves as open source maintainers have "Maintainer" in their current title, so profiles cannot confirm rights and OWNERS files can.
  • gitdm affiliations are imported into DevStats about once every 4 weeks and change only when someone files a pull request, so departures are under-recorded and every open-ended "from" line needs a profile check.
  • A GitHub CODEOWNERS entry only routes review requests. It gates merges only when "Require review from Code Owners" is on, and by default admins can bypass branch protection.
  • No public standard sets a lines-changed threshold for a substantive change, so log every removed item with a reason: bots, go.mod and go.sum bumps, metadata fixes, retests, and docs-only diffs.
  • Rank bids on current rights first and volume second. Code-owner approval needs only one owner, so one current approver in a subsystem you depend on outweighs a bigger commit share.

This guide covers the moment two support or services firms bid to run an open-source project you depend on, both say they are top upstream contributors, and you have to sign with one of them. It is written for engineering managers, technical founders, developer-relations leads, and technical sourcers. It carries one worked comparison from the raw claims to a dated, cited table that shows which claim survives the commit, review, and maintainer record.

What does a "top upstream contributor" claim have to prove?

A contributor claim holds up only if it proves three things as of a stated date. First, how many current employees hold merge or approver rights. Second, what share of the last 12 months of substantive changes current staff authored or reviewed. Third, how much of the headline figure rests on departed people, trivial changes, or farmed credit. A claim that cannot be broken into those three numbers is a brochure.

Procurement guidance points the right way but stops before the arithmetic:

  • The Drupal Association's RFP guide recommends weighted scoring that includes community contributions.
  • The EU Open Source Observatory lists vendor contributions to open source projects as an evaluation criterion.
  • The Open Source Initiative notes that public authorities don't necessarily know which suppliers are actively contributing.

None of the three says what form the evidence should take or how to compute it. That gap is why bids get compared on leaderboard screenshots, and leaderboard screenshots come from the outer layer of the record.

The layers inside a contributor claim

  1. Leaderboard volume
    Every commit, review, and credit ever attributed to the company
  2. Ever-affiliated people
    Anyone gitdm or the vendor has ever tied to the company
  3. Current staff
    People whose until date has not passed and whose profile agrees
  4. Substantive current work
    Last 12 months, with bots, bumps, and trivial edits removed
  5. Current rights
    Approvers and enforced code owners on the default branch today
Each layer is a subset of the one above it, and vendors usually quote the outermost layer while your contract depends on the innermost one.

Sources disagree on this order. The CHAOSS metrics sequence, as summarized in Refolk's elephant-factor guide, runs Elephant Factor, then Organizational Diversity, then Organizational Influence, which puts volume before rights. The Elephant Factor is the minimum number of companies whose employees perform 50% of the commits. That order makes sense when you are measuring a project's health. It is the wrong order for choosing a vendor, because you are buying the ability to get a fix merged, and only rights give you that.

The worked example: two bids for one Kubernetes dependency

The example is a platform team that depends on kops, the Kubernetes cluster-provisioning tool, and has two support bids on the table. Bid A is the larger firm. It points to its standing on the project's company activity view and lists "approvers we've had." Bid B is smaller. It names fewer people but says it employs maintainers. Neither bid states an evaluation date.

I don't put numbers in the bidders' mouths. The vendor-specific counts are slots you fill from your own bids. Every public number below comes from the project's own files or from Refolk's index, and those are the numbers that set the limits of what either bid can truthfully claim.

The ceiling arithmetic

Before you open either bid, read the project's rights file. As indexed on 2026-11-21, the kops OWNERS file lists 5 approvers and 9 emeritus approvers. That fixes two limits:

  • Current approver seats across both bids combined: at most 5. If the two bids together claim more than 5 current kops approvers, at least one of them is counting history.
  • Names an "approvers we've had" list can draw on: 14. That is the 5 current approvers plus the 9 emeritus ones, nearly three times the seats that can actually approve code.

Bid A's phrasing, "approvers we've had," already tells you which pool it drew from. This is the first fork in the comparison: accept the phrase and Bid A leads before any work is checked.

Getting the claim into a usable form

Both bids arrived as totals. Totals can't be verified, so the first move is to send both firms the same request.

Contributor-claim request for bidders
Subject: Upstream contribution evidence for the kops support bid

To score the upstream-contribution criterion, please list every person your bid relies on. For each person, give:

1. Full name and GitHub handle (and Drupal.org handle if relevant)
2. Current role in the project: approver, reviewer, emeritus, or none
3. Start date with your firm, and end date if they have left
4. Up to five links to changes they authored or reviewed in the last 12 months
5. Whether any of those changes involved AI-generated content, and if so where it was disclosed

We will check each entry against the project's OWNERS and CODEOWNERS files, the public affiliation records, and public professional profiles, as of an evaluation date we will share with you. Entries we cannot verify will score zero.

Replace the project name and dates; send the identical text to every bidder so the answers are comparable.

If the project is Drupal-based, the claim usually arrives as credits. One published agency RFP answer reads "256 organization contribution credits with 29 team members on Drupal.org." That is the same kind of claim in a different currency, and the same three questions apply: how many of the 29 are still employed, how many of the 256 credits fall inside the last 12 months, and how many are metadata edits or retests.

The procedure, step by step

The procedure runs in eight steps. The first four gather the record, the next three cut it down, and the last one builds the table. No source documents how long each step takes. My desk estimates are about an hour for step 1 and one to two hours each for steps 2 and 3. These are estimates, not measurements, but the whole run fits in an afternoon for a project the size of kops.

From two claims to one verified record

  1. Get each claim in writing as named handles
    Ask each bidder to list the people behind its claim, with GitHub or Drupal.org handles. Done when both claims are lists of people, not totals.
  2. Pull the current-rights roster
    Read the OWNERS approvers and reviewers on the default branch (not emeritus), CODEOWNERS on the base branch, and the branch protection setting. Done when each handle is marked current, emeritus, or absent.
  3. Resolve dated affiliation per handle
    Look up each handle's gitdm from and until lines and check them against the person's public profile. Done when each person has a dated employer or a missing flag.
  4. Pull 12 months of authored and reviewed changes
    Use DevStats and the GitHub API to pull each handle's authored and reviewed changes. Done when there is a raw count for each person.
  5. Cut bots, dependency bumps, and trivial changes
    Remove bot output, go.mod and go.sum bumps, metadata, retests, and docs-only diffs. Done when every removed item is listed with a reason.
  6. Cut departed staff by the until date
    Remove work by anyone whose until date falls before the evaluation date. Done when each bid has a current-staff share.
  7. Check for farmed credit
    Look for undisclosed AI, bulk low-effort issues, and Drupal Association sanctions. Done when each flagged item has a link.
  8. Build the dated table and decide
    Fill one row per bid with rights, share, and residue, each sourced and dated. Rank on rights first, then share.

Assign the steps by skill. The buyer owns step 1, an engineer owns steps 2 and 4, and a sourcer owns step 3. Steps 5 to 7 go faster when the engineer and the sourcer work through them together, because each cut needs both the code record and the employment record.

Cut one: who holds merge or approver rights today?

Rights holders are the names under the approvers key of OWNERS on the default branch, plus CODEOWNERS entries on the base branch when branch protection requires code-owner review. Names under emeritus_approvers don't count. The Kubernetes OWNERS spec defines them as people previously in the approvers section who no longer actively approve code.

My first pass made the obvious mistake: it counted every handle in the kops OWNERS file and got 14. The real figure is 5. The gap varies a lot from repo to repo, which is why you read the file for your own dependency instead of assuming a ratio.

RepoApproversEmeritusEmeritus per current
kubernetes/kops591.8
kubernetes/test-infra591.8
kubernetes/kubeadm561.2
kubernetes/utils540.8
kubernetes staging610.17

Source: the raw OWNERS files, as indexed 2026-11-21. The ratio column is derived. When the ratio is high, a historical claim inflates the most. In kops and test-infra, a vendor counting everyone it has ever had in the file can nearly triple its apparent rights.

The staging OWNERS file teaches a second lesson. It routes go.mod and go.sum changes to a separate dep-approvers group. Dependency-file changes follow their own approval path, so a vendor's count of "approved changes" may be padded with dependency bumps. Note those paths now, because you will cut them in step 5.

CODEOWNERS routes reviews but does not enforce them

On GitHub, a CODEOWNERS entry only routes review requests. It becomes a merge gate only when three conditions hold:

  • The CODEOWNERS file is on the pull request's base branch.
  • The "Require review from Code Owners" option is on in branch protection or a ruleset.
  • Nobody with admin rights is bypassing it. By default, admins can bypass branch protection rules.

When code-owner review is required, approval from any one of the listed owners is enough. That single fact is what flips rankings. A vendor with one owner per subsystem you depend on can get your fixes merged. A vendor with ten times the commits and no owner seat has to wait in someone else's queue.

Rights against current work

High current-staff substantive shareLow current-staff substantive share
Volume without a gate
They can write the fix but not merge it; price in review wait time
Rights and work
Strongest bid; check the residue and sign
Brochure
The claim rests on history; demand evidence or disqualify
Gatekeeper, light output
They can merge fixes; check capacity and that the rights are enforced
Few current approver seatsMany current approver seats
A bid's position comes from current approver seats in the subsystems you depend on and its share of substantive 12-month work, and only the top-right quadrant earns an unconditional yes.

In this comparison, the first fork happens here. Bid A's "approvers we've had" list can't exceed the 14 names in the file, and its current seats can't exceed 5. Bid B's narrower claim names current approvers, which you can check line by line against the 5. The ranking flips at this cut, and you should expect it to flip at this cut on your own bid. That is why rights come first.

Cut two: is the person still employed by the bidder?

A person's work counts for a vendor only if the change date falls inside that person's gitdm from and until range for the vendor, and a public professional profile agrees. gitdm entries lag real job changes, so neither source is enough alone.

The CNCF gitdm files list each developer's employers in sequence, each with dates. One real entry reads: "Tetrate.io until 2024-05-31 / Independent from 2024-05-31 until 2024-06-03". Five mechanics shape how much you can trust them:

  • Corrections are pull requests. The project asks people to "submit a pull request with edits to developers affiliations files." The examples I found are self-filed, such as PR #1274, where a contributor updated his own employment history.
  • Imports run about once every 4 weeks. New affiliations reach DevStats on that cycle, on top of however long it took someone to file the PR. Nobody has published how far entries actually lag real job changes. The documented minimum is the 4-week cycle.
  • Entries are split across numbered files, and contributors pick a file by the alphabetical order of their GitHub username. Search all of them before you mark a handle missing.
  • Email matters. CNCF needs both current and historical email addresses, because the data is processed from GitHub Archives, which saves events every hour.
  • Unaffiliated contributors count toward no company. A handle with no gitdm entry adds nothing to any vendor's total.

The last point cuts against the smaller bid. Bid B's people are more likely to be missing from gitdm entirely, which makes Bid B look smaller on any company leaderboard. Look up every claimed handle by hand, in both directions.

Wrong turn: trusting an open-ended "from" line

The second mistake in the first pass was reading an open-ended from line as "still employed." A departed person has little reason to close their old entry, so expect stale affiliations to prop up the larger, older vendor. Treat every open-ended line as unconfirmed until a public profile shows the same current employer.

Tagging one change to one employer

  1. Take the change date
    Use the author date and record that choice
  2. Match the gitdm range
    Find the handle's from and until lines across all numbered files
  3. Cross-check the profile
    Compare against the person's current public employer and start date
  4. Flag the conflicts
    Open-ended lines with a different profile employer become departures
  5. Tag or drop
    Credit the vendor only when both records agree on that date
A change counts for a vendor only after its date falls inside a gitdm range that a public profile confirms.

Which date applies is not established

Nobody has published whether DevStats applies gitdm ranges to the author date, the commit date, or the merge date. Git keeps the author date and the committer date separately, and --amend updates the committer date but keeps the author date. I use the author date because it marks when the work was done, and I write that choice into the table. To check how your dashboard behaves, find someone whose range ends mid-month, compare their dashboard attribution around that date with the raw commits, and see which date the boundary follows.

Wrong turn: confirming maintainership from profile titles

The third mistake was treating a profile title as proof of rights. Refolk's index shows how weak that signal is.

4 of 11
US self-described open source maintainers whose current title contains "Maintainer"
In Refolk's index of professional profiles, most people who describe themselves as maintainers do not carry the title, so only OWNERS files can confirm rights.
Query in Refolk's indexTotal profilesTitle contains "Maintainer"
US, maintainer titles + keyword114 (36%)
Germany, same query10
Global, keyword "kubernetes maintainer"139not broken out

Profiles are good for the other half of the check, which is where the person works now. In a sample of 25 of the 139 "kubernetes maintainer" profiles, the employers break down like this:

EmployerCountShare of sample
Broadcom416%
Harness312%
Google28%
CNCF28%
SUSE14%

Source: Refolk's index, sample of 25. Shares are derived. Eleven of the 25 were located in India, five of them in Bengaluru. Two warnings come out of this table. Foundations such as CNCF appear as employers, so a person can be a maintainer whose employer is neither bidder. And a self-described "maintainer" at a firm does not mean the firm holds a seat in your repo.

Steps 2 and 3 meet here: you have handles from the OWNERS file and need dated employers for them. Doing that lookup by hand, one profile at a time, is the slowest part of the afternoon. Refolk takes the question in plain English and returns the people with their current employers, which turns the open-ended gitdm lines into a short list to check.

Cut three: trivial changes, bots, and farmed credit

No published standard sets a numeric threshold, such as lines changed, for a substantive change. Define substantive by what you remove, and list every removal with its reason so a vendor can dispute a specific line instead of the whole method.

What to remove, and why

RemoveWhy it is not substantive
Dependency bumps (go.mod, go.sum)Routed to dep-approvers; usually automated
Bot accounts such as DependabotNo human judgement in the change
Small metadata fixes, retestsDrupal core says these usually earn no credit
Small issue summary editsSame Drupal core policy
Docs-only diffsThey pad leaderboard volume

Drupal adds one more test worth borrowing for any project: an issue that existing automation can already resolve for the maintainer should not be opened as a contribution in the first place.

Bot filters miss agents

The CHAOSS Bot Activity metric catches Dependabot but not a coding agent posting through a personal access token. The NeoNephos foundation's open issue on standardizing the metric still lists "which commits to filter out" as an open acceptance criterion. Agent output under a personal account therefore counts as human work unless you look for it. Two signals help:

  • AI-disclosure lines in commit messages or PR descriptions. A disclosure is a good sign: it shows the vendor follows a policy. Undisclosed AI work is the problem.
  • Bursty timing. Many similar changes from one account in a short window. This can lie in both directions: a legitimate large refactor split into a stack of PRs looks bursty too, so open a few changes before you flag them.

Drupal credit and the incentive to farm it

Drupal's credit system rewards volume in a way that invites gaming. According to Dries Buytaert, an organization's visibility is determined solely by its contributions over the preceding twelve months, and some buyers, including Pfizer and the State of Georgia, only allow Makers to apply in vendor selection. The Drupal Association itself says some organizations will try to game the system with bulk superficial contributions, automation, or AI.

What it treats as abuse, and what it does about it:

  • Abuse includes undisclosed or unreviewed AI content and unauthorized bulk-posting with automated tools.
  • Organizations can lose marketplace position, partner status, or listing.
  • Individuals face temporary suspensions, then permanent bans. One documented ban is issue #3375893.
  • AI policy: "Saying 'the AI wrote it' is grounds for immediately closing the contribution."
  • A structural fix: the credit checkbox is no longer pre-checked for certain kinds of issue activity. The fact that the platform had to change this tells you the raw numbers needed correcting.

A credit only attaches to an organization that is tied to the contributor's Drupal.org profile as a current or past employer. "Past" is the important word: the link alone doesn't show the person still works there.

Where the ranking flipped, and how to decide

In this comparison the ranking flipped at the rights cut. The later cuts widened the gap instead of reversing it, because departed staff, dependency bumps, and stale affiliations all inflate the larger, older vendor's numbers more than the smaller one's. If the ranking flips again during the residue cuts on your own bid, open the removal log and look for a cut you applied to only one side.

Rights expire but authorship does not. That asymmetry decides most of these comparisons. A leaderboard keeps crediting people the project has already moved to emeritus, and a company total keeps crediting people the firm no longer employs.

Rights expire but authorship does not, so every leaderboard remembers people the project has already retired.

Decision rules

  1. Lead on current rights in the subsystems you depend on. Count approvers and enforced code owners, per subsystem, as of the evaluation date.
  2. Break ties on current-staff substantive share. This is the share of the last 12 months of substantive changes that current staff authored or reviewed.
  3. Read residue as a credibility signal, not a score. I don't set a numeric residue cutoff, because no source supports one. A bid whose headline rests mostly on departed people or excluded changes has shown you how it reports, and that should affect how much you trust the rest of its proposal.
  4. Disqualify on sanctions. A Drupal Association sanction or a closed-for-undisclosed-AI pattern on a named contributor removes that person from the bid.
Bid comparison table skeleton
Evaluation date: YYYY-MM-DD | Change date used: author date | Window: 12 months before evaluation date

| Bid | Current approvers (subsystems) | Enforced code owners | Current-staff substantive share | Residue: departed | Residue: trivial/bot | Residue: farmed | Sources |
|---|---|---|---|---|---|---|---|
| Bid A | | | | | | | |
| Bid B | | | | | | | |

Removal log (one line per removed item):
| Handle | Change link | Reason (bot / bump / metadata / docs / departed / farmed) | Evidence link |

One row per bid; every cell carries its source link and the date you read it.

How this goes wrong: failure modes and false positives

Every failure mode here credits a vendor with rights or work it does not currently have. Each one has a cheap check. Run all seven on both bids, because a check you run on only one side is itself a bias.

  1. Counting everyone who has ever appeared in OWNERS.
    • False positive: emeritus approvers counted as current rights holders. In kops that adds 9 names to the 5 real ones.
    • Check: count only the approvers key on the default branch.
  2. Treating CODEOWNERS as a merge gate.
    • False positive: the owner is listed, but "Require review from Code Owners" is off, or admins can bypass it.
    • Check: the branch protection or ruleset settings, and confirm the file is on the base branch.
  3. Trusting gitdm with no end date.
    • False positive: someone who left is still credited to the vendor because nobody filed a PR.
    • Check: compare open-ended from lines with the person's public profile and the dates their PRs were filed.
  4. Ignoring unaffiliated contributors.
    • False negative for the smaller bid: handles with no gitdm entry count toward no company, so a smaller vendor's numbers shrink.
    • Check: look up every claimed handle by hand.
  5. Drupal default attribution.
    • False positive: a departed employee's credits keep landing on the old employer, because attribution carries over to the next issue.
    • Check: compare the date of each credit with the person's employment dates.
  6. Bot filters that miss agents.
    • False positive: AI-agent output posted under a personal account counts as human work.
    • Check: AI-disclosure lines and bursty timing, then open a sample of the changes.
  7. Leaderboard volume.
    • False positive: dependency bumps and metadata edits pad the totals.
    • Check: remove dependency-file paths such as go.mod and go.sum, plus docs-only diffs.

Two quieter failures sit underneath these. The first is leaving the change date unstated, so the vendor and you argue about different windows. The second is letting the vendor's own comparison page set the categories. Vendor comparison pages are written by vendors, and the categories they pick tend to be the ones they win.

Keeping the record current after you sign

The table is a snapshot. Re-run the rights cut and the affiliation cut at every renewal, and whenever the OWNERS file for a subsystem you depend on changes. Rights move to emeritus and people change employers without anyone telling the buyer.

Write the evidence format into the contract. Require the vendor to keep its named-handle list current and to tell you when a named approver leaves the firm or moves to emeritus. Keep the removal log with the contract file, so next year's comparison starts from the same rules.

Re-check the time-sensitive mechanics, don't assume them. The import cadence is stated in the gitdm repositories, and the Drupal credit and AI policies live on their own documentation pages. Read them again each time you run this. For the employment half, a standing plain-English question in Refolk, such as which named approvers changed employer in the last 12 months, catches departures weeks before a gitdm pull request might.

Before you call the comparison done

  • Each bid is a list of named handles, not a total or a logo.
  • Every counted approver appears under the approvers key on the default branch, not under emeritus.
  • Every counted code owner sits in a CODEOWNERS file on the base branch with required code-owner review turned on.
  • Every counted person has a gitdm range and a public profile that agree on the current employer.
  • The change date used (author, commit, or merge) is written on the table.
  • Every removed change has a line in the removal log with a reason and a link.
  • Drupal credits are dated against each person's employment, and sanctions have been checked.
  • Both bids went through exactly the same cuts in the same order.
  • Every cell in the final table carries a source link and the date it was read.

Questions practitioners ask

How do I check if a company actually contributes upstream?

Check the people, not the company total. Get the bidder's named handles, confirm which of them are current approvers in the project's OWNERS or enforced CODEOWNERS, confirm they still work there using gitdm dates and a public profile, and count only their substantive changes from the last 12 months. A company leaderboard total mixes departed staff, bot output, and dependency bumps, so on its own it cannot tell you whether the firm contributes today.

Does the vendor employ the maintainers, and how do I prove it?

You prove it with two records that agree: the project's rights file and a dated employment record. A handle has to appear under the approvers key on the default branch, not under emeritus. That same person has to show the vendor as their current employer, both in gitdm with no until date that has passed and on a public professional profile. If the two disagree, treat the person as unconfirmed and ask the vendor for evidence.

Can I trust the CNCF DevStats company leaderboard for vendor evaluation?

Use it as a starting point, not a verdict. DevStats takes its company attribution from gitdm affiliation files, which change only when someone files a pull request and are imported about once every 4 weeks. Departures get under-recorded, and contributors without a gitdm entry count toward no company at all. The board also counts volume, not rights. Re-derive the per-person numbers yourself before they go into a contract decision.

How should an RFP ask for upstream contribution evidence?

Ask for a list of named people, not a total. For each person, require the project handle, current role in the project's OWNERS or CODEOWNERS, employment start date, and links to substantive changes from the last 12 months. Procurement guidance from the Drupal Association and the EU Open Source Observatory treats contribution as a scored criterion but does not specify the arithmetic, so put the arithmetic in your RFP yourself.

What counts as a substantive contribution versus a trivial one?

No published numeric threshold exists, so define substantive by what you exclude. Drupal core's credit policy says small metadata fixes, retesting patches, and small issue summary edits usually earn no credit. Add dependency bumps such as go.mod and go.sum changes, bot output, and docs-only diffs. Log every exclusion with a reason, so the vendor can contest a specific line instead of disputing the method.

How do I handle Drupal.org contribution credits in a bid?

Re-date them against employment. Drupal remembers a user's attributions as the default for their next issue, so a departed employee's credits can keep landing on the old employer. Organization visibility is based on the preceding twelve months of credits, which rewards volume, and the Drupal Association has documented bulk, automated, and AI gaming. Check each credit's date against the person's employment dates, and check for sanctions before you count it.

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.

  1. 01Describe them

    One plain sentence. Role, city, stack, stage, whatever matters to you.

  2. 02I read the web live

    GitHub, public LinkedIn and Crunchbase records, the open web. Not a database that went stale last quarter.

  3. 03You read the shortlist

    Ranked, with the reasoning under every name. Open a profile, ask a follow-up, narrow it down.

  • 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.

Read next