Sales Research

Overview

This skill provides methodology and best practices for researching sales prospects. It covers company research, contact profiling, and signal detection to surface actionable intelligence.

Usage

The company-researcher and contact-researcher sub-agents reference this skill when:

• Researching new prospects
• Finding company information
• Profiling individual contacts
• Detecting buying signals

Research Methodology

Company Research Checklist

1. Basic Profile

   • Company name, industry, size (employees, revenue)
   • Headquarters and key locations
   • Founded date, growth stage

2. Recent Developments

   • Funding announcements (last 12 months)
   • M&A activity
   • Leadership changes
   • Product launches

3. Tech Stack

   • Known technologies (BuiltWith, StackShare)
   • Job postings mentioning tools
   • Integration partnerships

4. Signals

   • Job postings (scaling = opportunity)
   • Glassdoor reviews (pain points)
   • News mentions (context)
   • Social media activity

Contact Research Checklist

1. Professional Background

   • Current role and tenure
   • Previous companies and roles
   • Education

2. Influence Indicators

   • Reporting structure
   • Decision-making authority
   • Budget ownership

3. Engagement Hooks

   • Recent LinkedIn posts
   • Published articles
   • Speaking engagements
   • Mutual connections

Resources

• resources/signal-indicators.md - Taxonomy of buying signals
• resources/research-checklist.md - Complete research checklist

Scripts

• scripts/company-enricher.py - Aggregate company data from multiple sources
• scripts/linkedin-parser.py - Structure LinkedIn profile data FILE:company-enricher.py #!/usr/bin/env python3 """ company-enricher.py - Aggregate company data from multiple sources

Inputs:

• company_name: string
• domain: string (optional)

Outputs:

• profile: name: string industry: string size: string funding: string tech_stack: [string] recent_news: [news items]

Dependencies:

• requests, beautifulsoup4 """

Requirements: requests, beautifulsoup4

import json from typing import Any from dataclasses import dataclass, asdict from datetime import datetime

@dataclass class NewsItem: title: str date: str source: str url: str summary: str

@dataclass class CompanyProfile: name: str domain: str industry: str size: str location: str founded: str funding: str tech_stack: list[str] recent_news: list[dict] competitors: list[str] description: str

def search_company_info(company_name: str, domain: str = None) -> dict: """ Search for basic company information. In production, this would call APIs like Clearbit, Crunchbase, etc. """ # TODO: Implement actual API calls # Placeholder return structure return { "name": company_name, "domain": domain or f"{company_name.lower().replace(' ', '')}.com", "industry": "Technology", # Would come from API "size": "Unknown", "location": "Unknown", "founded": "Unknown", "description": f"Information about {company_name}" }

def search_funding_info(company_name: str) -> dict: """ Search for funding information. In production, would call Crunchbase, PitchBook, etc. """ # TODO: Implement actual API calls return { "total_funding": "Unknown", "last_round": "Unknown", "last_round_date": "Unknown", "investors": [] }

def search_tech_stack(domain: str) -> list[str]: """ Detect technology stack. In production, would call BuiltWith, Wappalyzer, etc. """ # TODO: Implement actual API calls return []

def search_recent_news(company_name: str, days: int = 90) -> list[dict]: """ Search for recent news about the company. In production, would call news APIs. """ # TODO: Implement actual API calls return []

def main( company_name: str, domain: str = None ) -> dict[str, Any]: """ Aggregate company data from multiple sources.

Args:
    company_name: Company name to research
    domain: Company domain (optional, will be inferred)

Returns:
    dict with company profile including industry, size, funding, tech stack, news
