We turned down 802 of 1,051 companies. Here is the SQL to read your own reject reasons

#sql #datascience #postgres #startup

Most lead lists record one thing about a company: that it is on the list. Nobody writes down why the others are not. The "no" pile is where the information is.

I'm the founder of SalesOne, which researches and qualifies B2B accounts before anyone reaches out. In our October 2026 production research runs, we checked 1,051 candidate companies against customers' ideal customer profiles, kept 249 and turned down 802. Every one of the 802 kept a reason. Counting those reasons told us more about list quality than the 249 we kept.

This post shows the counts, then the table and queries to do the same with your own pipeline.

What 802 reject reasons looked like

Reject reason	Share of 802
No qualifying dated event inside its window	67.1%
Size outside the profile's band	14.3%
Subsidiary, acquired, pending sale or another ownership rule	9.7%
Industry or segment mismatch	2.7%
Other reasons	3.9%
Duplicate, geography, exclusion list or too few buying roles, combined	2.3%

Three things stood out:

Timing dominated. Two in three companies fit on paper but had no recent event (a new executive, a new site, an acquisition) that made "now" a reasonable moment to reach out. These are not dead accounts. They are "not yet" accounts.
Industry filters already work. Only 2.7% failed on industry, because the searches were built from the profile's industries. The failures a filter cannot see are real size and current ownership.
Reasons need evidence. 88% of the reasons contain a date: the date of the fact the company failed on. A reason without a date cannot be re-checked later.

These shares describe the profiles in those runs. Your mix will differ, which is the point of counting your own.

The table

Add one table next to whatever holds your accounts. A decision is either kept or rejected, and a rejection must carry a rule and evidence.

CREATE TABLE account_decisions (
  id            BIGSERIAL PRIMARY KEY,
  account_id    BIGINT      NOT NULL REFERENCES accounts(id),
  decided_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
  decision      TEXT        NOT NULL CHECK (decision IN ('kept', 'rejected')),
  reason_rule   TEXT,       -- e.g. 'timing', 'size', 'ownership', 'industry'
  reason_text   TEXT,       -- one sentence a person can read
  evidence_url  TEXT,
  evidence_date DATE,       -- when the fact behind the reason happened
  CHECK (decision = 'kept' OR (reason_rule IS NOT NULL AND reason_text IS NOT NULL))
);

The last CHECK is the important line. If the database refuses a rejection without a reason, your "no" pile stays readable a year from now.

Query 1: the reason mix

SELECT reason_rule,
       count(*) AS rejects,
       round(100.0 * count(*) / sum(count(*)) OVER (), 1) AS pct
FROM account_decisions
WHERE decision = 'rejected'
  AND decided_at >= now() - interval '90 days'
GROUP BY reason_rule
ORDER BY rejects DESC;

How to read it:

Timing leads: the market fits, the moment does not. Keep the accounts and re-check them.
Size or ownership leads: your source data is stale. Fix the source, not the copy.
Industry leads: your search is wider than your profile.

Query 2: "not yet" accounts worth a second look

Timing rejects age. Pull the ones whose reason is older than a quarter, so they get re-checked instead of forgotten:

SELECT a.name, d.reason_text, d.evidence_date
FROM account_decisions d
JOIN accounts a ON a.id = d.account_id
WHERE d.decision = 'rejected'
  AND d.reason_rule = 'timing'
  AND d.decided_at < now() - interval '90 days'
  AND NOT EXISTS (            -- no newer decision for the same account
    SELECT 1 FROM account_decisions n
    WHERE n.account_id = d.account_id AND n.decided_at > d.decided_at)
ORDER BY d.decided_at;

Query 3: reasons with no evidence date

SELECT reason_rule,
       count(*) FILTER (WHERE evidence_date IS NULL) AS undated,
       count(*) AS total
FROM account_decisions
WHERE decision = 'rejected'
GROUP BY reason_rule;

An undated reason is an opinion. If one rule is mostly undated, that is where your research is guessing.

Try it on 50 accounts

You do not need a pipeline to start. Take 50 companies from your current target list, decide on each one (keep, or reject with one rule and one sentence), and count. In our data, about three in four companies that looked right on paper did not qualify, and the reasons showed why.

I wrote up the full breakdown, with what each reason means for a sales team, in why accounts get rejected.

If you track reject reasons differently, for example as tags or as a score, I would like to hear how in the comments.

DEV Community