You've been recording sales calls for months. Every recording sits in a folder. Managers occasionally spot-check one, listen for 10 minutes, give vague feedback, move on. That's a coaching wasteland.
AssemblyAI flips the game. Upload a Twilio recording and get back a JSON payload: [Speaker 0]: "Here's my pain point" (sentiment: NEGATIVE, 68% confidence) → [Speaker 1]: "I can fix that with..." (sentiment: POSITIVE, 81% confidence). The API tags topics automatically (pricing objection, timeline concern, trust-building question). Content safety flags red flags. PII redaction washes out customer SSNs and credit cards. Managers now have a dashboard showing call velocity, objection patterns, discovery-to-close ratios — per rep, per week, per month.
This post walks the real pattern: Twilio call recording → AssemblyAI async upload → Supabase store transcript + metadata → React dashboard for managers to filter, search, and coach. No Whisper hallucinations, no manual speaker labeling, no post-processing pipeline. One HTTP call and a webhook callback.
What AssemblyAI Does That Whisper Can't
If you've read our Whisper vs AssemblyAI comparison, you know Whisper's free and accurate. AssemblyAI costs money. So what's the trade?
1. Speaker Diarization. Whisper returns one blob of text. AssemblyAI labels [Speaker 0], [Speaker 1], [Speaker 2]. For a sales call, Speaker 0 is your rep, Speaker 1 is the prospect. Sentiment analysis then tags each speaker's emotional state — is the rep nervous? Is the prospect skeptical? A wall of text tells you nothing. Labeled speakers + sentiment tells you everything.
2. Sentiment Per Utterance. Not just "this call felt positive" — AssemblyAI assigns confidence scores to every sentence. "I'm interested" = POSITIVE at 92%. "But I'm not sure yet" = NEGATIVE at 78%. Managers can spot the exact moment a call turned (or almost turned). That's coaching gold. You can build a dashboard showing sentiment arcs per call, identify rep blind spots ("You always miss the micro-no"), and measure improvement week-to-week.
3. Automatic Topic Detection. The API tags what was discussed: pricing objection, timeline concern, competitor comparison, trust-building, next steps. Aggregate across 100 calls and you see what's blocking your pipeline. "Pricing objection" on 40% of calls? Time to workshop your value story. Real signal, real insights, no manual tagging.
Real Pattern: Twilio → AssemblyAI → Supabase
Here's the Aidxn standard flow. Twilio records a call. After hang-up, your webhook triggers an AssemblyAI upload (async, 5–30 second turnaround). AssemblyAI POSTs back to your backend when done. You store the transcript + metadata (diarization, sentiment, topics) in Supabase. Managers query the calls table, filter by rep or date range, click a call to see the full transcript with sentiment colors and coaching notes.
Database schema lives in three tables: calls (call_id, rep_id, prospect_id, created_at, duration, sentiment_average), call_utterances (id, call_id, speaker, text, sentiment, confidence, start_ms, end_ms), and call_topics (id, call_id, topic_name, count, first_at_ms). A call_id is the foreign key. Managers query with supabase.from('calls').select('*').eq('rep_id', $1).order('created_at', {ascending: false}) — boom, all calls for a rep, sorted new-first. Click into call_id 7, and the UI joins call_utterances to show the full diarized + sentiment-labeled transcript.
AssemblyAI's webhook endpoint is simple: receive the JSON, validate the signature, store the utterances in Postgres in ~200ms. The schema is normalized so you can slice data by speaker, sentiment, topic, date range, or rep. That's real analytics infrastructure, built on a free API call (well, a $0.37/hour API call).
Building the Manager Dashboard
React component: filter calls by rep, date, sentiment threshold, or topic. Show a table with call metrics: duration, average sentiment, dominant topic, speaker-0 talk percentage (is your rep dominating?). Click a row to expand the full transcript — utterances rendered as a timeline, each colored by sentiment. Negative utterances highlight red. Positive ones turn green. Managers can leave coaching notes per utterance (stored in a coaching_notes table, joined at query time). Over time, you're building a coaching library indexed by call + topic + rep.
You can go further: aggregate sentiment by rep and time, plot a line chart of weekly sentiment trends. Plot topic frequency week-to-week. Show talk percentage (rep vs prospect) — if your rep talks 80%, they're pitching, not listening. If they talk 20%, they're asking questions but maybe not closing. The data tells the story once you have utterance-level diarization and sentiment. Whisper can't do this. Whisper doesn't know who said what or how they said it.
PII Redaction and Compliance
If you're storing customer data, redaction matters. AssemblyAI's content-safety module flags and redacts credit card numbers, SSNs, phone numbers, email addresses. Transcripts stored in Supabase won't leak customer PII if someone queries the table. For regulated industries (financial services, healthcare — though healthcare shouldn't record calls without explicit consent), redaction is table-stakes.
AssemblyAI's PII request in the API: pii_policies: ['credit_card_number', 'ssn', 'phone_number', 'email_address']. The response includes a redacted_text field with masked values. Store the redacted version in your database. Separately, store the raw audio in encrypted S3 if you need a compliance audit trail. Don't store PII in the database unless the customer opts in — Supabase RLS rules enforce this.
Six FAQs
How fast is AssemblyAI compared to Whisper?
Whisper local: 1 hour of audio in 3–5 minutes on M2. AssemblyAI: async upload, webhook callback in 5–30 seconds depending on audio length. Whisper is real-time on your machine. AssemblyAI is instant if you queue async. For a sales coaching platform, async is fine — you're reviewing calls hours after hang-up, not during the call. Whisper would require shell scripts and cron jobs. AssemblyAI is a REST API.
Can I use AssemblyAI for live call coaching (real-time transcription)?
AssemblyAI has a Real-Time API (WebSocket). You stream audio and get transcription + diarization back as it happens. Latency is ~200ms, suitable for a rep's live dashboard or an AI coach prompt-feeding bot. But for your use case (post-call coaching), the async API is cheaper and simpler. Async costs $0.37/hour. Real-Time costs more (~$0.75/hour). Use async unless you're building a live call-assist product.
What if Twilio doesn't include call metadata?
Twilio webhooks include call_sid, phone numbers, duration, and recording URL. Store the recording_url, call_sid, and timestamp in your database immediately after the call ends. Then POST that recording_url to AssemblyAI with metadata (rep_id, prospect_id). AssemblyAI will fetch and transcribe. When the webhook fires back, you have the transcript + metadata to join with the original call record. Metadata is never missing — Twilio gives you everything.
How do I handle multiple simultaneous calls?
Every call has a unique call_sid. Twilio webhooks fire independently per call_sid. Your backend queues each upload to AssemblyAI with the call_sid as a correlation ID. When the webhook fires back, you match the response to the call via call_sid. Diarization per call is automatic — AssemblyAI clusters speakers independently per audio file. No cross-call speaker bleeding.
Can AssemblyAI detect when a rep is being dishonest?
No. Sentiment detects emotional tone (positive/negative/neutral), not truthfulness. A rep can be enthusiastically lying. You still need human coaching judgment. What AssemblyAI gives you: early signals. If a rep says "I'm confident we can ship by Friday" but their sentiment score is 42% positive (hedging), that's a coaching moment. Sentiment + human review = better coaching than either alone.
What's the cheapest way to set this up?
Twilio call recording is free (included in call cost). AssemblyAI is $0.37/hour. Supabase free tier gives you 500MB database storage, 1GB bandwidth. If you have 50 reps and each logs 3 calls/day (150 calls), that's ~75 hours/month of audio (~$28). Store utterances in Postgres (utterances are compressed — 100 calls = ~50KB JSON). A React dashboard on Vercel is free. Total marginal cost: ~$28/month + host fees. That's less than one hour of an operations manager, so the ROI is immediate.
The Bottom Line
Sales coaching scales when you systematize it. AssemblyAI turns audio into structured data: diarization (who said what), sentiment (how they said it), topics (what they discussed). Aggregate across 100 calls and you see coaching patterns, objection trends, and rep strengths. Whisper transcribes text. AssemblyAI transcribes context. For a sales organization, context is everything. Build once, coach forever. Want help wiring this up? Check out our AI integration services, or read more on transcription economics in our Whisper vs AssemblyAI guide.