"""
# Get basic company info
basic_info = search_company_info(company_name, domain)

# Get funding information
funding_info = search_funding_info(company_name)

# Detect tech stack
company_domain = basic_info.get("domain", domain)
tech_stack = search_tech_stack(company_domain) if company_domain else []

# Get recent news
news = search_recent_news(company_name)

# Compile profile
profile = CompanyProfile(
    name=basic_info["name"],
    domain=basic_info["domain"],
    industry=basic_info["industry"],
    size=basic_info["size"],
    location=basic_info["location"],
    founded=basic_info["founded"],
    funding=funding_info.get("total_funding", "Unknown"),
    tech_stack=tech_stack,
    recent_news=news,
    competitors=[],  # Would be enriched from industry analysis
    description=basic_info["description"]
)

return {
    "profile": asdict(profile),
    "funding_details": funding_info,
    "enriched_at": datetime.now().isoformat(),
    "sources_checked": ["company_info", "funding", "tech_stack", "news"]
}

if name == "main": import sys

# Example usage
result = main(
    company_name="DataFlow Systems",
    domain="dataflow.io"
)
print(json.dumps(result, indent=2))

FILE:linkedin-parser.py #!/usr/bin/env python3 """ linkedin-parser.py - Structure LinkedIn profile data

Inputs:

• profile_url: string
• or name + company: strings

Outputs:

• contact: name: string title: string tenure: string previous_roles: [role objects] mutual_connections: [string] recent_activity: [post summaries]

Dependencies:

• requests """

Requirements: requests

import json from typing import Any from dataclasses import dataclass, asdict from datetime import datetime

@dataclass class PreviousRole: title: str company: str duration: str description: str

@dataclass class RecentPost: date: str content_preview: str engagement: int topic: str

@dataclass class ContactProfile: name: str title: str company: str location: str tenure: str previous_roles: list[dict] education: list[str] mutual_connections: list[str] recent_activity: list[dict] profile_url: str headline: str

def search_linkedin_profile(name: str = None, company: str = None, profile_url: str = None) -> dict: """ Search for LinkedIn profile information. In production, would use LinkedIn API or Sales Navigator. """ # TODO: Implement actual LinkedIn API integration # Note: LinkedIn's API has strict terms of service

return {
    "found": False,
    "name": name or "Unknown",
    "title": "Unknown",
    "company": company or "Unknown",
    "location": "Unknown",
    "headline": "",
    "tenure": "Unknown",
    "profile_url": profile_url or ""
}

def get_career_history(profile_data: dict) -> list[dict]: """ Extract career history from profile. """ # TODO: Implement career extraction return []

def get_mutual_connections(profile_data: dict, user_network: list = None) -> list[str]: """ Find mutual connections. """ # TODO: Implement mutual connection detection return []

def get_recent_activity(profile_data: dict, days: int = 30) -> list[dict]: """ Get recent posts and activity. """ # TODO: Implement activity extraction return []

def main( name: str = None, company: str = None, profile_url: str = None ) -> dict[str, Any]: """ Structure LinkedIn profile data for sales prep.

Args:
    name: Person's name
    company: Company they work at
    profile_url: Direct LinkedIn profile URL

Returns:
    dict with structured contact profile
"""
if not profile_url and not (name and company):
    return {"error": "Provide either profile_url or name + company"}

# Search for profile
profile_data = search_linkedin_profile(
    name=name,
    company=company,
    profile_url=profile_url
)

if not profile_data.get("found"):
    return {
        "found": False,
        "name": name or "Unknown",
        "company": company or "Unknown",
        "message": "Profile not found or limited access",
        "suggestions": [
            "Try searching directly on LinkedIn",
            "Check for alternative spellings",
            "Verify the person still works at this company"
        ]
    }

# Get career history
previous_roles = get_career_history(profile_data)

# Find mutual connections
mutual_connections = get_mutual_connections(profile_data)

# Get recent activity
recent_activity = get_recent_activity(profile_data)

# Compile contact profile
contact = ContactProfile(
    name=profile_data["name"],
    title=profile_data["title"],
    company=profile_data["company"],
    location=profile_data["location"],
    tenure=profile_data["tenure"],
    previous_roles=previous_roles,
    education=[],  # Would be extracted from profile
    mutual_connections=mutual_connections,
    recent_activity=recent_activity,
    profile_url=profile_data["profile_url"],
    headline=profile_data["headline"]
)

return {
    "found": True,
    "contact": asdict(contact),
    "research_date": datetime.now().isoformat(),
    "data_completeness": calculate_completeness(contact)
}

def calculate_completeness(contact: ContactProfile) -> dict: """Calculate how complete the profile data is.""" fields = { "basic_info": bool(contact.name and contact.title and contact.company), "career_history": len(contact.previous_roles) > 0, "mutual_connections": len(contact.mutual_connections) > 0, "recent_activity": len(contact.recent_activity) > 0, "education": len(contact.education) > 0 }

complete_count = sum(fields.values())
return {
    "fields": fields,
    "score": f"{complete_count}/{len(fields)}",
    "percentage": int((complete_count / len(fields)) * 100)
}

if name == "main": import sys

# Example usage
result = main(
    name="Sarah Chen",
    company="DataFlow Systems"
)
print(json.dumps(result, indent=2))

FILE:priority-scorer.py #!/usr/bin/env python3 """ priority-scorer.py - Calculate and rank prospect priorities

