How do I track competitor mentions across all calls?

Another week, another product manager asking for magic. They want a report on every time a competitor's name is uttered in a sales or support call. "Just pull it from the recordings," they say. As if the audio fairy visits our data lake every night to leave transcribed tidbits.

Let's be clear: if you're manually scrubbing through call logs, you've already lost. The goal is to automate this into a pipeline, so the data flows to you, not you to the data. You'll need a few pieces working together, and if they're not integrated, you're building a Rube Goldberg machine that fails every Thursday.

First, you need a consistent way to capture and transcribe calls. If you're using something like Zoom or Teams, their cloud APIs often provide transcripts. The raw, unprocessed transcript is your source material. The pipeline stages look something like this:

* **Ingestion:** Pull call transcripts from your conferencing platform's API on a schedule. Dump them into a structured store. A simple S3 bucket or a database blob will do.
* **Processing:** This is where the actual detection happens. You need a script that scans each transcript for a defined list of competitor names and related keywords. Don't rely on simple string matching; you'll need to handle "SynergySoft" vs. "Synergy Soft" vs. "those Synergy guys."
* **Extraction & Alerting:** When a hit is found, you need to capture the context (the 30 seconds before and after the mention) and route it. This could be a Slack message to the competitive intel team, a row in a spreadsheet, or a ticket in your CRM.

Here's a brutally simplified example of the core processing logic you might run in a GitHub Action or a Jenkins pipeline step. This uses Python, but the concept is universal.

```python
import re

def scan_transcript(transcript_text, competitor_patterns):
"""
Scans a transcript for competitor mentions.
Returns list of dicts with 'competitor', 'mention_context', and 'timestamp'.
"""
findings = []
lines = transcript_text.split('n')

for i, line in enumerate(lines):
for pattern, competitor_name in competitor_patterns.items():
if re.search(pattern, line, re.IGNORECASE):
# Grab context (previous and next line)
context_start = max(0, i - 1)
context_end = min(len(lines), i + 2)
context = 'n'.join(lines[context_start:context_end])

findings.append({
'competitor': competitor_name,
'mention_context': context,
'timestamp': extract_timestamp(line) # You'd need to implement this based on your transcript format
})
return findings

# Define your patterns. Use regex for flexibility.
competitor_patterns = {
r'bSynergySoftb|bSynergy Softb': 'SynergySoft',
r'bMegacorpb|bMega Corpb': 'Megacorp',
r'bCloudNinjab|bCloud Ninjab': 'CloudNinja'
}

# This function would be called for each new transcript
new_findings = scan_transcript(raw_transcript, competitor_patterns)
```

The real headaches begin with false positives, speaker identification (was it our rep or the customer who mentioned them?), and scaling this across ten thousand calls a month. You'll likely graduate from simple regex to a dedicated NLP service, but that's a cost and integration discussion for another day.

The pitfall everyone ignores is the feedback loop. This pipeline must update the competitor keyword list. If a new competitor emerges in calls next month, your script is blind until you add the pattern. So build a simple review step where ambiguous mentions are flagged for a human to categorize.

Now, if you'll excuse me, I have to go restart a Jenkins agent that's fallen asleep again.

fix the pipe