event-signals

# Event Signals

Extract leads from the conference and events ecosystem. Events represent public declarations of priorities — a VP speaking about "scaling our infrastructure" is a stronger signal than a Reddit comment, and a company sponsoring a conference category has committed real budget.

## When to Use

- User wants to find leads from conferences, meetups, or developer events
- User wants speaker lists, sponsor lists, or attendee data from events
- User mentions KubeCon, AWS re:Invent, DevOpsDays, or any industry conference
- User wants to find people who spoke or presented about relevant topics
- User asks about hackathon participants using relevant technologies
- User wants podcast guests who discussed relevant challenges
- User describes prospects who attend industry events or speak at conferences

## Prerequisites

- Python 3.9+ with `requests` and optionally `python-dotenv`
- Apify API token in `.env` (for Meetup and Luma — optional)
- ListenNotes API key in `.env` as `LISTENNOTES_API_KEY` (for podcast search — optional, free tier gives 300 req/mo)
- Working directory: the project root containing this skill

## Phase 1: Collect Context

### Step 1: Gather Product & ICP Information

If not already available from prior skills:

> "To find the right event-based leads, I need:
> 1. **What does your product do?** (one-liner)
> 2. **What industry/vertical are you in?** (this determines which conferences matter)
> 3. **What technologies or keywords are in your space?**
> 4. **Who is your ideal buyer?** (their role, what conferences they'd attend)
> 5. **Any specific conferences or events you know about?** (names, URLs)
> 6. **Are you registered on Luma or Meetup for any events?** (if yes, we may be able to access attendee lists)"

## Phase 2: Discover Relevant Events

This is the most agent-driven phase. The agent must actively research to find the right events.

### Step 2: Discover Conferences

Use multiple approaches in parallel:

**2a. Confs.tech (automated):**
The tool can query confs.tech for conferences by topic. Common topics available: `devops`, `javascript`, `ruby`, `python`, `golang`, `rust`, `java`, `php`, `css`, `data`, `security`, `ux`, `android`, `ios`, `general`, `dotnet`, `elixir`, `networking`, `cloud`, `ai`.

**2b. Web search (agent-driven):**
Search for conferences in the user's space. Queries to try:
- "[industry/technology] conferences 2026"
- "[technology] developer conference"
- "[vertical] summit 2026"
- "best [topic] conferences for engineers"
- "[competitor name] conference" (competitors often host their own events)

**2c. Check for Sessionize events:**
Many tech conferences use Sessionize for their schedule. When you find a conference:
1. Check if their schedule page links to Sessionize
2. Look for URLs like `sessionize.com/api/v2/EVENTID` in the page source
3. If Sessionize is used, note the event ID — we can extract all speakers programmatically

**2d. Check for upcoming events (forward-looking 180 days):**
Search for events happening in the next 6 months. The user wants to reach prospects BEFORE the event.
- Search: "[conference name] 2026 dates"
- Check conference websites for published schedules and speaker announcements
- CFP (Call for Papers) deadlines indicate upcoming conferences

**2e. Check for recent events (backward-looking 90 days):**
Recent event speakers/sponsors still have the same priorities. Search for:
- "[conference name] 2025 2026 speakers"
- "[conference name] recap" or "what I learned at [conference]"

### Step 3: Discover Meetups and Local Events

**3a. Meetup.com (automated):**
Generate search queries based on the user's space:
- Technology-specific: "Kubernetes meetup", "WebRTC meetup"
- Industry-specific: "DevOps meetup", "cloud native meetup"
- Location-specific (if user has a target geography)

**3b. Luma (automated):**
Search Luma for events in the user's space. Luma is popular for:
- AI/ML community events
- Startup demo days
- Developer community gatherings
- Tech talks and fireside chats

**3c. Ask the user about their registrations:**
> "Are you registered for any events on Luma or Meetup? If you're registered for a Luma event, the attendee list is often publicly visible — I can extract it. For some Meetup events, RSVP lists are public too."

### Step 4: Discover Podcasts

**4a. Identify relevant podcasts:**
Do a web search to find podcasts in the user's space:
- "[technology/industry] podcast"
- "best podcasts for [role/topic]"
- "[competitor name] podcast" (competitors often appear as guests)

**4b. Search for specific episodes:**
Use ListenNotes to search for episodes by keyword:
- "[competitor] review" or "[competitor] experience"
- "[problem space] challenges"
- "[technology] at scale"
- "building [thing the product does]"

### Step 5: Discover Hackathons

**5a. Devpost:**
Search Devpost for hackathons with projects using relevant technologies:
- Go to devpost.com and search for hackathon names in the user's space
- Note the hackathon slug (URL path) for the tool to scrape

**5b. Other hackathon platforms:**
- MLH season events (mlh.io/seasons)
- Company-hosted hackathons (many companies run their own)
- University hackathons (if targeting younger engineers)

### Step 6: Present Discovery Results

Present all discovered events to the user in a table:

```
CONFERENCES (Sessionize available):
  Event                    | Date         | Location      | Sessionize ID
  KubeCon NA 2026          | Oct 13-16    | Salt Lake City| abc123
  DevOpsDays NYC           | Jun 5-6      | New York      | def456

CONFERENCES (need website scraping):
  Event                    | Date         | URL
  AWS re:Invent            | Nov 30-Dec 4 | reinvent.awsevents.com

MEETUP QUERIES: "kubernetes meetup", "cloud native meetup"
LUMA QUERIES: "devops event", "infrastructure meetup"
PODCAST QUERIES: "kubernetes scaling", "infrastructure challenges"
DEVPOST HACKATHONS: "cloud-native-hack-2026", "kubernetes-challenge"
```

Ask the user to review and approve. Also ask if they want to add or remove any events.

### Step 7: Scrape Conference Websites (Agent-Driven)

For conferences NOT on Sessionize, the agent should manually extract:

**Speaker lists:**
- Navigate to the conference website's "Speakers" or "Schedule" page
- Extract: speaker name, company, title, talk title, bio
- Use Chrome DevTools MCP or web fetching tools

**Sponsor lists:**
- Navigate to the "Sponsors" or "Partners" page
- Extract: company name, sponsorship tier (platinum/gold/silver/bronze)
- Higher tiers = more invested in the space

**Save scraped data** to `${CLAUDE_SKILL_DIR}/../.tmp/manual_event_signals.json` in this format:
```json
[
    {
        "person_name": "Jane Smith",
        "company": "Acme Corp",
        "signal_type": "conference_speaker",
        "signal_label": "Conference Speaker",
        "event_name": "KubeCon NA 2026",
        "event_type": "Conference",
        "talk_or_role": "Scaling Kubernetes to 10,000 Nodes",
        "bio": "VP of Infrastructure at Acme Corp",
        "url": "https://kubecon.io/speakers/jane-smith",
        "linkedin": "",
        "twitter": "@janesmith",
        "website": "",
        "date": "2026-10-14",
        "source": "Manual"
    }
]
```

## Phase 3: Execute Scan

### Step 8: Save Config File

```bash
cat > ${CLAUDE_SKILL_DIR}/../.tmp/event_signals_config.json << 'CONFIGEOF'
{
    "keywords": ["kubernetes", "cloud native", "infrastructure"],
    "sessionize_event_ids": ["abc123", "def456"],
    "confstech_topics": ["devops", "cloud"],
    "meetup_queries": ["kubernetes meetup", "cloud native meetup"],
    "meetup_location": "",
    "luma_queries": ["devops event", "infrastructure meetup"],
    "podcast_queries": ["kubernetes scaling", "infrastructure challenges"],
    "devpost_slugs": ["cloud-native-hack-2026"],
    "manual_signals_file": "${CLAUDE_SKILL_DIR}/../.tmp/manual_event_signals.json",
    "skip": []
}
CONFIGEOF
```

### Step 9: Run the Tool

```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/event_signals.py \
    --config ${CLAUDE_SKILL_DIR}/../.tmp/event_signals_config.json \
    --output ${CLAUDE_SKILL_DIR}/../.tmp/event_signals.csv
```

The tool handles structured sources. The agent handles conference website scraping in Step 7 (before running the tool), saving results to the manual signals file.

**To skip specific sources:**
Add to the config's `skip` array: `"sessionize"`, `"confstech"`, `"meetup"`, `"luma"`, `"podcast"`, `"devpost"`

## Phase 4: Analyze & Recommend

### Step 11: Analyze Results

**11a. Overall Stats**
- Total signals by type (speakers, sponsors, meetup organizers, hackathon entries, podcast guests)
- Total unique people and companies
- Signal source breakdown

**11b. Speaker Analysis**
- Who is speaking about topics relevant to the user's product?
- What companies are they from? (company clustering)
- What are the most common talk themes?
- Any speakers who appear at multiple events? (repeat speakers = thought leaders with influence)

**11c. Sponsor Analysis**
- Which companies are sponsoring events in this space? (they have budget committed)
- Tier analysis — platinum/gold sponsors are the most invested
- Companies sponsoring multiple events = deeply committed to the space

**11d. Hackathon & Community Analysis**
- What technologies are hackathon teams using?
- Which teams built projects most relevant to the user's product?

**11e. Podcast Analysis**
- What topics are being discussed most?
- Which podcast guests talked about problems the user's product solves?

**11f. Time-Based Urgency**
- Upcoming events (next 30 days) = outreach should happen NOW, before the event
- Recent events (last 30 days) = speakers still have the topic top-of-mind
- Events 30-90 days out = time to prepare personalized outreach

### Step 12: Recommend Next Steps

1. **For conference speakers:**
   - Highest-value leads. They publicly declared their priorities.
   - Outreach angle: "I saw your talk on [topic] at [event] — we solve exactly that problem"
   - Recommend enriching via SixtyFour to get contact info
   - If the event is upcoming: "I'll be at [event] too — would love to chat about [topic]"

2. **For sponsors:**
   - These are companies, not individuals. Use SixtyFour `/enrich-company` first, then find the right person.
   - Outreach angle: "I noticed [company] sponsored [event] — you're clearly investing in [space]"

3. **For meetup organizers/attendees:**
   - Community influencers. Good for partnerships, not just sales.
   - Consider having the user attend these meetups for warm intros.

4. **For hackathon participants:**
   - Active builders using relevant tech. Often at startups or building side projects that become companies.
   - Outreach angle: Reference their project specifically.

5. **For podcast guests:**
   - Similar to conference speakers — public thought leaders.
   - Outreach angle: "Listened to your episode on [podcast] about [topic]"

6. **Cross-signal validation:**
   - If a person appeared as both a conference speaker AND was found in GitHub signals or community signals, that's a very high-confidence lead.
   - Check if any companies from event signals also appeared in job signals (hiring + sponsoring = maximum budget commitment).

### Step 13: Ask for Go-Ahead

> "Would you like me to:
> 1. Enrich the top speakers/companies via SixtyFour
> 2. Cross-reference with GitHub/community/job signals data
> 3. Scrape more conference websites for additional speakers/sponsors
> 4. Set up monitoring for upcoming events (recurring scan)
> 5. Export for manual review first"

## Output Schema (Single Sheet)

| Column | Description |
|--------|-------------|
| person_name | Speaker name, organizer, podcast guest, or team member |
| company | Company/organization |
| signal_type | Internal signal type code |
| signal_label | Human-readable signal label |
| event_name | Conference/meetup/hackathon/podcast name |
| event_type | Conference, Meetup, Hackathon, Podcast, Luma Event |
| talk_or_role | Talk title, sponsorship tier, project name, episode title |
| bio | Speaker bio or event/project description |
| linkedin | LinkedIn URL (if available from Sessionize) |
| twitter | Twitter/X handle (if available) |
| website | Personal/company website (if available) |
| date | Event date or episode date |
| signal_score | Weight based on signal type |
| source | Sessionize, Meetup, Luma, ListenNotes, Devpost, Manual |
| url | Link to the event/talk/episode/project |

## Signal Scoring

| Signal Type | Score | Rationale |
|---|---|---|
| Conference Speaker | 9 | Company-approved public statement of priorities |
| Workshop Host | 9 | Deep expertise + company investment in teaching |
| Podcast Guest | 8 | Public discussion of challenges and stack |
| Panel Participant | 8 | Industry voice, often reveals pain points |
| Conference Sponsor | 8 | Committed budget to the space |
| Meetup Organizer | 7 | Community leader and influencer |
| Hackathon Entry | 7 | Active builder using relevant tech |
| Podcast Host | 6 | Creates content in the space — influencer |
| Meetup Attendee | 5 | Interest signal but lower commitment |
| Event Attendee | 5 | Interest signal |

## Event Type Guidelines for the Agent

When discovering events, consider ALL of these event types based on the user's ICP:

**Major Developer Conferences:**
KubeCon, AWS re:Invent, Google Cloud Next, Microsoft Build, QCon, DevOpsDays, GopherCon, PyCon, RustConf, JSConf, ReactConf, DockerCon, HashiConf, Datadog DASH, GitLab Commit, GitHub Universe, Vercel Ship

**Industry/Vertical Conferences:**
SaaStr (SaaS), MWC (mobile), CES (consumer tech), RSA (security), Black Hat (security), Gartner summits, Forrester events

**Startup Events:**
YC Demo Day, TechCrunch Disrupt, Web Summit, Collision, SXSW Interactive, Product Hunt launches

**Meetup Platforms:**
Meetup.com, Luma, Eventbrite, Bevy (community-led events)

**Hackathon Platforms:**
Devpost, MLH events, Devfolio, company-hosted hackathons

**Podcast Networks:**
Changelog, Software Engineering Daily, The New Stack, InfoQ podcasts, a16z podcast, industry-specific pods

The agent should adapt this list based on the user's specific vertical.

## Cost Estimates

| Source | Cost | Notes |
|--------|------|-------|
| Sessionize | Free | Public API, no auth |
| Confs.tech | Free | JSON on GitHub |
| Meetup (Apify) | ~$0.05-0.10/search | Pay-per-event |
| Luma (Apify) | $29/mo + usage or pay-per-event | Depends on actor |
| ListenNotes | Free (300 req/mo) | Free tier sufficient for most |
| Devpost | Free | Custom scraping |
| Manual scraping | Free | Agent uses web tools |
| **Typical run** | **$1-5 total** | Most sources are free |

## Time Window

- **Backward:** 90 days (recent events — speakers still have topic top-of-mind)
- **Forward:** 180 days (upcoming events — reach prospects before the event for maximum impact)