There is a structural decision at the center of how we build, and it is easy to get wrong because the wrong version is so tempting. The question is: where in the system does the verdict get rendered? Where does “we have computed some things about this company” turn into “this company has a problem”?

Our answer is that the verdict does not live in the computational engine at all. The engine produces leads. Judgment lives elsewhere, and it is calibrated by something the engine does not have: real-world outcomes.

The temptation to put the verdict in the math #

When you build a feature engine — a system that computes many quantities about a company across many dimensions — the natural instinct is to keep going. You have all these signals; surely the engine should combine them, weight them, apply some thresholds, and output a conclusion. Bake the decision logic right in. It feels efficient.

We’ve come to see this as a category error. A feature engine is good at one thing: computing features. The moment you embed thresholds and verdicts inside it, you have quietly asserted that you already know how much each feature should count — that you can set the weights by hand, in advance, from intuition. But you don’t know that, and intuition is exactly the wrong instrument. The whole reason to build a learning system is that the relationship between signals and outcomes is something you have to discover from data, not something you can declare.

There is a specific way this goes wrong that we’re especially wary of. If you hand-tune a combination of signals to match a set of historical problem cases, you will almost always find that the signals which dominate your formula are the ones most correlated with your labels — and those are frequently proxies for distress, size, or survivorship rather than for the thing you actually care about. A more “accurate” distress detector, fit this way, doesn’t make you better at finding fraud. It makes you better at finding companies that were already visibly in trouble, while doing collateral damage to anything that looks superficially similar. The verdict logic absorbs the biases of the labels, and you’ve encoded those biases as if they were knowledge.

Engine produces leads; outcomes confer judgment #

So we draw a clean line. The engine is a pure feature factory. Each of its components computes its own class of signals across its own dimension, and the output of the whole engine is a set of leads — companies surfaced because something about them is worth examining. A lead is not a verdict. It carries no claim that a problem exists. It is an input to judgment, not the judgment itself.

The judgment happens downstream, and crucially, it is meant to be learned from outcomes rather than declared by hand. The weight any given signal should carry is not something we set from intuition; it is something to be estimated from what actually happens to the companies the system surfaces. This is the difference between a system that encodes its builders’ priors and a system that updates on reality. Our intent is that the parameters governing judgment — how much each kind of signal should move the needle — are fit from observed outcomes, not from a hand-written formula of multiplied likelihood ratios.

We’re candid that this is a system whose most valuable part matures over time. In the early phase, before a meaningful history of outcomes has accumulated, the honest thing to do is build the feature factory thoroughly — produce every signal completely and accurately — and defer the learned judgment until there is real outcome data to learn from. We resist the urge to fill that gap with hand-tuned verdict logic, because hand-tuned verdict logic is precisely the thing that bakes in the biases we’re trying to avoid. An empty judgment layer waiting for real data is better than a confident one built on guesses.

Why the separation is the moat #

This is not only a correctness argument; it is a strategic one. Anyone can compute features. Public filings are public; the raw signals are available to anyone willing to build the extractors. What is not available to anyone is a growing record of which surfaced companies turned out to matter and which didn’t — and a judgment layer that has been continuously calibrated against that record.

The feature factory is the commodity. The accumulated outcomes, and the judgment they progressively teach, are the thing that compounds. By keeping the verdict out of the engine and anchoring it in outcomes, we put the durable value in the place that gets better with time rather than in the place that anyone can replicate. The engine surfaces leads. Experience — real, observed, accumulated experience — is what turns a lead into a judgment. And experience is the one thing that cannot be copied.