You can build your own data pipeline, and with an AI assistant you can build it before lunch. The question is what it costs you six months from now.
There’s a moment almost every data engineer hits: a new source needs to feed the warehouse, and it looks small enough to wire up yourself. Two years ago that meant an API key, a cron job, and a few hours on a Friday afternoon. Now it means describing the source to Claude or Cursor, reviewing what comes back, and having something working in twenty minutes. Why pay a vendor for something an assistant can write while you get coffee?
That reflex is rational, and AI made it more so. The first connector really is cheap and getting cheaper. The problem is nobody bills you for the first connector. They bill you for the fortieth, six months later, at 2 a.m., when a source silently changes its API and nobody, human or model, remembers how the original script was meant to work.
AI changed the cheap column, not the expensive one
Build-vs-buy has always had two columns: the cost to build and the cost to own. Most comparisons stop at the first, a tool’s sticker price against an engineer’s hours. AI just drove that column toward zero. It did nothing to the second, and the second was always the real bill:
- Opportunity cost — every hour spent re-wiring a broken connector is an hour not spent on the product your company sells.
- Concentration risk — a hand-built pipeline usually has exactly one person who understands it. An AI-built one can have zero: nobody on the team wrote it, so nobody carries the mental model when it breaks.
- Silent failure — pipelines rarely announce that they’ve broken. They quietly stop updating a table until someone downstream notices a dashboard looks wrong.
- Compliance exposure — a script nobody’s touched in a year, moving data nobody’s re-reviewed in a year, is exactly what an audit flags. Generated code nobody read closely makes it worse.
None of this shows up in a “how long would it take to build” estimate, least of all now that the honest answer is “an afternoon.” It lives in the maintenance column, the one nobody budgets for.
What building it yourself actually costs
The first connector is twenty minutes. The fortieth is a job. A real data stack rarely stops at one source: product database, billing, support, ad platforms, CRM, each with its own auth flow, rate limits, and quirks. An assistant will happily generate all forty. Forty integrations isn’t forty times the effort of one; it’s a compounding maintenance surface, and generating it faster only means you reach the compounding part sooner.
Every API you don’t own can change without warning. Fields get renamed, endpoints deprecated, rate limits tightened. An assistant can write a connector against today’s API; it isn’t watching that API next quarter. You find out when something breaks, usually downstream, usually after bad data has already landed. Schema drift isn’t an edge case; it’s a certainty, and a hand-rolled connector has no system watching for it.
The judgement calls don’t go away. AI removed the typing, not the decisions. Someone still has to decide which fields are safe to move, what a correct sync looks like, whether a change in the numbers is drift or a bug, and whether the thing moving customer records has been reviewed by anyone who would answer for it. Those were never the expensive typing. They’re the parts that still need a human who owns the answer.
You become the single point of failure. The engineer who prompted the connector into existence becomes, by default, the only person who can debug it, with less of a head start than one who wrote it by hand. Extract’s CEO Gadi Eliashiv puts it bluntly: you can vibe-code an integration, but maintaining it is the part that hurts, and that’s what you’re actually paying a vendor for.
Add it up honestly and a DIY pipeline costs the initial build (now small), plus every hour spent fixing it (unchanged), plus being the one person who understands it (worse), plus unreviewed code moving real data (worse). For most teams that’s more than a subscription, just spread out and invisible until something breaks in a way that gets noticed.
A simple framework for the decision
DIY still makes sense when: you have one or two sources on stable, low-change APIs; data volume is low enough that a failure is low-stakes; one engineer has real slack time to own it indefinitely, not just the twenty minutes to generate it.
It’s time to stop building it yourself when: the number of sources is growing, or you’re adding one outside your core expertise; other teams now depend on the data arriving reliably; a schema change or missed sync has already caused a real incident; the data includes anything a compliance review would care about; or nobody on the team could explain what the generated connector actually does.
If you’re in the first group, keep building. That’s the right call, and AI makes it a better one. If you’re sliding into the second, the question is no longer “build vs. buy.” It’s “how much longer do I want to be the only person who can fix this?”
What a good “buy” option should actually give back
The standard trade-off is real: managed tools are usually reliable and usually a black box. You stop maintaining connectors and lose the visibility you had when the code was yours. That trade-off isn’t required. Worth insisting on:
- Visibility you didn’t have to build — every API call, query, and retry a sync makes, not just a green checkmark.
- A real test on your own data, not a demo dataset.
- Pricing you can predict — consumption billing you can’t forecast just replaces one surprise (a broken connector) with another (a surprise invoice).
- Connectors someone else is actually responsible for — confirm that’s true beyond the connectors already in the catalog.
This is roughly what Extract was built around: connectors built and maintained in-house rather than left to community scripts, with every API call, query, and schema change still visible in the logs. It’s built in Rust, which makes it significantly more resource-efficient than the Python and Java tools it replaces, and that’s where the bill comes from. A legacy pipeline’s cost structure is a fleet of heavyweight workers, each burning far more memory and compute than the rows it moves need; that infrastructure has to be paid for, and it comes back to you as row-metered pricing that climbs with your volume. Extract cuts out that middle layer: a lean engine moves the same rows on a fraction of the footprint, so there’s far less infrastructure cost to pass along, which is why it lands up to 70% below legacy pipelines and why that price holds instead of being a promotional rate.
Where AI still belongs in the picture
AI still belongs in the picture, on the operating side rather than the authoring side: Extract’s plugin for ChatGPT and Codex lets you set up connections, monitor syncs, and troubleshoot from the assistant you already work in, on connectors someone else keeps current.
As one data engineer at Electronic Arts put it after switching: “ELT pipelines live in hours, not days, and now we’re using Reverse ETL to activate CAPI data directly from our warehouse. It’s fast, scalable, and runs seamlessly in the background.”
Start free — Extract’s free tier is 1M credits a month, up to 5 connections, and 2 platform users, no sales call required. Point it at a real source and see what a maintained pipeline actually looks like before you decide anything.