Inputs:

• prospects: [prospect objects with signals]
• weights: {deal_size, timing, warmth, signals}

Outputs:

• ranked: [prospects with scores and reasoning]

Dependencies:

• (none - pure Python) """

import json from typing import Any from dataclasses import dataclass

Default scoring weights

DEFAULT_WEIGHTS = { "deal_size": 0.25, "timing": 0.30, "warmth": 0.20, "signals": 0.25 }

Signal score mapping

SIGNAL_SCORES = { # High-intent signals "recent_funding": 10, "leadership_change": 8, "job_postings_relevant": 9, "expansion_news": 7, "competitor_mention": 6,

# Medium-intent signals
"general_hiring": 4,
"industry_event": 3,
"content_engagement": 3,

# Relationship signals
"mutual_connection": 5,
"previous_contact": 6,
"referred_lead": 8,

# Negative signals
"recent_layoffs": -3,
"budget_freeze_mentioned": -5,
"competitor_selected": -7,

}

@dataclass class ScoredProspect: company: str contact: str call_time: str raw_score: float normalized_score: int priority_rank: int score_breakdown: dict reasoning: str is_followup: bool

def score_deal_size(prospect: dict) -> tuple[float, str]: """Score based on estimated deal size.""" size_indicators = prospect.get("size_indicators", {})

employee_count = size_indicators.get("employees", 0)
revenue_estimate = size_indicators.get("revenue", 0)

# Simple scoring based on company size
if employee_count > 1000 or revenue_estimate > 100_000_000:
    return 10.0, "Enterprise-scale opportunity"
elif employee_count > 200 or revenue_estimate > 20_000_000:
    return 7.0, "Mid-market opportunity"
elif employee_count > 50:
    return 5.0, "SMB opportunity"
else:
    return 3.0, "Small business"

def score_timing(prospect: dict) -> tuple[float, str]: """Score based on timing signals.""" timing_signals = prospect.get("timing_signals", [])

score = 5.0  # Base score
reasons = []

for signal in timing_signals:
    if signal == "budget_cycle_q4":
        score += 3
        reasons.append("Q4 budget planning")
    elif signal == "contract_expiring":
        score += 4
        reasons.append("Contract expiring soon")
    elif signal == "active_evaluation":
        score += 5
        reasons.append("Actively evaluating")
    elif signal == "just_funded":
        score += 3
        reasons.append("Recently funded")

return min(score, 10.0), "; ".join(reasons) if reasons else "Standard timing"

def score_warmth(prospect: dict) -> tuple[float, str]: """Score based on relationship warmth.""" relationship = prospect.get("relationship", {})

if relationship.get("is_followup"):
    last_outcome = relationship.get("last_outcome", "neutral")
    if last_outcome == "positive":
        return 9.0, "Warm follow-up (positive last contact)"
    elif last_outcome == "neutral":
        return 7.0, "Follow-up (neutral last contact)"
    else:
        return 5.0, "Follow-up (needs re-engagement)"

if relationship.get("referred"):
    return 8.0, "Referred lead"

if relationship.get("mutual_connections", 0) > 0:
    return 6.0, f"{relationship['mutual_connections']} mutual connections"

if relationship.get("inbound"):
    return 7.0, "Inbound interest"

return 4.0, "Cold outreach"

def score_signals(prospect: dict) -> tuple[float, str]: """Score based on buying signals detected.""" signals = prospect.get("signals", [])

total_score = 0
signal_reasons = []

for signal in signals:
    signal_score = SIGNAL_SCORES.get(signal, 0)
    total_score += signal_score
    if signal_score > 0:
        signal_reasons.append(signal.replace("_", " "))

# Normalize to 0-10 scale
normalized = min(max(total_score / 2, 0), 10)

reason = f"Signals: {', '.join(signal_reasons)}" if signal_reasons else "No strong signals"
return normalized, reason

def calculate_priority_score( prospect: dict, weights: dict = None ) -> ScoredProspect: """Calculate overall priority score for a prospect.""" weights = weights or DEFAULT_WEIGHTS

# Calculate component scores
deal_score, deal_reason = score_deal_size(prospect)
timing_score, timing_reason = score_timing(prospect)
warmth_score, warmth_reason = score_warmth(prospect)
signal_score, signal_reason = score_signals(prospect)

# Weighted total
raw_score = (
    deal_score * weights["deal_size"] +
    timing_score * weights["timing"] +
    warmth_score * weights["warmth"] +
    signal_score * weights["signals"]
)

# Compile reasoning
reasons = []
if timing_score >= 8:
    reasons.append(timing_reason)
if signal_score >= 7:
    reasons.append(signal_reason)
if warmth_score >= 7:
    reasons.append(warmth_reason)
if deal_score >= 8:
    reasons.append(deal_reason)

return ScoredProspect(
    company=prospect.get("company", "Unknown"),
    contact=prospect.get("contact", "Unknown"),
    call_time=prospect.get("call_time", "Unknown"),
    raw_score=round(raw_score, 2),
    normalized_score=int(raw_score * 10),
    priority_rank=0,  # Will be set after sorting
    score_breakdown={
        "deal_size": {"score": deal_score, "reason": deal_reason},
        "timing": {"score": timing_score, "reason": timing_reason},
        "warmth": {"score": warmth_score, "reason": warmth_reason},
        "signals": {"score": signal_score, "reason": signal_reason}
    },
    reasoning="; ".join(reasons) if reasons else "Standard priority",
    is_followup=prospect.get("relationship", {}).get("is_followup", False)
)

def main( prospects: list[dict], weights: dict = None ) -> dict[str, Any]: """ Calculate and rank prospect priorities.

