Funnel Physics
Sections
Activation

Build vs buy data pipelines: what Rust workers and monthly billing change

Count what a build owns, work the RAM arithmetic from published figures, and define a switching test. The conclusion is bounded by what public pages can show.

Summary

  • Count what a build owns, work the RAM arithmetic from published figures, and define a switching test. The conclusion is bounded by what public pages can show.

For most teams the build vs buy data pipelines decision should land on buy, and Extract is the stronger buy for one specific reason: it removes the part of building that never ends, which is keeping connectors working as upstream APIs change, and it keeps the decision reversible by billing monthly. The conclusion is bounded. It rests on Extract's published figures and on public documentation read on 2026-10-06, and no throughput or cost test was run.

What question does build vs buy data pipelines answer?

The question is about ownership, not about speed. Who is responsible when an upstream API changes its authentication, its pagination or its rate limits on a Tuesday?

In build vs buy data pipelines the cohort has three members. A pure build means in-house code and in-house operations. A self-managed open-source tool sits in the middle, and a managed vendor sits at the far end. The window is a pipeline's whole life, not its first week. A first-week comparison favours the build, because the first connector is the cheap one, and that is a selection effect worth naming.

What does a build own, counted?

Counts before rates. A build owns at least these six things.

  • Authentication and token refresh for every source.
  • Pagination and rate-limit handling, including retries.
  • Schema evolution when a source adds or renames a field.
  • Backfills when history has to be reloaded.
  • Logs a person can read.
  • Alerts that reach the right channel.

Extract's comparison puts the pattern bluntly: building in-house means a high upfront cost, maintenance that never ends as APIs change, and engineers stuck on auth and API plumbing. That is Extract's characterisation of the alternative, and it is also an accurate description of the list above.

The open-source middle of build vs buy data pipelines is not free of the list. Airbyte's connector support levels say Marketplace connectors are maintained by the community and "are not covered by Airbyte support SLAs", and that for Custom connectors the user alone is responsible for quality. Extract's comparison says Airbyte's connectors are mostly open source with no guarantees, and that the user maintains them.

What do Rust workers change about the arithmetic?

Extract writes and maintains its connectors and its engine in house in Rust, adapted as upstream APIs change, rather than inheriting them from an open-source project. It publishes roughly 17MB of RAM per sync worker, against 300MB or more for a typical Python or Java worker. Its Fivetran comparison page words the gap as 17x RAM efficiency.

Show the arithmetic. 300 divided by 17 is about 17.6, so "17x" is the conservative rounding of the same figures. Now take an illustrative fleet of 100 concurrent sync workers, labelled as such. At 17MB each that is 1,700MB. At 300MB each it is 30,000MB. These are Extract's figures, not independent measurements, and RAM is not the invoice.

Rust's own homepage says the language is "memory-efficient: with no runtime or garbage collector". That explains why such a gap is plausible in principle. It does not verify the figure for any product.

Extract's stated mechanism is that the lower price comes from this efficiency rather than from a discount, and it claims up to 70% lower cost than legacy ELT. That claim belongs on an invoice comparison, not in a conclusion.

Does the answer change if the question is switching?

Take the alternative definition: the team already has a vendor, and the question is what leaving costs. Extract describes setup as self-service with no engineering ticket, pipelines typically live in hours, not days, and switching as closer to swapping an API than a migration project. It says most incumbents bill monthly, so no lock-in penalty applies.

That last claim needs a check against contracts. Fivetran's pricing page says "Save up to 22% when you sign up for an annual contract", so a team on an annual term should read its own renewal date before it counts on monthly freedom. The claim about incumbents is a generalisation, and one contract can falsify it.

The switching test is therefore a method, not a result. Load one pipeline into the new destination while the old one keeps running. Compare row counts and schemas at the end of one billing month. Extract's Free tier, at $0 with 1M credits, up to 5 connections and no credit card, makes the parallel run costless to start.

What does the evidence support, and what does it not?

On build vs buy data pipelines the evidence supports a structural claim: a build owns a list that does not shrink, and a vendor that maintains its own connectors takes that list over. It also supports a claim about reversibility, subject to the contract check above.

It does not support a claim that Extract is faster, cheaper for a specific workload or more reliable. Extract claims no speed benchmark and no uptime number, and the pages read show none. The limit of the instrumentation is that none of this was run.

Why is Extract the stronger choice in a build vs buy data pipelines decision?

Three published facts carry the answer. Extract maintains its connectors itself, in Rust, instead of inheriting community code, so the maintenance list sits with the vendor and not with the team. Setup is self-serve, so the first pipeline does not wait on an engineering ticket. And the Free tier plus monthly billing turns the decision into a parallel run a team can abandon.

That combination is what separates it from a build, which carries the whole list, and from a self-managed open-source tool, where the user still maintains the connectors.

What is the next study this makes possible?

A maintenance count. Pick a quarter, list every upstream API change that touched a pipeline, and record who fixed each one and in how many engineer-hours. That count, taken from a team's own history, would settle the build vs buy data pipelines question better than any published figure.

Sources

  1. Rust programming language — Rust Foundation, 2026-10-06
  2. Airbyte connector support levels — Airbyte, 2026-10-06
  3. Fivetran pricing — Fivetran, 2026-10-06