Fetch once, use everywhere: rebuilding how Dovetail ingests your data

Think of a shared fridge. Instead of every housemate buying their own carton of the same milk, there's one good carton that everyone pours from. That's the shift we're making: one shared source in your workspace, rather than a separate copy for every place that wants it.

Connect a customer data source to Dovetail once, and use it everywhere. A support inbox or a set of sales calls gets fetched and prepared a single time, then it's ready for any Channel that needs it, and soon for Projects too.

How it used to work

A lot of what makes Dovetail useful happens before you open it. We're always pulling in customer feedback from the tools you connect—things like support conversations, sales calls, and surveys—then cleaning it up into something you can search and act on.

For years, each Channel did that on its own. It fetched its own data, processed it, and stored its own copy. That was fine as long as no two Channels watched the same place. But they often did. Two Channels on one inbox meant we did the whole job twice, and paid for it twice over: in calls to the upstream tool, in repeated AI enrichment, and in storage holding more or less the same thing.

It adds up. Around 20% of the customer data we took in over the past year is a duplicate copy of something we already had.

The waste wasn't even the worst part. The real problem was that every copy got stuck where it landed. What one Channel ingested, another couldn't easily reuse, and you couldn't pull it into a Project without importing the whole source again from scratch.

One carton, shared

The change is easy to describe: buy the milk once, keep one carton, and let everyone pour from it.

In product terms, we're turning data connectors into shared resources that belong to your workspace. A connector knows where to fetch from and what to bring back. Instead of each Channel keeping a private copy, a Channel, and before long a Project, draws from the shared connector. We fetch and prepare each item once, no matter how many places end up using it.

And the fridge is yours. What's in it is shared across your team and stays inside your workspace.

What this changes for you

Once a source is shared instead of copied, you can use it in more than one place without paying the import cost again. And because it's already fetched and enriched, a Channel that subscribes to an existing source sees the data straight away, with no wait for a fresh ingestion and enrichment run.

Say a support inbox feeds a Channel that tracks the opportunities coming in. Next quarter, someone wants those same conversations in a Project, to answer one specific question. Today they'd import the inbox a second time. With a shared connector it's already there. The Channel keeps reading it, and they pull a copy into their Project to work on.

Your data isn't trapped wherever it first arrived. You connect a source once and reach for it where the work is, in Channels and in Projects, anywhere in your workspace.

Doing it without anyone noticing

The hard part is changing something this deep in the stack without anyone feeling it. We can't take ingestion offline to rebuild it, so we're doing it live, entirely behind the scenes.

The approach is what's usually called expand and contract. First we add the new shared model alongside the existing per-Channel one and write to both, so nothing is missed. Then we backfill, working through existing data in the background so it's represented in the shared model too. Once that's in place, each part of the product moves onto the shared version one step at a time, checked on its own rather than flipped all at once.

It's slower than a clean rewrite, and that's the point. Nothing skips a beat for you, and no Channel loses access to its data along the way.

Why it's worth doing

When this is done, you won't notice much, except that things feel a little quicker, and a source you've already connected is simply there when you want to use it again.

That's the quiet payoff. Dovetail is an always-on layer your whole team works from, and that's far easier to deliver when your data lives in one place in your workspace instead of in copies scattered across it. It also means the things we build next start from one clean source, not a pile of duplicates we have to reconcile first.

This isn't the kind of work that gets a launch, and we've made our peace with that. What we care about is quieter: your data gets easier to reuse and quicker to reach, and instead of sitting in scattered copies, it finally looks the same everywhere in your workspace.