Vertriebsforschungskompetenz: Methodik zur Prospect-Recherche

--- name: sales-research description: Diese Skill bietet Methodik und Best Practices für die Recherche von Vertriebsinteressenten. --- # Vertriebsrecherche ## Überblick Diese Skill bietet Methodik und Best Practices für die Recherche von Vertriebsinteressenten. Sie umfasst Unternehmensrecherche, Kontaktprofilierung und Signalerfassung, um umsetzbare Erkenntnisse zu gewinnen. ## Verwendung Die Unter-Agenten company-researcher und contact-researcher referenzieren diese Skill, wenn: - Neue Interessenten recherchiert werden - Unternehmensinformationen gefunden werden - Einzelne Kontakte profiliert werden - Kaufsignale erkannt werden ## Forschungsmethodik ### Checkliste Unternehmensrecherche 1. **Basisprofil** - Firmenname, Branche, Größe (Mitarbeiter, Umsatz) - Hauptsitz und wichtige Standorte - Gründungsdatum, Wachstumsphase 2. **Aktuelle Entwicklungen** - Finanzierungsankündigungen (letzte 12 Monate) - M&A-Aktivitäten - Führungswechsel - Produkteinführungen 3. **Technologie-Stack** - Bekannte Technologien (BuiltWith, StackShare) - Stellenausschreibungen mit Tool-Erwähnungen - Integrationspartnerschaften 4. **Signale** - Stellenausschreibungen (Skalierung = Chance) - Glassdoor-Bewertungen (Schmerzpunkte) - Presseerwähnungen (Kontext) - Social-Media-Aktivitäten ### Checkliste Kontaktrecherche 1. **Beruflicher Hintergrund** - Aktuelle Rolle und Amtszeit - Frühere Unternehmen und Rollen - Ausbildung 2. **Einflussindikatoren** - Berichtsstruktur - Entscheidungsbefugnis - Budgetverantwortung 3. **Engagement-Hooks** - Aktuelle LinkedIn-Beiträge - Veröffentlichte Artikel - Vorträge - Gemeinsame Kontakte ## Ressourcen - `resources/signal-indicators.md` - Taxonomie von Kaufsignalen - `resources/research-checklist.md` - Vollständige Recherche-Checkliste ## Skripte - `scripts/company-enricher.py` - Aggregiert Unternehmensdaten aus mehreren Quellen - `scripts/linkedin-parser.py` - Strukturiert LinkedIn-Profil Daten FILE:company-enricher.py #!/usr/bin/env python3 """ company-enricher.py - Aggregiert Unternehmensdaten aus mehreren Quellen Eingaben: - company_name: string - domain: string (optional) Ausgaben: - profile: name: string industry: string size: string funding: string tech_stack: [string] recent_news: [news items] Abhängigkeiten: - requests, beautifulsoup4 """ # Anforderungen: 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: """ Sucht nach grundlegenden Unternehmensinformationen. In Produktion würde dies APIs wie Clearbit, Crunchbase usw. aufrufen. """ # TODO: Implementieren Sie tatsächliche API-Aufrufe # Platzhalter-Rückgabestruktur return { "name": company_name, "domain": domain or f"{company_name.lower().replace(' ', '')}.com", "industry": "Technologie", # Würde von API kommen "size": "Unbekannt", "location": "Unbekannt", "founded": "Unbekannt", "description": f"Informationen über {company_name}" } def search_funding_info(company_name: str) -> dict: """ Sucht nach Finanzierungsinformationen. In Produktion würde dies Crunchbase, PitchBook usw. aufrufen. """ # TODO: Implementieren Sie tatsächliche API-Aufrufe return { "total_funding": "Unbekannt", "last_round": "Unbekannt", "last_round_date": "Unbekannt", "investors": [] } def search_tech_stack(domain: str) -> list[str]: """ Erkennt den Technologie-Stack. In Produktion würde dies BuiltWith, Wappalyzer usw. aufrufen. """ # TODO: Implementieren Sie tatsächliche API-Aufrufe return [] def search_recent_news(company_name: str, days: int = 90) -> list[dict]: """ Sucht nach aktuellen Nachrichten über das Unternehmen. In Produktion würde dies Nachrichten-APIs aufrufen. """ # TODO: Implementieren Sie tatsächliche API-Aufrufe return [] def main( company_name: str, domain: str = None ) -> dict[str, Any]: """ Aggregiert Unternehmensdaten aus mehreren Quellen. Args: company_name: Zu recherchierender Firmenname domain: Unternehmensdomain (optional, wird abgeleitet) Returns: dict mit Unternehmensprofil einschließlich Branche, Größe, Finanzierung, Technologie-Stack, Nachrichten """ # Grundlegende Unternehmensinformationen abrufen basic_info = search_company_info(company_name, domain) # Finanzierungsinformationen abrufen funding_info = search_funding_info(company_name) # Technologie-Stack erkennen company_domain = basic_info.get("domain", domain) tech_stack = search_tech_stack(company_domain) if company_domain else [] # Aktuelle Nachrichten abrufen news = search_recent_news(company_name) # Profil zusammenstellen 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", "Unbekannt"), tech_stack=tech_stack, recent_news=news, competitors=[], # Würde aus Branchenanalyse angereichert 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 # Beispielverwendung 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 - Strukturiert LinkedIn-Profil Daten Eingaben: - profile_url: string - oder name + company: strings Ausgaben: - contact: name: string title: string tenure: string previous_roles: [role objects] mutual_connections: [string] recent_activity: [post summaries] Abhängigkeiten: - requests """ # Anforderungen: 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: """ Sucht nach LinkedIn-Profilinformationen. In Produktion würde dies die LinkedIn-API oder Sales Navigator verwenden. """ # TODO: Implementieren Sie die tatsächliche LinkedIn-API-Integration # Hinweis: Die LinkedIn-API hat strenge Nutzungsbedingungen return { "found": False, "name": name or "Unbekannt", "title": "Unbekannt", "company": company or "Unbekannt", "location": "Unbekannt", "headline": "", "tenure": "Unbekannt", "profile_url": profile_url or "" } def get_career_history(profile_data: dict) -> list[dict]: """ Extrahiert den Karriereverlauf aus dem Profil. """ # TODO: Implementieren Sie die Karriereextraktion return [] def get_mutual_connections(profile_data: dict, user_network: list = None) -> list[str]: """ Findet gemeinsame Kontakte. """ # TODO: Implementieren Sie die Erkennung gemeinsamer Kontakte return [] def get_recent_activity(profile_data: dict, days: int = 30) -> list[dict]: """ Ruft aktuelle Beiträge und Aktivitäten ab. """ # TODO: Implementieren Sie die Aktivitätsextraktion return [] def main( name: str = None, company: str = None, profile_url: str = None ) -> dict[str, Any]: """ Strukturiert LinkedIn-Profil Daten für die Vertriebsvorbereitung. Args: name: Name der Person company: Unternehmen, bei dem sie arbeitet profile_url: Direkte LinkedIn-Profil-URL Returns: dict mit strukturiertem Kontaktprofil """ if not profile_url and not (name and company): return {"error": "Geben Sie entweder profile_url oder name + company an"} # Nach Profil suchen 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 "Unbekannt", "company": company or "Unbekannt", "message": "Profil nicht gefunden oder eingeschränkter Zugriff", "suggestions": [ "Versuchen Sie, direkt auf LinkedIn zu suchen", "Prüfen Sie alternative Schreibweisen", "Verifizieren Sie, dass die Person noch bei diesem Unternehmen arbeitet" ] } # Karriereverlauf abrufen previous_roles = get_career_history(profile_data) # Gemeinsame Kontakte finden mutual_connections = get_mutual_connections(profile_data) # Aktuelle Aktivitäten abrufen recent_activity = get_recent_activity(profile_data) # Kontaktprofil zusammenstellen 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=[], # Würde aus Profil extrahiert 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: """Berechnet, wie vollständig die Profildaten sind.""" 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 # Beispielverwendung 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 - Berechnet und ordnet Interessentenprioritäten Eingaben: - prospects: [prospect objects with signals] - weights: {deal_size, timing, warmth, signals} Ausgaben: - ranked: [prospects with scores and reasoning] Abhängigkeiten: - (keine - reines Python) """ import json from typing import Any from dataclasses import dataclass # Standard-Bewertungsgewichte DEFAULT_WEIGHTS = { "deal_size": 0.25, "timing": 0.30, "warmth": 0.20, "signals": 0.25 } # Signal-Score-Zuordnung SIGNAL_SCORES = { # Signale mit hoher Absicht "recent_funding": 10, "leadership_change": 8, "job_postings_relevant": 9, "expansion_news": 7, "competitor_mention": 6, # Signale mit mittlerer Absicht "general_hiring": 4, "industry_event": 3, "content_engagement": 3, # Beziehungssignale "mutual_connection": 5, "previous_contact": 6, "referred_lead": 8, # Negative Signale "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]: """Bewertet basierend auf der geschätzten Deal-Größe.""" size_indicators = prospect.get("size_indicators", {}) employee_count = size_indicators.get("employees", 0) revenue_estimate = size_indicators.get("revenue", 0) # Einfache Bewertung basierend auf Unternehmensgröße if employee_count > 1000 or revenue_estimate > 100_000_000: return 10.0, "Enterprise-Chance" elif employee_count > 200 or revenue_estimate > 20_000_000: return 7.0, "Mid-Market-Chance" elif employee_count > 50: return 5.0, "SMB-Chance" else: return 3.0, "Kleines Unternehmen" def score_timing(prospect: dict) -> tuple[float, str]: """Bewertet basierend auf Timing-Signalen.""" timing_signals = prospect.get("timing_signals", []) score = 5.0 # Basisscore reasons = [] for signal in timing_signals: if signal == "budget_cycle_q4": score += 3 reasons.append("Q4-Budgetplanung") elif signal == "contract_expiring": score += 4 reasons.append("Vertrag läuft bald ab") elif signal == "active_evaluation": score += 5 reasons.append("Aktiv in der Evaluierung") elif signal == "just_funded": score += 3 reasons.append("Kürzlich finanziert") return min(score, 10.0), "; ".join(reasons) if reasons else "Standard-Timing" def score_warmth(prospect: dict) -> tuple[float, str]: """Bewertet basierend auf der Beziehungswärme.""" relationship = prospect.get("relationship", {}) if relationship.get("is_followup"): last_outcome = relationship.get("last_outcome", "neutral") if last_outcome == "positive": return 9.0, "Warmes Follow-up (positiver letzter Kontakt)" elif last_outcome == "neutral": return 7.0, "Follow-up (neutraler letzter Kontakt)" else: return 5.0, "Follow-up (erneutes Engagement nötig)" if relationship.get("referred"): return 8.0, "Empfohlener Lead" if relationship.get("mutual_connections", 0) > 0: return 6.0, f"{relationship['mutual_connections']} gemeinsame Kontakte" if relationship.get("inbound"): return 7.0, "Inbound-Interesse" return 4.0, "Kaltakquise" def score_signals(prospect: dict) -> tuple[float, str]: """Bewertet basierend auf erkannten Kaufsignalen.""" 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("_", " ")) # Auf 0-10-Skala normalisieren normalized = min(max(total_score / 2, 0), 10) reason = f"Signale: {', '.join(signal_reasons)}" if signal_reasons else "Keine starken Signale" return normalized, reason def calculate_priority_score( prospect: dict, weights: dict = None ) -> ScoredProspect: """Berechnet den Gesamtprioritätsscore für einen Interessenten.""" weights = weights or DEFAULT_WEIGHTS # Komponentenscores berechnen 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) # Gewichtete Summe raw_score = ( deal_score * weights["deal_size"] + timing_score * weights["timing"] + warmth_score * weights["warmth"] + signal_score * weights["signals"] ) # Begründung zusammenstellen 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", "Unbekannt"), contact=prospect.get("contact", "Unbekannt"), call_time=prospect.get("call_time", "Unbekannt"), raw_score=round(raw_score, 2), normalized_score=int(raw_score * 10), priority_rank=0, # Wird nach dem Sortieren gesetzt 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-Priorität", is_followup=prospect.get("relationship", {}).get("is_followup", False) ) def main( prospects: list[dict], weights: dict = None ) -> dict[str, Any]: """ Berechnet und ordnet Interessentenprioritäten. Args: prospects: Liste von Interessentenobjekten mit Signalen weights: Optionale benutzerdefinierte Gewichte für Bewertungskomponenten Returns: dict mit geordneten Interessenten und Bewertungsdetails """ weights = weights or DEFAULT_WEIGHTS # Alle Interessenten bewerten scored = [calculate_priority_score(p, weights) for p in prospects] # Nach Rohscore absteigend sortieren scored.sort(key=lambda x: x.raw_score, reverse=True) # Ränge zuweisen for i, prospect in enumerate(scored, 1): prospect.priority_rank = i # In Dicts für JSON-Serialisierung umwandeln 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 # Beispielverwendung 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 # Checkliste Interessentenrecherche ## Unternehmensrecherche ### Basisinformationen - [ ] Firmenname (Schreibweise verifizieren) - [ ] Branche/Vertikale - [ ] Hauptsitz - [ ] Mitarbeiterzahl (LinkedIn, Website) - [ ] Umsatzschätzung (falls verfügbar) - [ ] Gründungsdatum - [ ] Finanzierungsphase/Geschichte ### Aktuelle Nachrichten (Letzte 90 Tage) - [ ] Finanzierungsankündigungen - [ ] Übernahmen oder Fusionen - [ ] Führungswechsel - [ ] Produkteinführungen - [ ] Große Kundengewinne - [ ] Presseerwähnungen - [ ] Ergebnis-/Finanznachrichten ### Digitaler Fußabdruck - [ ] Website-Überprüfung - [ ] Blog-/Inhaltsthemen - [ ] Social-Media-Präsenz - [ ] Stellenausschreibungen (Karriereseite + LinkedIn) - [ ] Technologie-Stack (BuiltWith, Stellenausschreibungen) ### Wettbewerbslandschaft - [ ] Bekannte Wettbewerber - [ ] Marktposition - [ ] Behauptete Differenzierungsmerkmale - [ ] Aktuelle Wettbewerbsbewegungen ### Indikatoren für Schmerzpunkte - [ ] Glassdoor-Bewertungen (Themen) - [ ] G2/Capterra-Bewertungen (falls B2B) - [ ] Social-Media-Beschwerden - [ ] Muster in Stellenausschreibungen ## Kontaktrecherche ### Berufliches Profil - [ ] Aktuelle Position - [ ] Zeit in der Rolle - [ ] Zeit im Unternehmen - [ ] Frühere Unternehmen - [ ] Frühere Rollen - [ ] Ausbildung ### Entscheidungsbefugnis - [ ] Berichtet an wen - [ ] Teamgröße (falls Manager) - [ ] Budgetverantwortung (abgeleitet) - [ ] Bisherige Beteiligung an Käufen ### Engagement-Hooks - [ ] Aktuelle LinkedIn-Beiträge - [ ] Veröffentlichte Artikel - [ ] Podcast-Auftritte - [ ] Konferenzvorträge - [ ] Gemeinsame Kontakte - [ ] Gemeinsame Interessen/Gruppen ### Kommunikationsstil - [ ] Ton der Beiträge (formell/informell) - [ ] Themen, mit denen sie interagieren - [ ] Antwortmuster ## CRM-Prüfung (Falls Verfügbar) - [ ] Frühere Berührungspunkte - [ ] Frühere Chancen - [ ] Verwandte Kontakte im Unternehmen - [ ] Notizen von Kollegen - [ ] E-Mail-Engagement-Verlauf ## Zeitbasierte Recherchetiefe | Verfügbare Zeit | Recherchetiefe | |----------------|----------------| | 5 Minuten | Unternehmensbasis + Kontakttitel nur | | 15 Minuten | + Aktuelle Nachrichten + LinkedIn-Profil | | 30 Minuten | + Schmerzpunkt-Signale + Engagement-Hooks | | 60 Minuten | Vollständige Checkliste + Wettbewerbsanalyse | FILE:signal-indicators.md # Referenz für Signalindikatoren ## Signale mit hoher Absicht ### Stellenausschreibungen - **3+ relevante Rollen ausgeschrieben** = Aktive Initiative, Budget zugewiesen - **Senior-Einstellung in Ihrer Domäne** = Strategische Priorität - **Dringlichkeitssprache ("ASAP", "sofort")** = Schmerz ist akut - **Bestimmtes Tool erwähnt** = Wettbewerbs- oder Kategoriebewusstsein ### Finanzielle Ereignisse - **Series B+ Finanzierung** = Wachstumskapital, Kaufkraft - **IPO-Vorbereitung** = Operative Reife erforderlich - **Übernahme angekündigt** = Integrationsherausforderungen stehen an - **Umsatzmeilenstein-PR** = Budget verfügbar ### Führungswechsel - **Neuer CXO in Ihrer Domäne** = 90-Tage-Prioritätensetzung - **Neuer CRO/CMO** = Technologie-Stack-Evaluierung wahrscheinlich - **Gründerübergang zum CEO** = Professionalisierung des Betriebs ## Signale mit mittlerer Absicht ### Expansionssignale - **Neue Büroeröffnung** = Infrastrukturbedarf - **Internationale Expansion** = Lokalisierung, Compliance - **Neue Produkteinführung** = Skalierungsherausforderungen - **Großer Kundengewinn** = Lieferdruck ### Technologiesignale - **RFP veröffentlicht** = Aktiver Kaufprozess - **Anbieterüberprüfung erwähnt** = Preisvergleich - **Technologie-Stack-Änderung** = Integrationsmöglichkeit - **Beschwerden über Altsysteme** = Modernisierungsbedarf ### Inhaltssignale - **Blogbeitrag zu Ihrem Thema** = Selbstbildung - **Webinar-Teilnahme** = Interesse bestätigt - **Whitepaper-Download** = Problembewusstsein - **Konferenzvortrag** = Thought Leadership, Sichtbarkeit ## Signale mit niedriger Absicht (Nurture) ### Allgemeine Aktivität - **Branchenveranstaltungsbesuch** = Marktteilnehmer - **Allgemeine Einstellungen** = Unternehmen wächst - **Positive Presse** = Gesundes Unternehmen - **Social-Media-Aktivität** = Engagierte Führung ## Signal-Bewertung | Signaltyp | Score | Aktion | |-------------|-------|--------| | Stellenausschreibung (relevant) | +3 | Outreach priorisieren | | Aktuelle Finanzierung | +3 | Im Gespräch referenzieren | | Führungswechsel | +2 | Zeitkritische Chance | | Expansionsnachrichten | +2 | Wachstumswinkel | | Negative Bewertungen | +2 | Schmerzpunkt-Winkel | | Inhaltsengagement | +1 | Nurture-Track | | Keine Signale | 0 | Entdeckungsfokus |