Lab

Lead scorer with product-usage signals

Every account gets a score from ICP fit and live product-usage signals, and every point traces to a rule. Accounts above the threshold go to one of three sequences: upgrade for heavy self-hosted users, integrator for teams building with the code, evaluator for the rest.

Adjust inputs ↓

Ranked accounts

50 accounts, scored live

ICP fit (0–15) plus capped signal points.

–Tier B
–Tier C
–No outreach
Sort by
Select an account to see its breakdown.
# Account Tier Branch ICP Signal Total

Why this score

Select an account

–ICP fit
–Signal
ICP dimensionSignalRemoved by cap
Every point and the rule that produced it.
ComponentRule that firedPoints
–

First touch

Checked before it sends

Template draft. In production an LLM writes it and the gate below decides whether it sends. The template only uses signals that fired for this account. Edit it and the gate re-runs.

–
    How it works
    Method
    Rule-based ICP + weighted signal score, tier and branch routing, deterministic copy gate, L2 logistic regression for re-weighting.
    Built from
    A port of the scoring model from a GTM engine I built for an open-source, usage-based billing product with a developer-led funnel.
    Data
    Synthetic, generated from a seeded model. Account names are fictional. Not client data.

    The model

    Two layers. ICP fit is five firmographic dimensions scored 0–3 each: billing complexity, company scale, funding and growth, headcount, technical fit. Max 15. Signal score is a weighted sum of ten intent signals, capped at 15. The product PQL signal is itself a composite of five usage triggers (invoice volume, plan and metric count, team seats, failed payments, months self-hosted), so it scales with how hard the account is hitting the free tier.

    Total out of 30 sets the tier: A at 20, B at 12, C at 7, below that no outreach. Signal source sets the branch, whatever the score: confirmed product PQL routes to the upgrade sequence, any fork or Python client install routes to the integrator sequence, everything else gets the evaluator sequence.

    The build's README describes a sixth ICP dimension, "intent", for a total of 33. The code that ran dropped it, because intent was already counted in the signal layer. This page ports the code.

    The copy gate ports the build's rule-gate checks: body at most 75 words, subject at most 8, a banned-vocabulary regex, company named in the body, a real signal cited, no weak opener, ends on a single question. One check is added here: the draft may not claim a signal that did not fire.

    The history set's outcomes come from a hidden logistic model. It differs from the hand-set weights in three ways: some signals matter more than their weight says, a star barely matters, and fresh signals count more than old ones. That is why the learned model and a non-zero half-life can both beat the source weights.

    In production

    Signals come from the GitHub, PyPI, Docker Hub and job-board APIs, a website visitor-identification tool and product telemetry, landed in the warehouse and deduplicated daily against inbound. Scoring runs in a stdlib-only Python module so it can sit in any scheduler. An LLM drafts the first touch from the account's fired signals; the deterministic gate decides whether it sends, and a failed draft gets one retry before going to a human. Closed-won and closed-lost outcomes feed back into the weights on a schedule. More on GitHub.

    Limits

    • Signal coverage is partial. Private forks, internal mirrors and pulls behind a proxy don't show up, so some active users score as cold.
    • Cold start. Learned weights need a few hundred closed outcomes before they beat hand-set ones; until then the rules carry the model.
    • A signal means different things for different personas. An engineer forking the repo may not be the buyer, and a finance lead may never touch GitHub.
    • The gate checks form, and checks claims only against the signal table. It can't tell if a claim about the prospect's stack is accurate.