Just wrapped up a POC for post-call summary automation, specifically feeding notes into Salesforce. tl;dv and Fathom were the final contenders. The marketing claims are similar, but the implementation reality is different.
Here's the breakdown from an integration and reliability standpoint.
**tl;dv**
* **Integration Method:** Uses a dedicated Salesforce connector with OAuth. It pushes summaries to a custom object via a configurable mapping UI. No direct API access to the core summarization engine.
* **Data Flow:** Call -> tl;dv -> (Processed Summary) -> tl;dv Connector -> Salesforce Custom Object.
* **Pros:** The UI mapping is straightforward for admins. Set up the field mapping once and it runs.
* **Cons:** Black box. If the summary format isn't perfect, you can't intercept and transform the JSON payload before it hits Salesforce without building a middleware proxy. Latency is higher due to the connector layer.
**Fathom**
* **Integration Method:** Provides a webhook for the summarized transcript. You point it at an endpoint, and you handle the Salesforce insert. We used a small AWS Lambda (Node.js) for this.
* **Data Flow:** Call -> Fathom -> (Webhook with JSON) -> Your Lambda -> Salesforce Standard/Custom Object via REST API.
* **Pros:** Full control. You can parse, enrich, reformat, or even trigger other workflows from the Lambda before the SFDC write. Lower latency.
* **Cons:** Requires development resources. You own the integration code and its failures.
**Verdict:** If you need a no-code, admin-led setup and accept the fixed data structure, **tl;dv works**. If you have dev/automation resources and need flexibility, reliability, and direct control, **Fathom is superior**. The webhook model lets you build a more resilient pipeline.
For our team, control won. Here's the Lambda snippet that handled the webhook, added some internal tagging, and pushed to a Salesforce Task.
```javascript
exports.handler = async (event) => {
const fathomData = JSON.parse(event.body);
const summary = fathomData.summary;
const callId = fathomData.id;
// Enrich & transform
const salesforceTaskPayload = {
Subject: `Call Summary: ${callId}`,
Description: `## AI Summaryn${summary}nn[Source: Fathom]`,
Status: 'Completed',
// ... other mapped fields
};
// Call Salesforce REST API
return await axios.post(SFDC_INSTANCE_URL, salesforceTaskPayload, {
headers: { 'Authorization': `Bearer ${await getAccessToken()}` }
});
};
```
The Fathom webhook gives you the raw materials to build exactly what you need. tl;dv gives you a pre-assembled, fixed-output tool.
-shift
shift left or go home
I'm a sales operations lead at a ~150 person SaaS company. We've been running Fathom in production for about a year, feeding summaries into Salesforce for our sales team.
**Integration Control:** Fathom wins if you have dev resources. Their webhook lets you parse and transform the summary JSON before the Salesforce insert. Our Lambda adds custom logic and retries. tl;dv's point-and-click mapper is faster but you're stuck with its output.
**Latency & Reliability:** The tl;dv connector added a noticeable delay, roughly 45-90 seconds post-call for us. Fathom's webhook reaches our endpoint in 20-30 seconds; total time to Salesforce depends on our script, but we average under a minute.
**Summary Format Flexibility:** With Fathom, we could adjust prompts via their API for different call types (demos vs support). tl;dv's summary style is fixed unless you pay for a custom plan, which started at $15k/year when we asked.
**Pricing & Scale:** tl;dv's per-seat pricing (~$29/user/mo) got expensive for our whole team. Fathom's per-meeting model (~$15/user/mo for our volume) worked better. For high call volume (50+ daily), Fathom's tiered meeting packs are cheaper.
I'd pick Fathom if you have a developer or integration tool like Zapier/Make to handle the webhook. It's more work upfront but you own the pipeline. Choose tl;dv if you're an admin-only shop and need a set-and-forget solution, accepting the format rigidity. To decide, tell us your average calls per day and if you have in-house dev or IT support.
You hit on the exact friction point we ran into. That black box issue with tl;dv's connector became a blocker for us because we needed to append internal ticket references to the summary before it landed in Salesforce. Building a proxy just to tweak the payload felt like too much overhead.
The latency you mentioned was a factor for us, too. For our sales team, even an extra 30-second delay meant they'd sometimes start a follow-up task before the notes appeared, which defeated the purpose. Fathom's webhook approach let us build in a quick retry for failed inserts, which has saved us a few times.