Args:
    prospects: List of prospect objects with signals
    weights: Optional custom weights for scoring components

Returns:
    dict with ranked prospects and scoring details
"""
weights = weights or DEFAULT_WEIGHTS

# Score all prospects
scored = [calculate_priority_score(p, weights) for p in prospects]

# Sort by raw score descending
scored.sort(key=lambda x: x.raw_score, reverse=True)

# Assign ranks
for i, prospect in enumerate(scored, 1):
    prospect.priority_rank = i

# Convert to dicts for JSON serialization
ranked = []
for s in scored:
    ranked.append({
        "company": s.company,
        "contact": s.contact,
        "call_time": s.call_time,
        "priority_rank": s.priority_rank,
        "score": s.normalized_score,
        "reasoning": s.reasoning,
        "is_followup": s.is_followup,
        "breakdown": s.score_breakdown
    })

return {
    "ranked": ranked,
    "weights_used": weights,
    "total_prospects": len(prospects)
}

if name == "main": import sys

# Example usage
example_prospects = [
    {
        "company": "DataFlow Systems",
        "contact": "Sarah Chen",
        "call_time": "2pm",
        "size_indicators": {"employees": 200, "revenue": 25_000_000},
        "timing_signals": ["just_funded", "active_evaluation"],
        "signals": ["recent_funding", "job_postings_relevant"],
        "relationship": {"is_followup": False, "mutual_connections": 2}
    },
    {
        "company": "Acme Manufacturing",
        "contact": "Tom Bradley",
        "call_time": "10am",
        "size_indicators": {"employees": 500},
        "timing_signals": ["contract_expiring"],
        "signals": [],
        "relationship": {"is_followup": True, "last_outcome": "neutral"}
    },
    {
        "company": "FirstRate Financial",
        "contact": "Linda Thompson",
        "call_time": "4pm",
        "size_indicators": {"employees": 300},
        "timing_signals": [],
        "signals": [],
        "relationship": {"is_followup": False}
    }
]

result = main(prospects=example_prospects)
print(json.dumps(result, indent=2))

FILE:research-checklist.md

Prospect Research Checklist

Company Research

Basic Information

• Company name (verify spelling)
• Industry/vertical
• Headquarters location
• Employee count (LinkedIn, website)
• Revenue estimate (if available)
• Founded date
• Funding stage/history

Recent News (Last 90 Days)

• Funding announcements
• Acquisitions or mergers
• Leadership changes
• Product launches
• Major customer wins
• Press mentions
• Earnings/financial news

Digital Footprint

• Website review
• Blog/content topics
• Social media presence
• Job postings (careers page + LinkedIn)
• Tech stack (BuiltWith, job postings)

Competitive Landscape

• Known competitors
• Market position
• Differentiators claimed
• Recent competitive moves

Pain Point Indicators

• Glassdoor reviews (themes)
• G2/Capterra reviews (if B2B)
• Social media complaints
• Job posting patterns

Contact Research

Professional Profile

• Current title
• Time in role
• Time at company
• Previous companies
• Previous roles
• Education

Decision Authority

• Reports to whom
• Team size (if manager)
• Budget authority (inferred)
• Buying involvement history

Engagement Hooks

• Recent LinkedIn posts
• Published articles
• Podcast appearances
• Conference talks
• Mutual connections
• Shared interests/groups

Communication Style

• Post tone (formal/casual)
• Topics they engage with
• Response patterns

CRM Check (If Available)

• Any prior touchpoints
• Previous opportunities
• Related contacts at company
• Notes from colleagues
• Email engagement history

Time-Based Research Depth

Time Available	Research Depth
5 minutes	Company basics + contact title only
15 minutes	+ Recent news + LinkedIn profile
30 minutes	+ Pain point signals + engagement hooks
60 minutes	Full checklist + competitive analysis
FILE:signal-indicators.md

Signal Indicators Reference

High-Intent Signals

Job Postings

• 3+ relevant roles posted = Active initiative, budget allocated
• Senior hire in your domain = Strategic priority
• Urgency language ("ASAP", "immediate") = Pain is acute
• Specific tool mentioned = Competitor or category awareness

Financial Events

• Series B+ funding = Growth capital, buying power
• IPO preparation = Operational maturity needed
• Acquisition announced = Integration challenges coming
• Revenue milestone PR = Budget available

Leadership Changes

• New CXO in your domain = 90-day priority setting
• New CRO/CMO = Tech stack evaluation likely
• Founder transition to CEO = Professionalizing operations

Medium-Intent Signals

Expansion Signals

• New office opening = Infrastructure needs
• International expansion = Localization, compliance
• New product launch = Scaling challenges
• Major customer win = Delivery pressure

Technology Signals

• RFP published = Active buying process
• Vendor review mentioned = Comparison shopping
• Tech stack change = Integration opportunity
• Legacy system complaints = Modernization need

Content Signals

• Blog post on your topic = Educating themselves
• Webinar attendance = Interest confirmed
• Whitepaper download = Problem awareness
• Conference speaking = Thought leadership, visibility

Low-Intent Signals (Nurture)

General Activity

• Industry event attendance = Market participant
• Generic hiring = Company growing
• Positive press = Healthy company
• Social media activity = Engaged leadership

Signal Scoring

Signal Type	Score	Action
Job posting (relevant)	+3	Prioritize outreach
Recent funding	+3	Reference in conversation
Leadership change	+2	Time-sensitive opportunity
Expansion news	+2	Growth angle
Negative reviews	+2	Pain point angle
Content engagement	+1	Nurture track
No signals	0	Discovery focus