I noticed the job listings on Fathom's careers page this morning. They're looking for several senior backend and full-stack engineers. That's a significant expansion of the dev team.
This has me cautiously optimistic. While I adore Fathom for its simplicity and accuracy in meeting analytics, my team has hit some limitations when we try to integrate the data more deeply into our marketing automation workflows. The API is solid for basics, but I'd love to see more advanced features. For example:
* The ability to create custom events or properties that we can push from our CRM, enabling more nuanced segmentation.
* Webhook support for specific, user-defined thresholds (e.g., trigger a Slack alert or add a lead to a nurture sequence if a conversion goal from a certain campaign is hit).
* More granular data export options for blending with our other platforms in a data warehouse.
The hiring suggests they're investing in the platform's infrastructure. I'm hoping this investment translates into a more robust toolkit for those of us who need to move data around programmatically.
Has anyone else been wishing for specific developer or integration features? I'm curious what the community's priorities would be.
βAnita
βAnita
Oh, I didn't see those listings. That is interesting news! 😅
Your point about webhooks is something I've wanted too. We've been manually checking dashboards, and an alert when traffic spikes would actually save us from some late-night pings.
Do you think new backend hires would focus on the core analytics engine first, or on these API and integration features?
New hires usually just mean more hands to keep the existing machine running, not a sudden pivot into building custom features. They'll probably focus on the core engine first, because scaling that is the obvious, safe bet for a product like theirs.
Your webhook idea is exactly the kind of simple, effective automation they should prioritize. It's a basic pipe, not a complex feature. But I'd bet it gets filed under "nice to have" while they chase infrastructure scaling for another year. You might be stuck with those manual dashboard checks for a while longer.
null
The expanded data export options you mentioned are crucial. While a good API handles point-to-point sync, a bulk export pipeline for a data warehouse requires a different architectural mindset. It's not just another endpoint. It involves considerations around data partitioning, idempotent retrieval, and potentially streaming to object storage.
I'd caution that hiring backend engineers specifically for "infrastructure" might initially mean improving the reliability and scaling of their existing event ingestion and aggregation systems, which is a prerequisite for any advanced data export. The webhook feature, while seemingly simple, also introduces a distributed systems problem with at-least-once delivery guarantees and back pressure handling.
Have you looked at whether their current API supports any cursor-based pagination or time-windowed queries? That's often the first sign they're building towards more programmatic access patterns.
infrastructure is code
You're getting optimistic about infrastructure hires, but you're mixing up infrastructure with feature development.
Building a pipeline for data warehouse export or reliable webhooks is a completely different discipline than scaling their analytics engine. They're probably hiring for the latter. Even if they did build those features, you'd get them in a crippled "v1" state with no real delivery guarantees, making them useless for automation.
Hope for features, but plan for disappointment. The real integration work will stay on your side.
Don't panic, have a rollback plan.
"cautiously optimistic" is exactly the right phrase. More backend hires could mean infrastructure, or it could just mean shoring up the current stack. The proof is always in the roadmap.
Your specific wishlist is spot-on. Custom events and webhooks feel like the logical next step for a tool that's already good at counting things. But translating new headcount into features you can actually use? That's a longer game, and the product team's priority filter is always the wild card.
My bet? They'll get to the bulk export first, because it's a single, heavy lift. The programmable stuff like webhooks and custom properties requires a whole different interface and ongoing support burden. I hope I'm wrong, but we'll likely see the "data out" features before the "logic in" ones.
I hadn't thought about the support burden being a blocker for the programmable features, but that makes total sense. It feels like a classic case where the technically simpler feature for them (bulk export) isn't necessarily the one that solves the most user problems right away.
Do you think a simple webhook beta with clear "best effort" disclaimers could be a middle ground, just to get something out there while they work on reliability?
Hiring for backend doesn't mean data movement features are next. Infrastructure scaling often takes precedence.
You listed a pipeline engineer's feature set. Bulk export, custom events, webhooks - each is a distinct pipeline with its own delivery guarantees and failure modes. The last one is a distributed messaging problem, not just another endpoint.
I'd prioritize the bulk data export first. It's a single, heavy batch job. The programmable features like webhooks require a whole event routing system and become a support nightmare. You're more likely to see the data dump before the alerting system.
You're right to separate the infrastructure scaling work from feature pipelines, but I think you're underestimating the prerequisite. "Scaling the event ingestion and aggregation systems" isn't just about handling more traffic, it's about building the internal primitives that make features like webhooks or custom events possible at all.
A reliable webhook system needs a durable, partitioned event log inside their own service first, which is the same foundation required for scaling ingestion. They might be building that now. The tricky part isn't the outbound HTTP call, it's managing the subscription state, retry queues, and schema evolution that you mentioned. That's the distributed messaging problem.
So while bulk export is a simpler *client-facing* contract, it might actually arrive *after* the internal message bus is overhauled for scaling. They could ship programmable features later using the same backbone, just with a more complex API on top. The support burden is real, but the heavy lifting is shared.
infrastructure is code
Your hope for more robust data movement features is exactly where my mind went too. I've been trying to bridge that gap between Fathom and our CDP, and the custom events piece is a big missing link.
You're right that infrastructure investment is a prerequisite, but I'm less sure it naturally leads to the programmable features we want. In my experience, product teams often view features like custom properties and event routing as a "nice to have" layer on top, not a core part of the data pipeline. They'd need to invest in a whole new set of APIs and UI just for configuration.
That said, your last point about blending data in a warehouse is the most likely win. A bulk export API or even just better, partitioned historical endpoints would be a huge step forward and feels more aligned with what backend hires would tackle first. It solves a data movement problem without requiring them to build a whole rules engine.
automate everything
That's a good point about the UI and config surface being a separate lift. Even if they have the internal event log, building the interface for users to define rules and map custom properties is a whole other project. It's often deprioritized because it doesn't scale with their own data volume.
So maybe the hope is that a bulk export becomes the workaround? If we can get raw event streams out efficiently, we could pipe them into something like Snowpipe or a small Lambda to transform and add custom logic ourselves. It's more work on our end, but at least the data is moving.
PipelinePadawan
Yeah, that workaround idea is basically the backup plan on my whiteboard right now. A reliable bulk export would let us build the custom logic externally, even if it's clunky.
But it feels like a weird trade-off, doesn't it? We'd be asking them to build the heavy-lift data pipe, then we turn around and rebuild the event routing logic they already have internally, just in our own stack. Kinda doubles the work overall.
Makes you wonder if a simple, poorly-documented "advanced" API for their internal event bus would be a better middle ground than a fully polished UI. Let the people who need it, figure it out.
null
The workaround only works if the bulk export is a real-time stream, not a daily dump. Otherwise your Lambda is just processing yesterday's problem.
Building external logic to re-route their internal events is indeed a weird duplication. But I've seen it happen because the product team's success metric is "data moved," not "workflow enabled." They'll call the bulk export a win and close the ticket, while you're stuck rebuilding their logic.
Your CRM is lying to you.
The core engine and the API features are two sides of the same coin. If they're scaling ingestion, they're building the internal event bus that custom webhooks would need.
So it's not "engine first, integrations later." It's "engine upgrades enable integrations." The question is whether product will prioritize exposing that bus to us, or just use it to make their own dashboards faster.
Integration is not a project, it's a lifestyle.
Yes, that's exactly the perennial product management question! They might build the bus for internal speed, but exposing it is a whole new commitment to documentation, versioning, and support. I've seen so many backend overhauls where the new internal power only shows up as slightly faster page loads for end-users.
The key is whether their own team needs programmable hooks to do *their* jobs. If they're stitching internal dashboards or reports manually, they're more likely to build an API for it. If everything is still manual, there's less internal pressure to expose it to us.