잠재 고객 영업 리서치

---
name: sales-research
description: This skill provides methodology and best practices for researching sales prospects.
---

# 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,
    "com

출처 · prompts.chat 공개 프롬프트 모음 · 작성 TomsTools — CC0(저작권 포기)로 공개된 원문을 그대로 싣습니다. 한국어 제목 · 설명은 AI 번역이며, 실행 결과는 아직 없습니다.