Give sales a reason
to make the call.

From the classifier, with my comments for you. The lists themselves live in a template the firm edits.

def check_exclusions(row, internal_team, dnc_list, competitors, fractional_execs):
    first = str(row.get('FirstName', '')).strip()
    last = str(row.get('LastName', '')).strip()
    full_name = f"{first} {last}".strip().lower()
    company = str(row.get('CompanyName', '')).strip().lower()
    title = str(row.get('Title', '')).strip().lower()
    emp = parse_employee_count(row.get('EstimatedEmployeeCount'))

    # The order is the point. Cheap, certain exclusions first, so a row that is
    # obviously not a prospect never reaches the scoring below it.
    for name in internal_team:
        if _name_matches(name, first, last, full_name):
            return 'INTERNAL', ...
    for name, reason in dnc_list:
        if _name_matches(name, first, last, full_name):
            return 'DO NOT CONTACT', ...
    for comp in competitors:
        if comp.lower() in company:
            return 'COMPETITOR', ...
    # This is the one the whole engine exists for. A fractional executive on the
    # site is the supply side, and they look exactly like a buyer to a tool that
    # only sees pages. The roster lives in a template the firm edits, not here.
    for name in fractional_execs:
        if _name_matches(name, first, last, full_name):
            return 'FRACTIONAL EXEC', ...
    # Only from an explicit word in the title or the company. Guessing would throw
    # out real people.
    for kw in ['self employed', 'self-employed', 'freelance', 'freelancer', 'retired']:
        if kw in title:
            return 'SELF-EMPLOYED', ...
    for exc_type, keywords in NON_TARGET_KEYWORDS.items():
        for kw in keywords:
            if kw in company:
                return exc_type, ...
    # Five thousand people is where a company stops buying the way this firm sells.
    if emp and emp > 5000:
        return '5000+ EMPLOYEES', ...
    return None, None

Title, out of ten. Revenue, industry and geography have functions of their own.

def score_title(title):
    # Ten points for the people who sign. Not the same thing as the MQL title gate
    # further down: this rewards seniority broadly, the gate is stricter on purpose.
    if pd.isna(title) or not str(title).strip() or str(title).strip() == '(No title)':
        return 0
    t = str(title).lower().strip()
    c_suite = ['ceo', 'cfo', 'cto', 'coo', 'cmo', 'cro', 'cpo', 'cio', 'cso', 'chief ',
               'founder', 'co-founder', 'cofounder', 'president', 'owner', 'managing director']
    if any(k in t for k in c_suite):
        return 10
    vp_dir = ['vice president', 'vp ', 'vp,', 'director', 'managing partner', 'partner',
              'general partner', 'board member', 'executive director']
    if any(k in t for k in vp_dir):
        return 8
    manager = ['manager', 'general manager', 'head of', 'head,', 'site manager']
    if any(k in t for k in manager):
        return 6
    relevant = ['coordinator', 'project manager', 'business development', 'account manager',
                'recruiter', 'consultant', 'advisor', 'strategist', 'analyst']
    if any(k in t for k in relevant):
        return 4
    # Everyone with a title gets something. No title at all gets nothing, above.
    return 2

Page scores sit in a dictionary by funnel stage: decision pages 10 to 12, consideration 7 to 9, interest 4 to 6, awareness 1 to 3. This is what happens to them.

def compute_behavioral(pages, all_time_views, n_exports):
    if not pages:
        return 0, []
    # Every page has a score by what it means, not by how often it is visited.
    # A pricing page is worth more than ten blog posts.
    page_scores = [(p, get_page_score(p)) for p in pages]
    base_sum = sum(s for _, s in page_scores)
    unique_pages = list(set(pages))
    max_score = max((get_page_score(p) for p in unique_pages), default=0)
    n_unique = len(unique_pages)
    # A journey across pages that matter is worth more than the pages alone.
    # The max_score check stops three blog posts from counting as a journey.
    journey_bonus = 0
    if n_unique >= 3 and max_score >= 4:
        journey_bonus = 15
    elif n_unique >= 2 and max_score >= 4:
        journey_bonus = 10
    # Showing up in more than one weekly export means they came back.
    repeat_bonus = 0
    if n_exports >= 3:
        repeat_bonus = 10
    elif n_exports >= 2:
        repeat_bonus = 5
    total = base_sum + journey_bonus + repeat_bonus
    return total, page_scores

The original client classifier: decision rules and title eligibility. These are separate from this website’s demonstration score.

def meets_mql_behavior(fit, behav, pages, title_score):
    # Kept as its own function so the decision and the label in the row agree
    # on exactly what "MQL-strength" means. Two places, one definition.
    if fit < 15:
        return False
    is_hand_raiser = any(p in HAND_RAISER_PAGES for p in pages)
    if behav >= 25:
        return True
    # A hand-raise on the pricing or contact page, from a manager or above,
    # gets in a little earlier than the behaviour score alone would allow.
    if is_hand_raiser and title_score >= 6 and behav >= 20:
        return True
    return False


def classify_lead(fit, behav, pages, title_score, visited_apply, flags, title):
    # The apply page decides first, before fit and behaviour get a say.
    # Someone who touched it is almost always the supply side.
    if visited_apply:
        non_apply = [p for p in pages if p != 'apply']
        max_non_apply = max((get_page_score(p) for p in non_apply), default=0)
        if max_non_apply >= 4 and fit >= 15:
            return 'APPLY-PAGE-CAUTION'
        return 'SUPPLY-SIDE ONLY'
    if fit >= 15:
        if meets_mql_behavior(fit, behav, pages, title_score):
            # MQL is only for the people who sign: CEO, founder, co-founder, an
            # actual president, an actual VP. A functional VP with the same
            # behaviour is still a strong lead. It nurtures as Warm instead.
            if is_mql_eligible_title(title):
                return 'MQL'
            return 'WARM'
        return 'WARM'
    if behav >= 20:
        return 'FLAGGED'
    return 'LOW'


    # Founder or co-founder has to be the role, not a word in a job title.
    # "Founder", "Founder & CEO", "Founder of Acme" qualify. "Founder Relations",
    # "Head of Founder Programs", "Founding Engineer" do not. So: find the word,
    # then look at what follows it.
    fm = re.search(r'\bco-founder\b|\bfounder\b', t)
    if fm:
        rest = t[fm.end():].lstrip()
        if rest == '' or rest[0] in ',&/|+' or rest.startswith(('of ', 'and ')):
            return True
        if re.match(r'(ceo|president|owner|coo|cfo|cto|cmo|cio|cro|chair|principal)\b', rest):
            return True
        # Otherwise "founder" is describing a department, and the checks below decide.

From the skill. What the agent is told to do, and the one rule it cannot touch.

# What the agent is told to do, after the Python has run. It reads the
# workbook, not the export, so it is reading the exceptions.

Every MQL row
  Confirm the title really is MQL-eligible: a CEO, founder, co-founder, or a
  literal President or VP. The Python gate enforces this, but watch for what
  a parser misreads: "Pres." abbreviations, titles in another language,
  "President & CEO" combos. Check the industry is not obviously wrong.

Warm leads labelled "title not MQL-eligible"
  These had MQL-strength behaviour and a title the gate turned away. Skim them.
  If one is a top decision-maker the parser misfiled, move it up.

Top 20 Warm leads
  Any that deserve attention on title, company and geography together?

Flagged leads with high scores
  Any worth a human looking at?

The one rule it cannot touch
  /apply is red, at the bottom, always. Removed from MQL and Warm.