When you build a marketplace that connects two sides, manufacturers on one side and distributors on the other, the first instinct is often to reach for machine learning to rank matches. We went the other way. The core of Hell of a Partner is a deterministic scoring function, and that choice has paid off in ways I did not expect.

The shape

The whole matcher is one pure function:

scoreMatch(offer, profile) => {
  score: number,      // 0 to 100
  tier: "strong" | "fair" | "weak",
  rationale: Reason[] // one line per dimension
}

It scores a pair across seven weighted dimensions (category fit, country and trade bloc, certifications, capacity, and so on). Each dimension is a small scorer that returns a value from 0 to 1, then we take a weighted sum.

const MATCH_WEIGHTS = {
  category: 0.30,
  geography: 0.20,
  tradeBloc: 0.15,
  certifications: 0.15,
  // ...
}

Why deterministic beats a model here

It is explainable. Every score comes with a rationale, for example "category match, both in food and beverage" or "no shared trade bloc". A buyer sees why a supplier was suggested. With a black box ranker you get a number and a shrug.

It is testable. Our tests are plain scripts that assert invariants: same input, same output, every time. No flaky thresholds, no drift, no retraining. A pull request that changes a weight shows up as a clean diff in expected scores.

It is cheap and instant. No inference cost, no extra API latency, no cold start. The function runs inline with the request.

It works on day one. A learned ranker needs interaction data you do not have at launch. A scoring function encodes domain knowledge directly, so it is useful before you have a single click to learn from.

The tradeoff

The cost is that the domain knowledge lives in the weights, and you tune them by hand. That is fine while the rules stay legible and the team can reason about them. The day there is enough real interaction data, the deterministic scorer becomes a strong baseline and a source of features, not something to throw away.

Takeaway

Reach for the pure function first. Make the thing explainable, testable, and cheap, then add learning later when you have data and a baseline to beat.

If you want to see it in action, the matcher powers the supplier and distributor suggestions on Hell of a Partner.