Build vs buy for marketing data

A wrong buy costs money. A wrong build costs a year

Your engineers can stand up working connectors in a weekend, and they are right: that part really did get cheaper. Everything after that weekend did not.

  • 17Sections
  • 41Sourced references
  • No gateRead it all, free

What did not get cheaper

Money

The operating bill

It arrives every month after the weekend ends

Custody

The live keys to every ad account

Yours to rotate, scan and answer for in every security review

Time

The platform history that expires while you build

Retention windows delete it, and no later budget buys it back

Time

The months every project behind your data layer waits

They are spent whether the build lands or not

You are choosing between four things, not two

This page prices all four, months first and dollars second

  1. Option 01

    Build from scratch

    Your engineers own the connectors, the schema and the on-call

  2. Option 02

    Connector-only ELT

    Buy extraction, model it yourself in dbt

  3. Option 03

    A marketing-specific platform

    Connectors, normalization and credential custody as one bought function

  4. Option 04

    Hybrid

    Buy the layer that churns, build the part that encodes your judgment

The 90-second version

Nine claims, each linked to the section that argues it

Where a figure comes from someone's research, the tile names who paid for that research.

Colour is the clock Time Money The shape of the choice

  1. 01

    Time decides this, not money

    A late build costs the months a competitor spent compounding on a layer that already worked.

    Every cost line, months first →
  2. 02

    The finish line is on their calendar

    Google sunset three Ads API versions in 2026, LinkedIn ships monthly versions, TikTok promises no version lifetime. source 10

    Someone else's calendar →
  3. 03

    Four options, not two

    Build, connector-only ELT plus your own dbt models, a marketing platform, or hybrid. ELT wins on a few mainstream sources with a strong analytics team, loses on the long tail.

    The four options →
  4. 04

    Writing it is under 30% of the cost

    Initial development is under 30% of an integration's lifetime cost, by the analysis of a vendor that sells integration infrastructure. source 3

    What changed →
  5. 05

    53% of capacity already maintains pipelines

    Enterprise benchmark run by a company that sells ETL, so read it as a vendor number. source 13

    The four meters →
  6. 06

    35% of builders replaced a SaaS product

    A survey of builders run by a company that sells build tooling. Direction, not an enterprise average. source 1

    What changed →
  7. 07

    Some time cannot be bought back

    Retention windows delete the platform history a late build never captured.

    The four meters →
  8. 08

    Seven situations end in a build

    Three of them are not a pure build: two are build-and-buy, one buys connector-only ELT and builds the models on top.

    The seven situations →
  9. 09

    The buy case is a three-year argument

    If your horizon is one campaign, one migration or one program, none of these models apply to you.

    The cost lines →

What changed

Why this is a 2026 decision

2024

2026

the technical buyer opened the call asking why they should pay for connectors their own team could write

they open it with an architecture diagram and ask who the agents call into

What got cheap

Days

to stand up working connectors with current tooling. That concession is real.

78% of teams expect to build more of their own tools in 2026

and 35% already replaced a SaaS product with a build

Retool, 817 builders from its own user base: direction, not an enterprise average source 1

What did not

70%+

of an integration's lifetime cost is operating it, not writing it. Composio's own model source 3

57% of analytics engineers still spend most of the week maintaining datasets, flat year over year, in a year when 70% of them used AI at work

dbt Labs, n=459 source 6

What the AI adds to the bill

1.7x

more issues per pull request in AI-generated code, across 470 open-source PRs. CodeRabbit, which sells AI code review source 4

43% of AI-generated changes still needed manual production debugging after passing QA

200 SRE and DevOps leaders, commissioned by Lightrun source 5

The largest consumer of this data layer is not built yet

17% of organizations already run AI agents and more than 60% expect to within two years (Gartner, 2026 source 7). Whoever holds the platform credential at that seam decides what the automation is allowed to trust: where the key sits in the shape we run.

You can generate the pipeline in a weekend. You then operate that weekend for as long as the company exists, and four meters run while the build is unfinished.

Read the full argument, with every source

The question moved up a layer. In 2024 the technical buyer opened the call by asking why they should pay for connectors their own team could write. In 2026 they open it with an architecture diagram and ask who the agents call into. Different question, different failure mode: the first is about cost, the second is about what your automation is allowed to trust. Gartner's 2026 CIO and Tech Executive Survey puts 17% of organizations with AI agents already deployed and more than 60% expecting to deploy within two years (2026, source 7). Most readers of this page are deciding the custody of a data layer whose largest consumer has not been built yet. What makes that a custody question rather than a volume question is where the credential sits at the seam. In the shape we run, an agent reads through a gateway that injects the platform credential server-side, so the credential never reaches the agent, and every call it makes leaves an audit line naming who asked, for what, and in which workspace (where we fit). Get that seam wrong and the same automation runs on a key pasted into a context window, with nothing recording what it read. That architecture is argued at length in build vs buy in the agent era and zero-copy marketing data integration, both under Go deeper at the foot of this page. The decision itself has four shapes rather than two.

Take the build concession at full strength. A competent team with current tooling can stand up working connectors in days. In Retool's build-versus-buy report, 78% of teams expect to build more of their own tools in 2026 and 35% have already replaced at least one SaaS product with a custom build, across 817 builders drawn from Retool's own user base (Retool, 2026-02-17, source 1). That is a build-tool vendor surveying builders, so read it as direction, not as an enterprise average. At the front edge, a16z reports one CTO at one high-growth SaaS company saying nearly 90% of their code is now AI-generated, and a16z itself frames that as the bleeding edge rather than the norm (2025-06-10, source 2). One company, one CTO, and still worth knowing.

The same Retool sample carries a third figure, and it changes what the word "build" refers to: 60% report having built something outside IT oversight in the past year (source 1). A build nobody sanctioned has no scoped on-call, no compliance clock running, and nobody whose job it is to know where the credentials live. Every custody argument on this page lands harder against that build than against a reviewed one, which is why Meter 4 and steps 4 and 7 of the build plan matter most to the teams who do not think of themselves as having made a build decision at all.

The turn is not that AI cannot write connectors. The line AI made cheap was never the big one. By Composio's own analysis, a vendor's model rather than an external study, initial development often accounts for under 30% of an integration's total cost across its lifetime (2026-01-16, source 3). The rest, more than 70% of it, is operating cost, and that is where a 2026 build case has to be argued.

Part of that operating bill is written by the AI itself. Two measurements, each from a party with a stake, each named so you can weigh it:

AI-generated code produced about 1.7x more issues per pull request than human-written code, 10.83 against 6.45, across 470 real open-source pull requests. CodeRabbit, which sells AI code review, 2025-12-17 (source 4).

43% of AI-generated code changes still required manual production debugging after passing QA. Two hundred director-level and above SRE and DevOps leaders, fielded by Global Surveyz and commissioned by Lightrun, which sells production debugging, 2026-04-14 (source 5).

Neither is independent, and together they show only a direction: the part of the work that got cheap hands more of itself to review and then to production.

The structural version outlives whichever of those two numbers the next model release moves. In dbt Labs' State of Analytics Engineering survey, 57% of practitioners still spent most of their time maintaining and organizing datasets, flat year over year, in a year when 70% of them reported using AI in their work (n=459, 2025-04, vendor-published, source 6). AI was in the workflow. The share of the week spent keeping data usable did not move. You can generate the pipeline in a weekend. You then operate that weekend for as long as the company exists.

And the operating share is not only the bigger share. It is the share that runs concurrently with everything you have not shipped yet, and four meters measure what it costs while the build is unfinished.

The decision

You are choosing between four things, not two

  1. 01

    Build from scratch

    You buy
    Nothing.
    You own
    Connectors, normalization, the scheduler and the credential store. Every line in the build column.
  2. 02

    Connector-only ELT, modeled by you

    You buy
    Extraction and loading. Fivetran and Airbyte are the pure form; Supermetrics, Funnel and Adverity sell some modeling and sit nearer row 03.
    You own
    Modeling, metric definitions and cross-platform semantics in dbt.
  3. 03

    A marketing-specific platform

    You buy
    Connectors, a normalized schema, governance and credential custody as one function. This is our row.
    You own
    Your warehouse, your models, and the review at purchase and every renewal. What buying it does not fix.
  4. 04

    Hybrid

    You buy
    The layer that churns.
    You own
    The part that encodes your judgment. Warehouse and models stay where they are.

Where 03 beats 02

  1. Cross-platform normalization. A cost, an impression or a conversion means the same thing on every platform. The failure is silent: a metric that cannot be summed gets summed, and nobody notices until it is defended in a room.
  2. The long tail. Sources outside a mainstream catalog.
  3. Custody as a bought function. Governance and credential custody, instead of a standing internal one: the procurement section.

Where 02 beats 03

A small count of mainstream sources and a strong analytics engineering function already shipping dbt models daily. That team owns its semantics layer and would be buying a normalization it can write itself. Below that source count, option 02 is the cheaper answer and you should not call us. The cost lines print where we think it falls.

Hybrid is where 2026 lands, and not out of diplomacy

The data layer became something agents call into. Gartner expects 40% of enterprise applications to carry task-specific AI agents by the end of 2026, from under 5% in 2025 source 8. dbt Labs counts 900 or more data teams and partners on its MCP server, a company figure that includes partners and prototypes source 9.

Once an agent is the reader, the question is no longer who writes the connector but who is accountable for what it reads: whose credentials, whose schema, whose audit line. The two-clock test scores that.

Read the full argument, with every source

1. Build from scratch. Your engineers write and then operate the connectors, the normalization, the scheduler and the credential store. Every line in the build column is yours.

2. Connector-only ELT, modeled by you. Fivetran and Airbyte are the pure form of this row. Supermetrics, Funnel and Adverity get named alongside them, though each of those three sells some modeling of its own and sits nearer the line between this row and the next. In this shape you buy extraction and loading, and your analytics engineers own the modeling, the metric definitions and the cross-platform semantics in dbt. One disclosure: we cite Fivetran's enterprise benchmark for the maintenance argument in what runs while you build, and Fivetran is also a vendor in this row. Both are true at once. Read their research as a vendor's research, and their product as a real alternative to ours.

3. A marketing-specific platform. Connectors, a normalized schema, governance and credential custody bought as one function. That is our row, and where we fit states what buying it does not fix.

4. Hybrid. Buy the layer that churns, build the part that encodes your judgment, keep your warehouse and models where they are.

Option 3 beats option 2 in three places. First, cross-platform normalization semantics: making a cost, an impression or a conversion mean the same thing on every platform, across currencies, granularities, attribution windows and creative types. That failure is silent rather than loud - a metric that cannot be summed gets summed, and nobody notices until the number is defended in a room. Second, the long tail of sources outside a mainstream catalog. Third, governance and credential custody as a bought function rather than a standing internal one, the subject of the procurement section.

It does not beat option 2 for a team with a small count of mainstream sources and a strong analytics engineering function already shipping dbt models daily. That team owns and reviews its semantics layer, and would be buying a normalization it can write itself. There is a source count below which option 2 is the cheaper answer and you should not call us. The cost lines print where we think it falls, under the band table that earns it.

Hybrid is where this decision is landing in 2026, and not out of diplomacy. The data layer became something agents call into rather than something people read. Gartner expects 40% of enterprise applications to carry task-specific AI agents by the end of 2026, up from under 5% in 2025 (source 8), and dbt Labs reports 900 or more data teams and partners adopting its MCP server, a company figure that includes partners and prototype use rather than production deployments (source 9). Once an agent is the reader, the question is no longer who writes the connector but who is accountable for what it reads: whose credentials it holds, whose schema it trusts, whose audit line records the call. That is the question the two-clock test is built to score.

Two profiles this reads differently for

AgenciesYour source count is platforms multiplied by clients, and multi-tenant isolation is a build inside the build.

Your source count is platforms multiplied by clients: twelve platforms across forty clients is not a twelve-platform build, and scoring it as one puts you in the wrong band. Every hour on pipes is unbillable, so the build competes with revenue rather than with a budget line. Multi-tenant isolation is then its own build inside the build, and it moves the security boundary out of a battle-tested server into code your team wrote and now maintains. A leak between two clients is not a bug you fix next sprint. It is a client-loss event, and you disclose it to the client.

What a bought platform gives you against that is already built and publicly documented, so you can read it before anyone gets on a call with you. Each client gets a workspace of its own, and that client's data lands in separate tables in the same destination. Custom roles let a client's users see only their own dashboards, which the docs describe as "no risk of stumbling into another client's data". Access for sub-brands and teams runs from full access down to a filtered, view-only slice. White-label puts your own domain and logo on what the client sees, and sign-on runs through Okta or SAML. None of that cancels the warning above. It moves the boundary out of code your team wrote and into a product you then review, at purchase and at every renewal (the reviewer on the other side of the build). We would rather show this configured than describe it: pick a time and we will walk through two client workspaces side by side. That link asks for a work email, routes you, and then puts a calendar in front of you to pick a date and time. There is no document at the end of it.

Healthcare operatorsWhere the data is patient-adjacent, the build question is a compliance question wearing a cost costume. The same applies to any other regulated data.

Where the data is patient-adjacent, the build question is a compliance question wearing a cost costume. The credential the pipeline holds and the tracking pixel firing on a scheduling page are both regulated surface. The BAA question arrives before the architecture question: any outside party that touches this data signs one, and building in-house does not remove the obligation behind it. It keeps the whole regulated surface inside your own controls, your own audit and your own team. We sign a business associate agreement, and the HIPAA Security Rule opinion sits inside the scope of our SOC 2 Type II report (where we fit, which also lists the three certifications we do not hold). That gets a vendor through the gate. It does not decide the question, which is the rest of this page. Treat the compliance clock as a gating dependency, not a cost line: legal review runs before the data moves, not alongside the sprint. Ask any vendor for the SOC 2 Type II report itself and read what sits inside its scope: an attestation, examined, never a certification.

The platforms' clock

The finish line is on someone else's calendar

  • Google Ads API

    ~12 mo

    per major version, new version every three to four months. Three sunset in 2026 already: v19, v20, v21.

    Miss it: hard failure. A sunset version returns an error. Sunset schedule, read 2026-09-07 source 10

  • Meta Marketing API

    No floor

    Graph API promises two years. The Marketing API, the one ad data runs on, publishes no lifetime; recent sunsets landed near nine to twelve months.

    Miss it: two calendars, and the binding one has to be watched, not planned. Versioning guide, read 2026-08-31 source 10

  • LinkedIn Marketing API

    1 yr min

    Monthly versions, each named on every call, each supported for at least a year.

    Miss it: hard failure. A call that names no version is rejected; there is no default. LinkedIn versioning, read 2026-08-31 source 10

  • TikTok Marketing API

    Not published

    No version-lifetime guarantee in the policy. An absence, not an accusation.

    Miss it: unknown in advance. You can staff a response to a dated sunset, not to a date that does not exist yet. Developer guidelines, read 2026-08-31 source 10

One year on someone else's calendar

  1. Jan
  2. Feb
  3. Mar
  4. Apr
  5. May
  6. Jun
  7. Jul
  8. Aug
  9. Sep
  10. Oct
  11. Nov
  12. Dec
  • LinkedIn ships a new version every single month
  • Google Ads ships every three to four months, and sunsets on a date
  • Meta publishes no lifetime for the API ad data runs on
  • TikTok is on no square here, because it publishes nothing to plan against
  • 85+ changes across 19 platforms in one year, about seven a month source 11

85+ API changes in one year across 19 platforms, about seven a month, in one enterprise customer's appendix (2025-09-17). A severity grade, not a count of hard breaks, and one customer's record. source 11

Access is granted, not written. Enterprise API access to a single platform can run $30,000 to $50,000 a month, X the reported example as of 2025-09. One example, not a rate card, and no amount of AI-assisted development moves it. source 12

Access can be refused. In 2026-07 an app-store review at a major commerce platform blocked an entire connector class of ours, exemption denied. On that platform our standing bought nothing, and buying from us would buy you nothing either. Scope it platform by platform before you choose a path.

Read the full argument, with every source

Two clocks run against a build and only one of them is yours. Your clock is the months between kickoff and a reliable answer, which is what the cost section prices. The platforms' clock is the schedule they publish and you sign nothing to accept: version sunsets, retention windows, access reviews. Your clock stops when the team gets pulled onto something else. Theirs does not.

A connector is finished the day it works. An integration is never finished, because the platform on the other side ships breaking changes on a schedule you did not agree to.

"APIs change" is the easiest sentence here to write and the least useful, because it carries no date. The dates are public. Each row links to the platform's own policy page and the date we last read it.

What four ad platforms publish about version lifetimes

Platform Versioning policy Typical version lifetime What breaks if you miss it Source and read date
Google Ads API Google's own stated cadence is a new version every three to four months, and it aims to sunset a version one year after release. Point releases land between the majors, each with its own upgrade guide. Google states around twelve months for a major version and around ten for a minor. Three versions have already sunset in 2026: v19 on 2026-02-11, v20 on 2026-06-10, v21 on 2026-08-05. A fourth, v22, is posted for 2026-10 and marked tentative. Hard failure. Google separates the two states: a deprecated version still answers, a sunset version returns an error. Google Ads sunset schedule, read 2026-09-07; the v19, v20 and v21 sunset dates from the developer blog sunset reminders. source 10
Meta Marketing API Graph API versions carry a stated minimum of two years. The Marketing API is versioned separately, and we found no equivalent published lifetime commitment for it on Meta's versioning page. Graph API: two years minimum, published. Marketing API: not published. Recent sunsets have landed near nine to twelve months, which is our reading of the release history, not a commitment Meta states. Two calendars, not one, and for ad data the Marketing API's is binding. The binding one has no published floor, so it has to be watched rather than planned around. Graph API versioning guide, read 2026-08-31. source 10
LinkedIn Marketing API Monthly versions, with the version named on every call. A stated minimum of one year of support per version. Hard failure. A call that names no version is rejected, and there is no default to fall back on. LinkedIn versioning, read 2026-08-31. source 10
TikTok Marketing API TikTok publishes no version-lifetime guarantee. Not published. An absence in the policy, not an accusation about conduct. Unknown in advance, which is the planning problem. You can staff a response to a dated sunset, not to a date that does not exist yet. TikTok developer guidelines, read 2026-08-31. source 10

The Google row is worth checking yourself, and not for the sunset dates. The policy says a version lasts about a year. It does not say how many upgrade steps land inside that year, and we hold no count of them we can source. A point release is not a sunset and we do not count it as one, but each is still a diff somebody reads.

None of it arrives as one tidy annual migration. One enterprise marketing stack absorbed 85 or more API changes in a single year, about seven a month, across the 19 platforms its appendix itemizes, graded there as 20 or more critical (platform sunsets, complete API overhauls, v2-to-v3 migrations), 30 or more high (major version deprecations, authentication changes) and 35 or more medium (endpoint changes, new AI integrations, metric updates). That is a severity grade, not a split between changes that forced code on a date and changes that arrived as notice, so the 85 bounds the volume of changes that required a response rather than proving 85 hard breaks. It is one customer's appendix, 2025-09-17, not re-run since, with no research dataset behind it. source 11

Access is granted, not written

Now the half of the mechanism the calendar hides. You can write the code. That does not mean you are allowed to run it. Enterprise API access to a single platform can run $30,000 to $50,000 a month, with X's enterprise API the widely reported example as of 2025-09 (source 12). One example, not a rate card; do not extrapolate it across your list. It is a license, it is negotiated, and no amount of AI-assisted development moves it.

Access can also be refused, and the refusal does not respect who is asking. In 2026-07 an app-store review at a major commerce platform blocked an entire connector class of ours. The decision was stated as final and the exemption request was denied, recorded 2026-07-17. Read it as a buyer should: on that platform our standing bought nothing, and buying from us would buy you nothing either. Gatekeeping is a separate risk class from engineering, and it does not yield to effort, budget or better code. Scope it before you choose a path, platform by platform: a no there invalidates the build plan and the purchase order equally.

Which leaves the one line in a build plan with no number on it. How long a developer-account or partner-program approval takes is a declared unknown in our own modeling, and we left it blank. It sits on the critical path in front of the first useful line of code, and it is the only row where the answer can come back no and stay no.

What runs while you build

Four meters run the whole time you are building

  1. Meter 1. Capacity

    53%

    of enterprise engineering capacity already goes to maintaining and troubleshooting pipelines. Fivetran, 500 senior leaders at 5,000+ employee firms, 2026-03 source 13

    The people who absorb connector churn are the people who were going to build the thing a competitor cannot copy. A broken sync is visible this morning; a differentiating feature next year.

  2. Meter 2. Queue

    97%

    of senior data leaders said pipeline failures had slowed their analytics or AI initiatives. Same benchmark source 13

    Everything behind the data layer waits with it: the models, the attribution rebuild, the agent meant to read from this layer. A finished pipeline removes the dependency; the metric definitions stay your work.

  3. Meter 3. Evidence

    30 days

    of YouTube ads reporting retention, recorded in one enterprise customer's platform appendix, 2025-09-17. One dated record, not a policy citation: check your own top-spend platforms. source 14

    The one meter that does not reset when the budget does. Start a daily raw-payload capture today whichever way the decision goes: step 0 of the build order.

  4. Meter 4. Custody

    64%+

    of credentials leaked in 2022 were still valid in 2026-01. GitGuardian, which sells secrets detection source 15

    Every connector you ship is a standing credential you hold from then on. Slip a quarter and you add a quarter of keys to rotate, scan and answer for in every security review that follows.

Two receipts, separate findings

Moltbook exposed 1.5 million API keys and 35,000 email addresses; root cause a client-side database key shipped without row-level security, the founder's own words "I didn't write a single line of code". Wiz Research, 2026-02-02 source 16

And a rate, not an incident

CVE-2025-48757: row-level security missing in 170 of 1,645 scanned applications built on one AI application platform, roughly one in ten. source 17 The longer version: custody in the agent era.

Read the full argument, with every source

A build does not have a cost. It has a run rate. The build camp brings the number the project costs when it is finished. What decides the outcome is what is charged against you every month it is not. On the buy track those months compound on a layer that already works. On the build track they are spent getting to the layer, and four meters run the whole way: capacity, queue, evidence and custody. None of them appears in a build estimate.

Meter 1. Capacity

Fivetran, which sells managed pipelines, surveyed 500 senior leaders at organizations with 5,000 or more employees (published 2026-03-26) and found 53% of enterprise engineering capacity already going to maintaining and troubleshooting data pipelines (source 13). That maintenance exists is not the finding. Who performs it is. The people who absorb connector churn are the people who were going to build the thing a competitor cannot copy, and churn wins the tie every time: a broken sync is visible this morning, a differentiating feature next year.

One quarter of slip is one more quarter of your strongest engineers reading other companies' release notes.

Meter 2. Queue

Everything behind the data layer waits with it. In the same benchmark, 97% of senior data leaders said pipeline failures had slowed their analytics or AI initiatives (source 13). That is a queue, not a catastrophe: the models, the attribution rebuild and the agent meant to read from this layer inherit every week it slips. Be exact about what clearing it buys, though: a finished pipeline removes the dependency, it does not make the data mean anything. The metric definitions stay your work (where we fit).

Meter 3. Evidence

Platforms stop serving history you did not capture, and this is the one meter that does not reset when the budget does. It is also the meter most often overstated, so here is what we hold. One enterprise customer's platform-retention appendix, dated 2025-09-17, records a 30-day retention limit on YouTube ads reporting (source 14). One dated customer record is not a policy citation: check the retention limit on your own top-spend platforms before you plan around this one. The same appendix records a 37-month window on Meta. That one is an attribution window, not a retention limit. It bounds how far back a conversion can be credited, and it is not evidence that anything gets deleted.

Capture does not wait on the decision. A daily dump of raw platform payloads into object storage can start before anyone has picked a track, and you should start it today whichever way the decision goes. It is a bound rather than a cure, and both of its limits are stated where it belongs, at step 0 of the build order.

Meter 4. Custody

Every connector you ship is a standing credential you hold from then on, and the pile grows with the build, not with the launch. Those outlive the attention paid to them: GitGuardian, which sells secrets detection, retested credentials leaked in 2022 and found about 70% still valid in 2025-01 and above 64% still valid in 2026-01 (source 15), a validity tail longer than most build timelines.

Two receipts, and they are separate findings rather than one story. Moltbook exposed 1.5 million API keys and 35,000 email addresses, root cause a client-side database key shipped without row-level security, the founder's own description of the build being "I didn't write a single line of code" (Wiz Research, 2026-02-02, source 16). Separately, on a different platform, and this one is a rate rather than an incident, CVE-2025-48757 recorded row-level security missing in 170 of 1,645 scanned applications built on one AI application platform (source 17): roughly one in ten shipped without the access control its own platform expected. The longer version is in our piece on custody in the agent era.

Slip a quarter and you have not only added a quarter of work. You have added a quarter of keys to a set you now rotate, scan and answer for in every security review that follows.

The reviewer

The reviewer on the other side of the build

The file every reviewer wants

  1. A SOC 2 Type II report someone can read, not a logo
  2. A SIG or CAIQ workbook filled in by someone who knows the system
  3. Which standard contractual clause module you operate under: 2021/914, not the legacy ones
  4. A sub-processor register with the DPA chain behind every name
  5. Breach-notification windows written at 24, 48 or 72 hours source 21
  6. Current penetration-test evidence
  7. A policy pack of about 26 documents, kept current rather than written once source 19

None of it finishes. It renews with every contract you sign and every reviewer who asks again next year.

11

security questionnaires from nine clients over 2024-2025, then AI-specific reviews and an EU AI Act statement written from scratch in 2026. Our own inbound. source 19

3 to 12 mo

SOC 2 Type II observation window before the first report exists, then annually. Zero for you if the pipeline is never attested to third parties. source 18

3 years

of uptime history one enterprise RFP asked for. No budget compresses it; a build that starts today scores zero on that question until 2029. source 20

one questionnaire elapsed calendar, one 36-month scale

An internal build ships with no SLA

The internal customer has no committed response time, no service credit, nothing to escalate to but the manager of whoever is already awake. A vendor contract can name a P1 response target and an uptime target inside the DPA. Ours does; make every vendor put both numbers in yours.

The reviewer does not ask whether your pipeline works

They ask what you can evidence: for how long, under whose policy, with which sub-processors, and who answers at 03:00 on a Sunday. That file is accumulated, not purchased. Our own attestation and its limits: where we fit.

Read the full argument, with every source

Build the pipeline and you also become the vendor. Someone reviews it: your own security function, your clients if you are an agency, the partner whose data moves through it. That review is now harder to pass than the code was to write, and better tooling does not make it faster.

The security review is a standing function, not a project. Our own inbound is the receipt: nine clients sent eleven security questionnaires over 2024-2025, and the 2026 inbound added AI-specific security reviews and an EU AI Act statement that had to be written from scratch (source 19). Each one wants roughly the same file. A SOC 2 Type II report someone can read, not a logo. A SIG or CAIQ workbook filled in by someone who knows the system. Confirmation of which standard contractual clause module you operate under, meaning the 2021/914 modules and not the legacy ones. A sub-processor register with the DPA chain behind every name. Per-customer breach-notification windows written at 24, 48 or 72 hours (source 21). Current penetration-test evidence. A policy pack in the region of 26 documents kept current rather than written once (source 19). None of it finishes. It renews with every contract you sign and every reviewer who asks again next year.

Read the SOC 2 line at the right scope. A SOC 2 Type II observation window runs three to twelve months before the first report exists, and the examination recurs annually (source 18). It applies to a builder only if the pipeline itself becomes a service you attest to third parties: the agency reselling reporting, the shared-services team whose entities audit each other, the pipeline touching regulated data. For internal marketing analytics under the posture your company already holds, this line is zero, and the cost table carries it as zero. The dollar ranges are argued there.

Some of it cannot be bought at any speed. One enterprise RFP we answered asked for the last three years of uptime, including any major service outages (source 20). Three years of uptime history requires three years of uptime. No budget compresses it, no vendor sells it to you, and a build that starts today scores zero on that question for the next three years. Like the observation window above, it is denominated in elapsed calendar rather than dollars, and the asymmetry table scores it Never.

An internal build ships with no SLA. "We own it" sounds like control. In practice the internal customer has no remedy: no committed response time, no service credit, nothing to escalate to but the manager of whoever is already awake. A vendor contract can name a response target for a P1 incident and an uptime target written into the technical and organizational measures of the data processing agreement. Ours does. One enterprise customer made an enforceable SLA a precondition for renewal, which is what a buyer does when the number has to be real. Make us put both numbers in your contract, and make every other vendor do the same. Our own attestation and its limits are in where we fit.

The reviewer does not ask whether your pipeline works. They ask what you can evidence: for how long, under whose policy, with which sub-processors, and who answers at 03:00 on a Sunday. That file is accumulated, not purchased.

The asymmetry

Which mistake can you survive?

What comes back

comes back partly never

A wrong buy

2 come back, 2 partly, 1 never

  • The remainder of the contract termRuns out; you do not renewYes, at renewal
  • The months before you can prove the implementation is failingNothing. A kill date shortens them, it does not hand them backNever
  • The re-selection and the second migrationA scoped project, run twice, on your calendarPartly
  • Your dataLeaves with you, if you insisted on an open table format in storage you ownYes, fully
  • The domain knowledge your team did not buildNothing automatic. You bought their capacity insteadPartly

Bounded: a contract term, an export and a migration, all three visible from where you stand.

A wrong build

None comes back, 2 partly, 4 never

  • The quarters themselvesNothing. They do not come backNever
  • Platform history that retention windows deleted while you builtNothing once a window closes. Step 0 of the build plan is the cheap mitigationNever
  • Uptime and incident history you cannot backfillNothing faster. The record starts the day the system startsNever
  • The compliance clock, if the pipeline becomes an attested serviceNothing you can buy; the window is elapsed timeNever, where it applies
  • The standing credentials you now hold for every ad accountRevocation, once you have found all of themPartly
  • The standing team who now owns the layerMaking the same decision again later, plus a migrationPartly

No bound it did not write for itself. Writing one is step 7 of the build plan; it caps the loss from that day and hands back nothing already spent.

Five contract terms to demand from every vendor, this one included

  1. Data lands in storage you own, in an open table format. Leaving is a permissions change, not an export project. Our zero-copy delivery runs by request today, not self-serve: say so on the first call.
  2. A full-history export path you test before signing. During the evaluation, not during the renewal you are trying to escape.
  3. Credential revocation you control unilaterally, without filing a ticket with the vendor you are revoking.
  4. A documented exit that leaves your transformations intact, readable by someone who has never seen the vendor's console.
  5. A named SLA with named remedies, not a target. An internal build ships with none.

Money spent wrong is recoverable at renewal. The quarters are not

Read the full argument, with every source

Nobody says this part out loud in the meeting, and it can settle the call before expected value gets a hearing. A build that fails is absorbed as ambition: the team was stretched, the requirements moved, the headcount stays. A purchase that fails has one person's name on it and an invoice attached. Those failures are not scored on the same scale, so a reasonable person facing review picks the survivable one over the better arithmetic. Treating that as irrational is how vendor pages lose this room.

It is also why you should not trust a vendor telling you that building never wins. The downside of a wrong build lands on you and not on us, so we have no incentive to price it honestly. That is why the next three sections are the cost tables that price all four options, a test that can return build, and the situations that end in build, and why the plan for doing it is on this page at all.

Run the two failures forward and they are not symmetric in the other direction either. Both of them cost time; the difference is whether anything stops the clock.

What the mistake costsWhat it takes to get it backRecoverable?
A wrong buy
The remainder of the contract termIt runs out and you do not renewYes, at renewal
The months before you can prove the implementation is failingNothing. A kill date agreed up front shortens them; it does not hand them backNever
The re-selection and the second migrationA scoped project with an end date, run twice, on your team's calendarPartly
Your dataIt leaves with you, if you insisted on an open table format in storage you ownYes, fully
The domain knowledge your team did not build because they were doing something elseNothing automatic. You bought their capacity instead, spent elsewherePartly
A wrong build
The quarters themselvesNothing. They do not come backNever
The platform history that retention windows deleted while you builtNothing once a window closes. See the third meter; step 0 of the build plan is the cheap mitigation, on either pathNever
Uptime and incident history you cannot backfillNothing you can do faster. The record starts the day the system starts, and buyers ask for years of it (procurement)Never
The compliance clock, if the pipeline becomes a service you attest to third partiesNothing you can buy; the window is elapsed time. Zero for you if the pipeline is never attested (scope rule)Never, where it applies
The standing credentials you now hold for every ad accountRevocation, once you have found all of them (the custody meter)Partly
The standing team who now owns the layerMaking the same decision again later, and paying a migration on top of itPartly

Two rows are worth reading slowly. The wrong-buy half has Never rows of its own: the months before a failing implementation announces itself are spent whatever you do next, and a re-selection spends more. What differs is the bound. A wrong buy ends at a contract term, an export and a migration, all three visible from where you are standing. A wrong build has no bound it did not write for itself, so its rows keep accruing until somebody declares the build over.

That bound is writable in advance, and writing it is step 7 of the build plan: a stopping rule fixed before the first connector, four measures instrumented from day one, and someone other than the build lead holding the standing to invoke it. It does for the quarters what step 0 does for the retention history. It caps the loss from the day you write it, and it hands back nothing already spent. The asymmetry against a buy survives that, because a contract's bound is dated before you sign it and written by someone other than the person defending the spend, while a build's is one you have to author, fund, and then honor against your own sunk months.

The domain-knowledge row is the one pages like this usually score as free. It is not. A team that does not maintain the plumbing does not learn the plumbing: which field a platform quietly renamed, what a failed sync looks like at 02:00, why a number moved. Buying trades that knowledge for capacity, and the trade is good only if that capacity goes somewhere that matters more than the plumbing does. The trade is defensible on its merits. It is not free, and a vendor promising that you keep everything is selling.

One more claim, and it is ours rather than a finding: we believe the competitor who bought spent those same quarters compounding on a layer that already worked. No row in the register proves it, so weigh it as an argument.

What keeps a wrong buy inside the top half of that table is contract language, not vendor goodwill. Demand all five from every vendor you evaluate, this one included:

  • Data lands in storage you own, in an open table format. Then leaving is a permissions change, not an export project. Our own zero-copy delivery into storage you own runs by request today rather than self-serve, so if your evaluation depends on it, say so on the first call and make us commit to it in the contract.
  • A full-history export path you test before signing. Run it during the evaluation, not during the renewal you are trying to escape.
  • Credential revocation you control unilaterally, without filing a ticket with the vendor you are revoking.
  • A documented exit that leaves your transformations intact and readable by someone who has never seen the vendor's console.
  • A named SLA with named remedies, not a target. An internal build ships with none, which is its own problem.

Writing those down costs us something: they are the terms that reduce our leverage in a renegotiation you have not started yet. We would rather you hold them. A decision made out of fear of lock-in is how teams end up building something they never wanted to own, and a vendor who will not put these in a contract has answered the question you were about to ask.

Money spent wrong is recoverable at renewal. The quarters are not.

The cost lines

Every cost line, months first

One enterprise's three-year comparison, its own model, 2025-09-17 source 23

Months first

Four to five engineers, 18 to 24 months to parity on 17+ sources.

Then the dollars

  • Build, seven modeled lines$2,950,000
  • Build with the security line struck (most readers)$2,800,000
  • Buy: that customer's three-year subscription, one figure$1,200,000

elapsed calendar, one 36-month scale build, modeled buy, subscription only

A modeled total, one configuration, not a rate card and not a quote for you. The buy figure is the subscription only; the buy table below carries the lines it leaves out.

Who carries each line

the vendor carries it shared you carry it

  • A bought platform absorbs

    Connector build, connector maintenance, deprecation response, rate-limit engineering. For sources in the vendor's catalogue and for nothing else.

  • Partly

    Normalization semantics, data quality and backfills, multi-tenant isolation only if the platform ships client separation as a product.

  • Stays yours

    Transformation maintenance, your metric definitions, LLM inference for an agent-facing layer, your security review of the vendor at every renewal.

The crossover, as judgment rather than measurement

Below about ten mainstream sources, with a standing need, analytics engineers already shipping dbt models weekly, and no agency multi-tenancy or regulated-data surface, connector-only ELT plus your own modeling is the cheaper answer and you should not call us.

Above that, or with any of those conditions reversed, what you are buying is the normalization semantics and the long tail. The full tables below price build, buy, ELT and hybrid line by line, with the source and the flag on every row.

Open all six cost tables, with every source

Months is the first data column in the build, buy, ELT and hybrid tables below, because months is what you spend first. The lines most models leave out are the ones with no invoice attached. Where no publishable benchmark exists the row says so instead of carrying a round number.

One enterprise's three-year comparison

One enterprise customer ran this on its own scope in 2025, with us, on its own salary and infrastructure assumptions (source 23). The customer is not named. The build side is seven modeled line items. The buy side is one figure: the three-year subscription for that one customer's own configuration, as of 2025-09-17. It is a modeled total rather than a copied invoice, one configuration rather than a rate card, not a price list and not a tier, and not a quote for you. The model decomposes it no further, and neither do we.

So do not try to read this line against line. One column itemizes because it is a model of work you would do; the other does not, because it is a price for one configuration. Three things you can do instead, in this order. Read down the build column and mark which lines a bought platform takes off you and which it leaves, set out under the buy table below. Put your own quote variables beside that customer's, in the next block. Then get a quote and replace the buy figure with your own number.

Build, three yearsModeled cost
Development, year 1$670,000
Maintenance, years 2 and 3$1,000,000
Infrastructure$180,000
API access fees$150,000
Overhead and benefits, as modeled$600,000
Data-quality incidents$200,000
Security and compliance$150,000
Build total$2,950,000
Build total with the security line struck, which is the scope most readers are in. Our subtraction from that model's own seven lines, not a figure the model prints (source 23)$2,800,000
Buy, same three years, same scope: that customer's subscription, one figure, not decomposed$1,200,000

What the 30% is 30% of, the model does not record. The rate and the amount are both on the record; the base is not, which is why the row above reads "as modeled" rather than as a multiplier you can re-run. Our own arithmetic on that model's seven lines, not figures the model prints (source 23): 30% of development plus maintenance is $501,000, adding data quality gives $561,000, and only development, maintenance, data quality and security together reach about $606,000. The loading cannot be decomposed here, which is the same treatment the buy figure gets below and for the same reason - the model does not break it out, and we will not invent the breakdown. One consequence, printed rather than left for you to find: the struck-security row subtracts the $150,000 security line and leaves the loading exactly as the model set it. If any part of that loading was riding on the security line, the honest struck total is below $2,800,000, so the table overstates the build column and the error runs in our favor rather than yours. We would rather print the direction of that error than close it with a number the model does not support.

The model assumed four to five full-time engineers and 18 to 24 months to parity. Parity there meant one customer's own scope, set out in full at source 24: 17 or more sources in a single warehouse, normalized so a cost, impression or conversion figure means the same thing on every platform, backfilled as far as each platform's retention allowed, and operated with a named owner and a documented rerun path. The months belong to that scope, and a smaller scope is a smaller number. It is a build duration, not a payback date.

Three years is not a lifetime, and the two shares are not the same quantity. The under-30% figure at the top of this page is Composio's, and it is the share initial development takes of an integration's whole life, which runs well past any three-year window (2026-01-16, source 3). This customer's model stops at three years: $670,000 of year-1 development against $1,000,000 of maintenance in years 2 and 3 puts development at about 40% of the three-year people cost, which is our arithmetic on that model's own lines rather than a figure it prints (source 23). Both hold at once, and the longer the horizon runs the smaller development's share gets, but you should not have had to do that reconciliation yourself. One thing the model does not settle: at $500,000 a year the maintenance line runs at about three-quarters of the year-one rate, which reads like a smaller standing team than the one that built it, and the model records four to five engineers without saying how they are spread across the three years. This page argues that the operating half is the half that grows, so when you re-run this on your own numbers, that is the assumption to raise rather than the one to inherit.

What that one figure does not carry. It is the subscription. It is not everything buying costs, and the buy table below carries the lines it leaves out, from implementation and analyst time to renewal and an exit migration. None of those were priced into the $1,200,000, and several have no invoice attached on anybody's side. So the buy column here is a subscription total, not a buy-side total, and a complete buy-side model is larger than $1,200,000 by whatever those lines cost you. We would rather print that than have you find it.

Does the $150,000 security line apply under a buy? Partly, and smaller. That line is that customer's own assumption, and the model records the amount rather than the scope behind it. Under the scope rule in procurement, a pipeline that is never attested to a third party starts no examination clock and the line is zero: if that is you, strike it, which is the $2,800,000 row above. Under a buy, the examination and the annual penetration test sit with the vendor, and you ask for the report instead of commissioning one. What does not move: your own security review of that vendor at purchase and at every renewal, counsel time if the data processing agreement needs redlines, and every obligation you already owe your own customers. Those three sit on the buy table below, carry no dollar figure, and cost less than running an examination yourself. Less, not nothing.

Where your own configuration sits

We publish no tiers and no per-connector rate, so the honest substitute for a decomposed buy column is the set of variables a quote is actually built from. There are five. Two of them are on the record for that customer's configuration and three are not, and the gaps are printed as gaps.

VariableWhat moves itThat customer's configuration
Source countEvery platform, system and file feed landing in the layer. Agencies and shared-services teams multiply it by clients rather than counting platforms.17 or more (source 24)
Row volumeRows landed and kept. It tracks media spend and reporting granularity rather than headcount, so a good quarter moves it and your renewal date has nothing to do with it. This is the one that surprises people.Not recorded in the model
Destination countThe warehouses, BI tools and applications the layer writes to. A second team wanting its own target moves it.One warehouse (source 24)
SeatsHow many analysts and marketers you put in front of it.Not recorded in the model
Service levelResponse and uptime commitments, and whether anyone outside your team depends on the layer. It is the variable you should not trim to hit a number.Not recorded in the model

Two knowns and three blanks is the second reason that customer's total is not yours, on top of the first reason, which is that it was one configuration priced once, in 2025. Fill your own five in, then get an actual quote and finish your model with that number rather than with this one.

If you build

Cost lineMonthsDollarsSourceFlag
Connector build, first passThe fast part. The same 2026 internal cost model records more than a year to the first reliable dashboard.About $24,000 of engineering time for three basic connectors.One 2026 internal cost model, 2026-05 (source 25)Usually counted
Connector maintenanceEvery month the connector exists.$50,000 to $150,000 per integration per year, and a separate three-year scenario near $125,000. Two scenarios, not one arithmetic.Truto's own estimate rather than a study, 2026-03-11 (source 26)Usually undersized
Deprecation responseContinuous, on the platforms' calendars rather than yours.No published figure.Schedules in someone else's calendarUsually omitted
Rate-limit engineeringPermanent, and it is what on-call absorbs. Our fleet's error mix runs Rate Limited 35%, Auth Expired 25%, API Error 20%, Timeout 15%: throttling and expired auth, not novel bugs.No publishable benchmark. One platform's application id imposes a global ceiling of 20 requests a second on every account behind it. A different major platform is SOAP-only and blocks pattern reuse.Our own fleet records, audited 2026-06-17 (source 27)Usually omitted
Normalization semanticsFor as long as you keep adding sources.A mechanism, not a number. Cost, impression and conversion fields differ by currency, granularity, attribution window and creative type, and errors fail silently.Argued in the four optionsUsually omitted
Transformation maintenanceStanding. Evidence that this share of the week has not moved: what changed.Analytics engineering salary. No invoice.Cited thereUsually omitted
Data quality, monitoring, backfillsContinuous, and it competes for the capacity metered in what runs while you build.$200,000 across three years in the configuration above.Same modeled configurationUsually undersized
Multi-tenant isolationFrom the first client you separate. Agencies and shared-services teams only.No publishable benchmark. The security boundary moves out of a battle-tested server into code your team maintains, and a leak between two clients is a client-loss event rather than a bug.Our own architecture design notes, 2026 (source 29)Usually omitted
LLM inference for an agent-facing layerFrom the first agent that reads the layer.No figure we can publish. The mechanism is the point: it scales with adoption rather than source count, so it grows when the build succeeds.Declared unknownUsually omitted
Overhead and benefitsEvery payroll month.A modeled loading of $600,000 across three years on one team. The model records the rate and the amount but not the base the rate was applied to, so the line cannot be re-run: see the note under the three-year comparison above. The BLS figure in the hiring row measures benefits as a share of wages across the US economy. Different quantity, do not use one to check the other.Same modeled configurationUsually undersized
The on-call benchPermanent, and scoped to the service you actually run. See the two rows below.Headcount before dollars: eight engineers single-site, six per site across two, on-call capped at 25% of an engineer's time.Google SRE book, evergreen (source 33)Scoped, not universal
Hiring and rampNo publishable benchmark. No credible data-engineer time-to-hire or attrition figure exists. Use your last two hires.US data engineer median total compensation near $160,000; BLS puts benefits at about 42% on top of wages. 39% of organizations report difficulty hiring AI engineers, 24% for data analytics roles.levels.fyi, 2026-08 and BLS ECEC, 2025-06 (source 30); Infragistics, 2025 (source 31)No benchmark
Security and complianceScoped, not universal. See the two rows below, and procurement for when the clock starts at all.Examination $7,000 to $150,000, or $12,000 to $100,000 depending on the guide; penetration test $4,000 to $30,000. Both annual.Secureframe and Drata, 2025-2026 (source 18); Software Secured, 2025-2026 (source 32). The vendors' own cost guides.Modeled as one-time
The contracting surfaceStanding. It renews with every customer contract you sign.No dollar figure. Obligations itemized in procurement.Cited thereUsually omitted
Credential custodyStarts at the first OAuth token and outlives the project. Validity tail: what runs while you build.No publishable benchmark. Rotation, secret scanning, and the leak you have not had yet.Cited thereUsually omitted
Warehouse and infrastructureMonthly, for as long as you keep the history.Median Snowflake contract $100,000 a year, across a $20,000 to $600,000 range.Vendr marketplace data, 2026 (source 34)Usually counted
The migration treadmillRecurring, before any new feature. Dashboard and agent-framework migrations took about 25% of one quarter's engineering capacity here.No dollar figure. Price a quarter of your own capacity at your own loaded rate.Our own measurement, 2025-Q4 (source 28)Usually omitted
Historical data never capturedPermanent. Retention windows: what runs while you build.Cannot be repurchased at any price.Cited thereUsually omitted

"Our dev team will just add it to the roadmap" is a headcount statement rather than a schedule, and the rows above are what it resolves to. The roadmap is not the constraint. The standing team that owns every line above, after the launch dashboard ships, is the constraint, and it outlives whoever proposed it.

If you buy a platform

Cost lineMonthsDollarsSourceFlag
SubscriptionMonthly, from signature.Your quote. The five variables that move it are above.Your own contractUsually counted
ImplementationWeeks, and only if dates and named owners are in the contract rather than assumed.Your team's time alongside theirs.Declared unknownNo benchmark
Consumption and row-volume escalationIt moves when your spend and source count move, which is not your renewal date.Your quote. The most common way a data bill doubles without a renegotiation. Get the behaviour at twice your row volume in writing before you sign.Your own contractUsually undersized
Support-queue latency when their connector breaksHours to days per incident, and it is not your keyboard. You file a ticket; the dashboard is stale either way.No publishable benchmark. Ask for median first response and resolution by severity, and put the answer in the agreement.Declared unknownUsually omitted
Vendor-initiated schema changesWhenever the vendor versions the normalized tables your models read.Your analysts' time re-pointing models. Require a notice period, not a changelog.Declared unknownUsually omitted
A connector the vendor sunsetsThe gap between their sunset date and your replacement, on their calendar.The build column for that one source, at your cost.Build table aboveUsually omitted
Vendor acquisition or end of lifeUnpredictable, and not on your calendar.A migration you did not plan. The terms that bound it are in which mistake can you survive.Declared unknownUsually omitted
Time to support for a platform you start spending on next monthAsk for the median in weeks and the last three real examples with dates.No publishable benchmark, ours included, until you have those examples.Declared unknownUsually omitted
The source your vendor does not supportSame months as the build table, for that source.Same dollars. Buying removes this work from the platforms everyone has, not from your long tail.Build table aboveUsually omitted
Internal analyst timeDoes not go away. It moves from assembling data to interrogating it.No benchmark separates the analyst hours a platform removes from the ones it does not. Measure yours before and after.Declared unknownUsually omitted
Security review of the vendorYour own review cycle, at purchase and at every renewal.Internal time, plus counsel if the data processing agreement needs redlines. Ask for the SOC 2 Type II report itself, not a logo.Your security functionUsually omitted
Renewal and repricingAt every renewal date in the term.No publishable benchmark. Cap it in the contract rather than forecast it.Declared unknownUsually omitted
Migration cost on exitOne migration, whenever it comes.Estimate from your last one. An open format in storage you own keeps it an estimate rather than a rebuild.Declared unknownUsually omitted

What a bought platform absorbs from the build column, and what it leaves

This is the comparison that does not need a price, and it is the one to make. Every line in the build table above, and what a bought platform actually does with it. "Absorbed" here means for sources in the vendor's catalogue and for nothing else.

Build cost lineUnder a bought platform
Connector build, first passAbsorbed for catalogue sources, and only for those. Anything outside the catalogue is the build column again, at your cost and on your months.
Connector maintenanceAbsorbed for catalogue sources. This is the largest recurring line a purchase removes, and it is most of what you are paying for.
Deprecation responseAbsorbed for catalogue sources. The platforms' calendars do not change; who has to answer them does.
Rate-limit engineeringAbsorbed for catalogue sources, including the throttling and expired-auth mix that is most of the work.
Normalization semanticsPartly. Cross-platform field semantics for catalogue sources are the thing being bought. The metric definitions your own business argues about stay yours.
Transformation maintenanceStays yours. Nobody sells you your own models. Normalized data feeds the layer you already built rather than replacing it.
Data quality, monitoring, backfillsPartly. Pipeline-level monitoring and backfills for catalogue sources move. Checks that encode your business rules do not, and those are the ones that catch a silent change.
Multi-tenant isolationAbsorbed only if the platform ships client separation as a product. Ask to see it configured rather than assume it. Agencies and shared-services teams only.
LLM inference for an agent-facing layerStays yours. It scales with your agents' adoption rather than with who runs the pipeline underneath them.
Overhead and benefitsAbsorbed in proportion to the headcount you therefore do not hire. You still carry it on everyone you keep.
The on-call benchPartly. The pager for catalogue extraction moves. A named owner and a documented rerun path on your side do not, and never required the eight-engineer floor in the first place.
Hiring and rampAbsorbed in proportion. The analytics engineers who model the data are still your hires, and they are the ones the market is tightest for.
Security and compliancePartly. Answered above the build table: the examination moves, your review of the vendor does not.
The contracting surfaceStays yours. What you owe your own customers does not transfer. What changes is that you answer it with a vendor's report rather than with an examination you commission.
Credential custodyMoves rather than disappears. The tokens sit with the vendor instead of in your secret store. That is a transfer of custody, not a removal of it, and it is exactly what your own security review should be about.
Warehouse and infrastructureStays yours on the architecture this page argues for, where you keep your own warehouse. Pipeline compute moves; your storage and query bill does not.
The migration treadmillStays yours. The dashboard and agent-framework migrations in that row sit downstream of the pipeline, and buying the pipeline does not touch them.
Historical data never capturedAbsorbed forward only. Starting sooner means less history expires while you wait. Nothing at any price recovers what already expired.

Absorbed does not mean gone. Every line above that moves to a vendor comes back as one of the lines in the buy table you just read: their support queue, their schema changes, their sunsets, their renewal, and your migration if you leave. The honest form of this comparison is build lines you keep against buy lines you take on, and both columns have lines with no invoice attached. That is the part of it we can hand you without a price.

If you buy connector-only ELT and model it yourself

Cost lineMonthsDollarsSource
Extraction and loadingMainstream connectors exist on day one. Almost none of your months go here.Your quote. The one question to ask is what the price does at twice your current row volume, because that is the variable these contracts move on.Your own contract
Modeling and normalization semanticsWhere your months go instead: metric definitions, cross-platform semantics, and what a cost field means across currencies and attribution windows.Analytics engineering salary, standing.Argued in the four options
The long tail and proprietary sourcesSame months as the build column, per source.Same dollars.Build table above
Governance, credential custody, auditStanding, and split between you and the vendor. Write down which half is yours before signing.No publishable benchmark.Itemized in the procurement section

If you run a hybrid

Hybrid has no model of its own, and building one would be the error this section spends its length refusing. It is a composition: every line below is already priced in the build, buy or ELT tables above, and the only new information is which of them it comes from. The sorting rule is the one in the four options - buy the layer that churns, build the part that encodes your judgment, keep your warehouse and your models where they are. No total is printed, because the total is your own quote added to your own salary line, and neither of those is ours to print.

Cost lineMonthsDollarsWhich column it comes from
Catalogue connectors: first pass, maintenance, deprecation response, rate limitsThe implementation weeks in the buy table above, for sources in the catalogue, rather than the 18 to 24 months to parity in that one customer's build model above (source 24).Your quote. The five variables that move it are above.Buy. The largest recurring line a purchase removes, and the reason to run a hybrid at all.
The long tail and proprietary sourcesSame months as the build column, per source. A hybrid does not shorten these.Same dollars as the build column.Build. Count them before you assume the split favors you.
Cross-platform normalization semanticsBought rather than built for platforms in the catalogue; standing for everything outside it.In your quote for the catalogue half. Analytics engineering salary for the rest.Buy for the catalogue, build for the rest. What a cost or a conversion means across your own long tail is still yours to define.
Transformation, metric definitions, business-rule checksStanding, and this is the half a hybrid is deliberately keeping.Analytics engineering salary. No invoice, and it does not fall when the connectors move.Build, on purpose. Nobody sells you your own models.
Warehouse, storage and queryMonthly, for as long as you keep the history.The same warehouse line as the build table above.Build. Pipeline compute moves to the vendor; your storage and query bill does not.
Data quality, monitoring, backfillsContinuous on both halves.Pipeline-level monitoring in the quote; your own business-rule checks at salary.Split. The checks that catch a silent change are the ones that stay.
Credential custodyStanding, from the first token either side holds.No publishable benchmark.Split, and the split is where the seam sits. Catalogue tokens sit with the vendor, long-tail tokens sit with you, and a hybrid is the shape where the second set is easiest to lose track of. Write down where the line falls before you sign.
On-callThe pager for catalogue extraction moves. A named owner and a documented rerun path do not.No separate figure. Whether the 24/7 floor in the build table applies is a question about the service you promise rather than about the split: see the two rows at the end of this section.Split.
Overhead and benefitsEvery payroll month.Carried on the headcount you keep, which in a hybrid is the modeling team rather than the connector team. As modeled, on the caveat under the three-year comparison above.Build, in proportion.
Security and complianceTheir examination on their cycle; your review of them at purchase and at every renewal.The examination and penetration-test ranges in the build table apply only to a pipeline you attest to third parties yourself. Procurement carries the scope rule.Split. Both halves are already itemized in the build and buy tables.
Vendor sunsets, schema changes, renewal, exit migrationOn their calendar, not yours.The buy table above, in full.Buy. A hybrid takes on the whole buy-side risk column for the half it bought, and the five contract terms in which mistake can you survive are what bound it.
The migration treadmill and the agent-facing layerRecurring, downstream of the pipeline either way.Unchanged by the split.Build. Buying the pipes does not touch what sits on top of them.

Read the fourth column and the shape of a hybrid falls out: a subscription for the rows marked Buy, salary for the rows marked Build, and the Build rows never reach zero. That is why a hybrid is not a cheaper buy. What it buys is months on the catalogue half while your own months go to the modeling, and the sorting is only worth doing if the catalogue covers most of your source list. If your list is mostly long tail, the Buy rows cover less than they appear to and the arithmetic slides back toward the build column, and its months come with it.

What a connector costs, by band

Two figures from the same model look like they contradict each other: about $24,000 of engineering time for three basic connectors, and five or more engineers at roughly $750,000 a year fully loaded with about 60% of that effort landing on connectors (source 25, 2026-05). They are one model at two scales. This is the bridge, and only the first band has a number.

SourcesDollarsWhat changes at this band
1 to 3About $24,000 of engineering time, from the same modelA project. Rate limits are visible, an expired token is noticed the same day, and one person holds the whole thing in their head.
4 to 10No publishable benchmarkNormalization starts to bite. Two platforms disagree about what a conversion is, and the disagreement fails silently. Someone has to be reachable when a sync fails on a weekend.
11 to 20No publishable benchmarkThe error mix changes character: throttling and expired auth dominate, and one platform's global rate ceiling holds up everything behind it. Deprecations stop arriving one at a time.
21 and aboveNo publishable benchmarkFleet behaviour. Simultaneous failures across unrelated platforms in one day, protocols that block pattern reuse, and a backfill queue that is a standing capacity line rather than an event.

We will not fit a line through two points. Linear extrapolation from the first band (source 25) gives roughly $80,000 for ten connectors, and we do not believe it, because the curve bends on the mechanisms in the third column rather than on connector count. We hold no defensible figure for the upper three bands and will not invent one. The mechanism column is sourced from our own fleet (source 27); the dollars are not.

The crossover, as judgment rather than measurement. Below about ten mainstream sources, with a standing need, analytics engineers already shipping dbt models every week, and no agency multi-tenancy or regulated-data surface, connector-only ELT plus your own modeling is the cheaper answer and you should not call us. Above that, or with any of those conditions reversed, what you are buying is the normalization semantics and the long tail. That is judgment from our own fleet and our own customers rather than a measured crossover, and should be weighted as such.

The two rows that are zero for most readers

SOC 2. The observation window and the examination cost apply only if the pipeline itself becomes a service you attest to third parties. For internal marketing analytics under the posture your company already holds, this line is zero. The procurement section argues where it stops being zero.

On-call. For a batch marketing pipeline the honest floor is a named owner, a documented rerun path, a business-hours rotation, and an agreed staleness tolerance written down as a service level. A sync failing at 03:00 on a Sunday means the dashboard is stale on Monday morning and somebody reruns it. Nobody staffs eight engineers for that. The floor in the build table is what a genuine 24/7 production-service commitment costs, and it applies only if you are making one, to your own business or to a client. Hold any vendor including us to the contractual version rather than a headcount claim: a one-hour response target on a P1 incident and a 99.95% uptime target, written into the technical and organizational measures of our data processing agreement (2026-05-19, source 22). Make us put both in your contract and make every other vendor do the same. A target with no remedy attached is a marketing number, and an internal build has neither (procurement).

The test

The two-clock test

Gate 1

If policy forbids any third party holding credentials to your accounts, no total changes the answer: you build.

Gate 2

If the pipeline logic itself is what your customers pay for, you build that logic whatever the total says; the arithmetic still decides everything underneath it.

Part 1 Score seven factors 1 to 5, multiply by the weight, add. Range 20 to 100

FactorWeightA 1 looks likeA 5 looks like

  1. 1Platforms in scope today and in 18 months. Agencies: platforms times clientsx61 Three or fewer, not growing5 Twenty or more, growing quarterly
  2. 2Share of the mix on vendor release calendars rather than systems you controlx21 Mostly systems you control5 Mostly someone else's calendar
  3. 3Do you already run a data on-call with a named owner and a documented rerun pathx41 Yes, staffed and funded now5 No, and adding one is a hiring plan
  4. 4Does this pipeline become a service you attest to third partiesx21 No, internal analytics only5 Yes, and the attestation does not exist yet
  5. 5Does the pipeline logic differentiate youx21 It is what we sell5 The same layer everyone has
  6. 6Is the need bounded or standingx21 One campaign or migration, with an end date5 Standing, no end date
  7. 7Share of the mix whose retention window is shorter than your expected buildx21 None5 Several of your top-spend platforms

Where a total lands, with the four profiles placed

20 to 55 build-leaning 56 to 75 hybrid: buy the layer that churns, build the part that encodes your judgment 76 to 100 buy-leaning
  • Profile A84Buy-leaningTwelve-source ad-heavy enterprise, no data on-call
  • Profile B36Build-leaningThree-source B2B, internal CRM, one warehouse, a competent analytics engineer
  • Profile C54Build-leaningEight mainstream ad platforms, standing need, a data team already shipping dbt and carrying the on-call
  • Profile D60HybridProduct company whose attribution model is what it sells, marketing pipeline internal

Part 2 The delay meter. Three numbers, all yours, written before the meeting

  1. Projects queued behind the data layer
  2. Platforms whose retention window is shorter than your build
  3. Your own date for the first reliable answer, slip included

Worked example. Six projects, three platforms, 2027-Q4: six projects waiting fourteen months, and fourteen months of history off those three platforms that no later budget buys back. The projects are late. The history is gone.

Build-leaning: the seven situations, then the build order. Hybrid and buy-leaning: what to make both sides answer, then where we fit.

Read the full argument, with every source

Your clock is the months to a first reliable answer. The platforms' clock is the sunsets and retention windows in the finish line is on someone else's calendar. Part 1 scores the decision and Part 2 measures the distance between the two clocks. The weights and the band boundaries are our argument, not research, so the four worked profiles below are printed with their arithmetic visible: see what the instrument does before you trust it.

Two gates that come before the arithmetic

Two cases are settled before you score anything. If policy forbids any third party holding credentials to your accounts at all, no total changes the answer and the arithmetic below does not apply to you: you build. If the pipeline logic itself is what your customers pay for, you build that logic whatever the total says, and the arithmetic still decides everything underneath it - profile D below is that reader. Both cases are argued in the seven situations. Go to the build order.

Part 1: score seven factors, 1 to 5

Multiply each score by its weight and add. Weights sum to 20, so the range is 20 to 100.

FactorWeightScore 1Score 5
1. Platforms in scope today, and in eighteen months (agencies: score platforms multiplied by clients, not platforms)6Three or fewer, not growingTwenty or more, growing quarterly
2. Share of the mix on vendor release calendars rather than systems you control2Mostly systems you controlMostly someone else's release calendar
3. Do you already run a data on-call with a named owner and a documented rerun path4Yes, staffed and funded nowNo, and adding one is a hiring plan
4. Does this pipeline become a service you attest to third parties2No, internal analytics onlyYes, and the attestation does not exist yet
5. Does the pipeline logic differentiate you2It is what we sellThe same layer everyone has
6. Is the need bounded or standing2One campaign or migration, with an end dateStanding, no end date
7. Share of the mix whose retention window is shorter than your expected build2NoneSeveral of your top-spend platforms

Three of those need their scope said out loud. Factor 3 asks for a rerun path with a name on it, not a round-the-clock rotation; the staffing floor quoted for services with tight availability targets is priced in every cost line and is not a marketing-pipeline floor. Factor 4 scores 1 for most readers, because internal marketing analytics starts no attestation clock; the reviewer on the other side of the build carries the rule for when it does. Factor 7's windows are per platform and per surface, and the four meters shows which surface each belongs to.

  • 20 to 55, build-leaning.
  • 56 to 75, hybrid. An answer rather than a hedge: buy the layer that churns, build the part that encodes your judgment.
  • 76 to 100, buy-leaning.

Four profiles, scored

ProfileScores, factors 1 to 7ArithmeticTotalBand
A. Twelve-source ad-heavy enterprise, no data on-call4, 5, 5, 1, 5, 5, 424 + 10 + 20 + 2 + 10 + 10 + 884Buy-leaning
B. Three-source B2B, internal CRM, one warehouse, a competent analytics engineer1, 2, 2, 1, 4, 3, 16 + 4 + 8 + 2 + 8 + 6 + 236Build-leaning
C. Eight mainstream ad platforms, standing need, no attestation surface, a data team already shipping dbt and already carrying the on-call2, 5, 1, 1, 5, 5, 312 + 10 + 4 + 2 + 10 + 10 + 654Build-leaning
D. Product company whose attribution model is what it sells, with the marketing pipeline itself internal3, 4, 3, 2, 1, 5, 318 + 8 + 12 + 4 + 2 + 10 + 660Hybrid

Profile C is the reader of the seventh situation: 54 is a build verdict on an ad-platform mix with a standing need. Profile D is the first gate and the arithmetic agreeing rather than colliding. What D sells sits on top of the pipes rather than in them, so the gate settles the model and the score settles the rest. Hybrid at 60 is the right answer rather than a fudge: they build the model, which is the thing they sell, and they do not have to build the pipes underneath it.

Factors 1 and 3 are the two that can carry a real enterprise to build, and they carry it on facts rather than posture: a source count that is small and staying small, and a data on-call that already exists and is already funded. Factor 5 is where most readers find out they are buying.

Part 2: the delay meter

Three numbers, all yours. We do not supply your build duration. The two reference durations this page carries are in every cost line, each one organization's own modeling rather than a benchmark, and neither is interpolated into your number.

Worked example. Six projects queued behind the data layer. Three platforms whose retention window is shorter than the build. Your own date for the first reliable answer, slip included: 2027-Q4, fourteen months out. That is six projects waiting fourteen months, and fourteen months of history off those three specific platforms that no later budget buys back, less whatever each window still holds on the day you finish. The projects are late. The history is gone.

Now yours. Write them down before the meeting, not in it.

  1. Projects queued behind the data layer: ______
  2. Platforms whose retention window is shorter than your build: ______
  3. Your own date for the first reliable answer, slip included: ______

Build-leaning: go to the seven situations and find yours, then to the build order. Hybrid and buy-leaning: go to what to make both sides answer, then to where we fit and what we do not claim.

When building wins

Seven situations where building is the right answer

How each one ends

a build, no purchase attached build and buy buy connector-only ELT, build the models

  1. 01Build

    Sources on a release calendar you control

    Three or four systems, one warehouse, nobody asking for an attestation report. Build it.

    TestName every source you will still need in 18 months and who controls its release schedule. Your order database qualifies; ad platforms do not.

    WarningThe count only moves up. Rerun the test annually against the written list.

  2. 02Build and buy

    The pipeline is the product

    If the marketing data logic is what your customers pay for, you own it. Nobody should sell you your own differentiator.

    TestTake that part out of the product and ask whether your pricing survives. If the renewal conversation changes, it is yours.

    WarningYour logic ships when you decide; the token refresh underneath it ships when the platform decides, in one repository under one on-call.

  3. 03Build and buy

    A source nobody supports

    A proprietary or internal system, an acquired brand's homegrown stack, a partner feed on a bespoke contract. The market for that connector is you.

    TestSearch two or three vendor catalogs by name, then ask each whether they will build it under contract. No delivery date means no.

    WarningIn-house beside a dozen platform connectors, it queues behind every deprecation they absorb: the source only you need is the one that slips.

  4. 04Build

    You already run the standing function

    A funded data on-call with a named owner and escalation path, and third-party security reviews answered as a standing function. The overhead in every build model is already paid.

    TestAsk whoever owns the rotation how many people are on it and what happens at 03:00 on a Sunday. Names, immediately, means this case is yours.

    WarningThat rotation now absorbs someone else's release notes, monthly. Staffed on-call is not spare capacity, and the month it runs short is the month a version sunsets.

  5. 05Build

    A horizon shorter than the payback

    The buy case is a three-year argument. If the need has a defined end, scripts win and none of the models here apply to you.

    TestWrite the month the requirement stops as a date. If you cannot write it, the need is standing.

    WarningNothing enforces that date except you. Put the stop date in the decision document, with a name beside it.

  6. 06Build

    A hard sovereignty mandate

    If policy forbids any third party from holding credentials at all, custody rather than residency, you build. No vendor architecture satisfies a rule written that way.

    TestFind the sentence in the policy and read it literally. A residency rule has architectural answers. A custody prohibition does not.

    WarningThe mandate exempts you from nothing else: platforms keep deleting history while your policy review runs. Start raw capture the day you decide.

  7. 07Buy ELT, build the models

    A moderate ad-platform footprint, a standing need, and a team that already ships models

    Source count below the crossover, mainstream catalogued APIs, no compliance surface beyond your existing posture, dbt models shipping weekly. Buy connector-only ELT, build the models, do not call us.

    TestCount the sources you will still need in 18 months. Ask the person who would own the Monday rerun whether they already do that job. Both answers have to come back clean.

    WarningAll four conditions reverse inside a year, source count fastest: an agency of record adds a channel, an acquisition brings its stack. Set the review date now.

If one of these is yours, the sequence is in build in this order. Read what builders say a year later first, because those teams checked their conditions too, on the day they decided.

Read the full argument, with every source

Three of the seven do not end in a pure build, and the count is worth stating before it flatters us. Situations 2 and 3 are build-and-buy rather than build-instead-of-buy: we count them because the work is real and somebody does it either way, not because they argue against buying. Situation 7 ends in a purchase of its own, connector-only ELT for extraction with the models built in-house, so what it rejects is a platform like ours rather than buying as such. That leaves four that end in a build with no purchase attached, and five in total that end in a decision not to buy a platform like ours. Every warning carries a clock, because what ends these cases is a date rather than a cost line.

1. Sources on a release calendar you control

Three or four systems, one warehouse, nobody asking for an attestation report. Build it. Test: name every source you will still need in 18 months and who controls its release schedule; your own order database qualifies, ad platforms do not (someone else's calendar). Warning: the count only moves up, so rerun the test annually against the written list.

2. The pipeline is the product

Condition. If the marketing data logic is what your customers pay for, the joins, the attribution model, the normalization a client cannot get elsewhere, you own it. Nobody should sell you your own differentiator.

Test you can run today. Take that part out of the product and ask whether your pricing survives. If it does, it is utility; if the renewal conversation changes, it is yours.

Honest warning. The line sits higher in the stack than teams assume, and the halves run on different clocks: your logic ships when you decide, the token refresh underneath it ships when the platform decides, and both live in one repository under one on-call.

3. A source nobody supports

A genuinely proprietary or internal system: your own order database, an acquired brand's homegrown stack, a partner feed on a bespoke contract. The market for that connector is you. Test: search two or three vendor catalogs by name, then ask each whether they will build it under contract, and treat an answer with no delivery date as a no. Warning: in-house beside a dozen platform connectors, it queues behind every deprecation they absorb, so the source only you need is the one that slips.

4. You already run the standing function

Condition. Two things already true and funded. You carry a data on-call with a named owner and a documented escalation path, staffed for the hours your business needs rather than for a 24/7 production service (every cost line splits that floor by profile). And you answer third-party security reviews as a standing function. Whether a pipeline pulls a SOC 2 Type II examination of its own, and when that line is zero, is scoped in the reviewer on the other side of the build. Then the overhead in every build model here, ours included, is already paid.

Test you can run today. Ask whoever owns the rotation how many people are on it, what the escalation path is at 03:00 on a Sunday, and when it was last used. Names, immediately, means this case is yours. A pause means you are pricing a new function, not extending one.

Honest warning. The rotation you already staff now absorbs someone else's release notes, monthly, for platforms nobody on it chose and on dates nobody on it can move (the version calendars). Staffed on-call is not spare capacity, and the month it runs short is the month a version sunsets.

5. A horizon shorter than the payback

The buy case is a three-year argument, and the build case reaches parity later than most bounded programs end (every cost line). If the need has a defined end, scripts win and none of the models here apply to you. Test: write the month the requirement stops as a date; if you cannot write it, the need is standing. Warning: nothing enforces that date except you, and a script that outlives its bound becomes an unowned production dependency. Put the stop date in the decision document, with a name beside it.

6. A hard sovereignty mandate

Condition. If policy forbids any third party from holding credentials at all, custody of the credential rather than residency of the data, you build. No vendor architecture satisfies a rule written that way. Where the data is patient-adjacent, the mandate often arrives as a BAA question before it arrives as an architecture question, and the compliance clock is then a gating dependency rather than a cost line (the four options carries the profile differences).

Test you can run today. Find the sentence in the policy and read it literally. A data-residency rule has architectural answers. A credential-custody prohibition does not.

Honest warning. Delivery into storage you own under your own keys narrows this case, it does not close it. And the mandate exempts you from nothing else: platforms keep deleting their history while your policy review runs, so start raw capture the day you decide, not the day the architecture is approved (the four meters).

7. A moderate ad-platform footprint, a standing need, and a team that already ships models

Condition. Four things at once. Your source count sits below the crossover named in every cost line. The sources are mainstream platforms on catalogued, documented APIs rather than the long tail. There is no compliance surface beyond the posture your company already carries. And your analytics engineering team already ships dbt models weekly and can carry a data on-call with a named owner. Then buy connector-only ELT for extraction, build the models yourself, and do not call us. That is the third camp in the four options, and it is the case here an ordinary marketing-data reader can be in.

Test you can run today. Count the sources you will still need in 18 months, not the ones connected now. Then ask the person who would own the rerun path at 09:00 on a Monday whether they already do that job for something else. Both answers have to come back clean. Agencies count sources times clients, which usually ends the case in one step.

Honest warning. All four conditions are reversible inside a year, and the source count reverses fastest, because the next source arrives from a marketing team that never asked you: an agency of record adds a channel, or an acquisition brings its own stack. By then the crossover has moved past you and the build carries a year of sunk months. Set the review date now, and decide against the new count.

If one of these is yours, the sequence is in build in this order. Read what builders say a year later first, because those teams checked their conditions too, on the day they decided.

A year later

What builders say a year later

  1. Pattern 1

    The rename nobody saw

    The connectors ran. A field was renamed upstream, nothing threw an error, and the reporting quietly became wrong. A pipeline that breaks loudly gets fixed. One that keeps returning plausible numbers gets trusted instead, and every decision on it inherits the error.

  2. Pattern 2

    Built for one platform, needed for more

    A build scoped to a single platform shipped and worked. Scaling past it meant repeating the work platform by platform, so the team went looking for a pipeline partner. The build was not wasted. It was just not the thing they needed twice.

  3. Pattern 3

    Inherited from someone who left

    A stack still shaped by the table design of the person who wrote it, now somewhere else. Nothing was broken, and nothing could be changed cheaply. That is why reversibility is a step in the build plan rather than a preference.

None of these teams was incompetent. Each pattern is invisible in month two and obvious in month fourteen, the interval this whole page is about

Read the full argument, with every source

Every other section here argues forward. This one looks back, at teams that had already built and came to us anyway. Three patterns, no company names and no count of how many teams reported each, drawn from our own customer conversations through 2026-04 (source 35). Every team in that corpus went on to buy from us, which is the direction the bias runs; the register says what the corpus is worth.

The rename nobody saw. The connectors ran. Then a field was renamed upstream, nothing threw an error, and nobody noticed. The reporting just quietly became wrong. The cost table calls normalization semantics a mechanism rather than a number and says the failures are silent; this is the receipt behind that line. A pipeline that breaks loudly gets fixed, because it announces itself. One that keeps returning plausible numbers after the meaning underneath them changed gets trusted instead, and every decision taken on it inherits the error.

Built for one platform, needed for more. A build scoped to a single platform shipped and worked. Scaling past it meant repeating the work platform by platform, so the team went looking for a pipeline partner rather than build the same thing again. The build was not wasted. It was just not the thing they needed twice.

Inherited from someone who left. A stack still shaped by the table design of the person who wrote it, who is now somewhere else. Nothing was broken, and nothing could be changed cheaply, so the cost of that build turned out to be the cost of being unable to move it. That is why reversibility is a step in the build plan rather than a preference.

None of these teams was incompetent. What the three have in common is timing: each is invisible in month two and obvious in month fourteen, which is the interval this whole page is about.

The build plan

If you are building, build in this order

  1. Step 0

    Capture history before you design anything

    A daily dump of every platform's raw responses into object storage, on the day you decide, whichever way the decision goes.

    Every other step can start late. This one loses something each day it does not exist.

  2. Step 1

    Apply for access before you write code

    Every platform behind an app review or partner program goes on the critical path now.

    Code cannot buy access. An application filed in month four dates your launch from month four.

  3. Step 2

    Staff to the service level you are promising

    Business-hours rotation for a Monday-morning audience; the round-the-clock floor only for a real-time commitment to someone outside your team.

    The staffing bar comes from the promise you make about the data, not the pipeline's size.

  4. Step 3

    Start the compliance clock early, if it is yours at all

    Zero unless the pipeline becomes a service you attest to third parties.

    Money buys the examination. It does not buy the months the examination has to observe.

  5. Step 4

    Custody from day one

    Credentials in a vault with rotation and per-source scoping from the first connector, never a config file.

    Custody is a design decision at connector one, not a hardening pass you schedule for later.

  6. Step 5

    Subscribe to every deprecation calendar, with a named owner per platform

    One person per platform, named in a document, reads the release notes and files the work before it is urgent. Developer blogs, not status pages.

    Nobody owns a calendar that everybody watches.

  7. Step 6

    Keep the raw payloads beside the modeled tables

    An open table format in storage you own, with the step 0 captures kept next to the models.

    Then changing your mind in year two is a migration, not a rebuild.

  8. Step 7

    Write the stopping rule before you write the first connector

    A month count, a second missed date, a maintenance share; four measures instrumented from day one; someone other than the build lead holds the standing to invoke it.

    A build with no stopping rule does not fail. It continues, and the case for stopping gets harder every month.

Run this sequence, and if it works you made the right call. That is a real outcome, not a consolation prize

Read every step in full

If the two-clock test came out build-leaning, if one of the situations where building wins is yours, or if you already knew, here is the sequence and why the order matters: each step is either irreversible, or runs on a clock that is not yours and starts late by default.

Step 0. Capture history before you design anything

On the day you decide, start a daily dump of every platform's raw responses into object storage: before schema design, before hiring. It is worth doing whichever way the decision goes, because retention windows do not pause for an architecture review; the third meter makes that case. Two limits keep it from being a cure. It cannot recover what already fell outside a window, so it caps the loss at the day you start rather than the day you decided. And raw payloads are not a history anyone can query, so normalizing them is the same work in the same queue.

Every other step can start late. This one loses something each day it does not exist.

Step 1. Apply for access before you write code

Developer accounts, partner programs and enterprise API licensing gate everything downstream; the calendar section carries the dates and the licensing line. Put every platform behind an app review or partner program on the critical path now, and ask what access requires before you promise a date. Approval time has no owner and no published benchmark, so no schedule you write can promise it.

Code cannot buy access. An application filed in month four dates your launch from month four.

Step 2. Staff to the service level you are promising

Internal marketing analytics with a Monday-morning audience is a business-hours rotation: a named owner per source, a documented rerun path, and enough people that one vacation is not an outage. A layer under a real-time commitment to someone outside your team, client dashboards under contract or bidding automation, is the other regime and its round-the-clock floor. The cost tables price both.

The staffing bar comes from the promise you make about the data, not the pipeline's size.

Step 3. Start the compliance clock early, if it is yours at all

This step is zero for you unless the pipeline itself becomes a service you attest to third parties: procurement carries the scope rule and the cost tables carry the money. If it is yours, start before you need the report rather than when a customer asks, because the observation window is elapsed time.

Money buys the examination. It does not buy the months the examination has to observe.

Step 4. Custody from day one

Credentials go into a vault with rotation and per-source scoping from the first connector, never a config file. The custody meter is the reason: the pile grows with every connector and the keys outlive the attention paid to them. Aim it hardest at the work nobody reviewed: a shadow build that never passed a review never had its credential handling reviewed either.

Custody is a design decision at connector one, not a hardening pass you schedule for later.

Step 5. Subscribe to every deprecation calendar, with a named owner per platform

Use the version table in the calendar section as the starting list, then extend it to the rest of your mix, including the platforms that publish no lifetime at all. One person per platform, named in a document, reads the release notes and files the work before it is urgent. Subscribe to the developer blogs, not the status pages: deprecations are announced on one and discovered on the other.

Nobody owns a calendar that everybody watches.

Step 6. Keep the raw payloads beside the modeled tables

Land data in an open table format in storage you own, and keep the step 0 captures beside the modeled tables instead of deleting them once the models look right. Whoever inherits this in year three was not in the meeting where you chose the schema, and the payloads still answer what your model cannot.

Then changing your mind in year two is a migration, not a rebuild.

Step 7. Write the stopping rule before you write the first connector

Decide now, in writing, what would make you stop building and buy: a month count, a second missed date, a maintenance share crossing a line you draw today, while you have nothing sunk to defend. Then instrument four things from day one, so that in six months the answer is measured rather than argued: breaking changes absorbed per month, hours per quarter rotating credentials, time to first reliable dashboard per source, and the maintenance share the first meter benchmarks. Give someone other than the build lead the standing to invoke the rule. Written before the first connector, it is the build's own answer to the asymmetry: the bound a contract hands you for free is the one a build has to author for itself.

A build with no stopping rule does not fail. It continues, and the case for stopping gets harder every month you have already spent.

Run this sequence, and if it works you made the right call. That is a real outcome, not a consolation prize.

The meeting kit

What to make both sides answer

Ask your own engineers

  1. Who owns each platform's deprecation calendar, and what happens the week two sunsets land together?
  2. What is the plan for a connector denied at app review, with no appeal?
  3. How many months of history do we lose, per platform, if this slips two quarters?
  4. Where do the credentials live on day one, and who rotates them?
  5. What does on-call cost in headcount, not in volunteers, at the service level we are promising?
  6. What does the eleventh source cost compared to the third?
  7. What does this team stop building while they build this?
  8. Have we already rebuilt part of this once, what did that cost, and who owns the next rebuild?
  9. What is our median time to support a platform marketing starts spending on next month?
  10. What does our bill look like at twice today's row volume?
  11. Is what we build API-addressable, and who keeps that contract stable when schemas move?

Ask every vendor, including us

  1. Where does our data physically live, byte by byte, and what stops working if we deny you storage?
  2. What can you see inside our accounts, and how do we revoke it without asking you?
  3. Can we read your SOC 2 Type II report, what is in its scope, and which certifications do you not hold?
  4. What is your response commitment when a platform sunsets an API version?
  5. How far back can you backfill each platform in our mix, and where does its own retention stop you?
  6. What do we keep, in what format, the day we leave, and can we test that export before signing?
  7. How many of the platforms in our specific mix do you maintain today, by name?
  8. What is your median time to support a platform that is not in your catalogue today?
  9. What happens to our price at twice our current row volume?
  10. Is the layer API-addressable, and what does the API return that the dashboard does not?
  11. What does a connector to a source you do not support cost, who builds it, and who owns it after?

If you run a bake-off, specify one we can lose

Three entrants: connector-only ELT with your own dbt models, a marketing-specific platform, and your own build. One fixed question that needs yesterday's numbers joined across two platforms, one annual budget for all three, criteria written down before any vendor sees them. A bake-off between two chat windows measures writing, not data.

Raise the build option yourself, in the first meeting

A build case argued in the room can be answered. One raised in the hallway after the vendor has left wins by default, because nobody is there to answer it.

Read the full argument, with every source

Whichever way the test came out, the meeting still happens. Copy both lists and take them into the room. They are the same length and the same difficulty on purpose: if the vendor questions come out softer than the engineering questions, the exercise is theater, and everyone in the room can tell.

Ask your own engineers

  • Who owns each platform's deprecation calendar, and what happens the week two sunsets land together?
  • What is the plan for a connector denied at app review, with no appeal?
  • How many months of history do we lose, per platform, if this slips two quarters?
  • Where do the credentials live on day one, and who rotates them?
  • What does on-call cost in headcount, not in volunteers, at the service level we are promising?
  • What does the eleventh source cost compared to the third?
  • What does this team stop building while they build this?
  • Have we already rebuilt part of this once, what did that cost, and who owns the next rebuild?
  • What is our median time to support a platform marketing starts spending on next month?
  • What does our bill look like at twice today's row volume?
  • Is what we build API-addressable, and who keeps that contract stable when schemas move?

Ask every vendor, including us

  • Where does our data physically live, byte by byte, and what stops working if we deny you storage?
  • What can you see inside our accounts, and how do we revoke it without asking you?
  • Can we read your SOC 2 Type II report, what is in its scope, and which certifications do you not hold?
  • What is your response commitment when a platform sunsets an API version?
  • How far back can you backfill each platform in our mix, and where does its own retention stop you?
  • What do we keep, in what format, the day we leave, and can we test that export before signing?
  • How many of the platforms in our specific mix do you maintain today, by name?
  • What is your median time to support a platform that is not in your catalogue today?
  • What happens to our price at twice our current row volume?
  • Is the layer API-addressable, and what does the API return that the dashboard does not?
  • What does a connector to a source you do not support cost, who builds it, and who owns it after?

If you run a bake-off, specify one we can lose

Three entrants, not two: connector-only ELT with your own dbt models, a marketing-specific platform, and your own build or the part of it you already run. One fixed question that needs yesterday's numbers joined across two platforms. One annual budget for all three. Criteria written down before any vendor sees them, and more than one criterion: time to the first correct answer, who can produce the second answer without the vendor in the room, where each number came from when you ask both sides, what happens when a platform retires an API version mid-test, and what the whole thing costs inside that budget. A bake-off between two chat windows measures writing, not data.

If connector-only ELT plus your own models wins that comparison, that is information you should have, and we would rather you got it from a specification we wrote than from a surprise in month nine. Take every cost line and the five contract terms in which mistake can you survive into the same meeting.

One tactical note, worth more than any statistic on this page: raise the build option yourself, in the first meeting, before someone else raises it after. A build case argued in the room can be answered. A build case raised in the hallway once the vendor has left wins by default, because nobody is there to answer it.

Where we fit

Where Improvado fits, and what we do not claim

Connectors

1,000+

maintained connectors, as of 2026-08-13 source 36

Schema

One

normalized schema, so a metric means the same thing on every platform

Agents

MCP

gateway that injects credentials server-side, so an agent never holds a platform key, and every call leaves an audit line

Delivery

Iceberg

zero-copy delivery into storage you own, by request today rather than self-serve

At scale

1.69bn

records, one enterprise brand

1.5bn

rows, one agency

One enterprise brand runs 1.69 billion records across 573 tables from 17+ sources; one agency runs over 1.5 billion rows across 2,379 tables. Anonymized production numbers, 2025-2026 source 38

What buying this does not fix

  • The source nobody supports. Your internal systems stay a build: scope a platform takes on, not a reason to build the whole layer.
  • Your semantics, and the layer you already built. Metric definitions, attribution logic and the models on top stay yours. What moves off your team is connector churn.
  • Platform outages. No contract makes someone else's API come back up.

Attested, and not held

  • SOC 2 Type II attested. Clean unqualified opinion, 46 of 46 controls, report issued 2026-06-26, HIPAA Security Rule opinion inside the scope. We sign a BAA. GDPR as a processor, CCPA, annual external penetration test. source 37
  • An attestation, not a certification. We use those words on purpose.
  • Not held: ISO 27001, PCI DSS, FedRAMP. If your questionnaire hard-requires any of the three, we fail it, and you are better off learning that here than on the third call.

Three customers, in public

90h

a week saved, ASUS

82%

less engineering time on attribution, AdRoll

3x

ROI during implementation, SoftwareOne

ASUS reports about 90 hours a week saved source 39; AdRoll 82% less engineering time on attribution and 300% first-year ROI source 40; SoftwareOne 3x ROI during implementation source 41.

What that is worth

150+

enterprise customers

Three self-reported numbers with names on them, not a benchmark: the baselines belong to those customers and none is a comparison against the build they did not run. 150+ enterprise customers source 36, and not all of them would have been wrong to build.

Read the full argument, with every source

If the test came out build-leaning, use the build order and do not call us. If it came out hybrid or buy-leaning, this is the layer we think you should not build, and this is what buying it does not fix.

The position: keep your warehouse, keep your agents, change the custodian of the part that breaks. That means maintained connectors across 1,000+ platforms (source 36, as-of 2026-08-13), one normalized schema so a metric means the same thing on every platform, one MCP gateway that injects credentials server-side so an agent never holds a platform key, and zero-copy delivery that writes Apache Iceberg tables into storage you own, which we run by request today rather than self-serve. What we will sign for, and that one term we do not meet as standard, is in the five contract demands.

What buying this does not fix

  • The source nobody supports. Your internal systems, and the one platform your category invented, stay a build. That is scope a platform takes on, not a reason to build the whole layer. Ask any vendor what one costs, how long it takes and who maintains it in year two (the meeting kit).
  • Your semantics, and the layer you already built. Metric definitions, attribution logic and the models on top of them stay yours; that is the work that encodes judgment, and a connector encodes none of it. Normalized data feeds your layer rather than replacing it, so what moves off your team is connector churn.
  • Platform outages. No contract makes someone else's API come back up. A vendor can own the version sunsets, the on-call rotation and the audit trail, not Meta having a bad afternoon.

Whether it holds at your scale, and whether there is an API

Two production numbers, anonymized, because a dashboard demo does not answer this question. One enterprise brand runs 1.69 billion records across 573 tables from 17 or more sources; one agency runs over 1.5 billion rows across 2,379 tables (source 38, 2025-2026), and the per-client workspaces, roles, white-label and single sign-on an agency buys are listed with their docs in the agency profile. The layer is machine-addressable rather than dashboard-only: agents reach the normalized tables through the MCP gateway, and on the by-request zero-copy path those tables land in storage you own as open Iceberg data that other Iceberg-aware engines can read.

Attested, and not held

SOC 2 Type II attested: clean unqualified opinion, no exceptions, 46 of 46 controls, report issued 2026-06-26, with a HIPAA Security Rule opinion inside the report scope (source 37). We sign a business associate agreement, which is where the healthcare reader's first question actually lands (the four options). GDPR as a processor, CCPA, and an annual external penetration test. It is an attestation and not a certification, and we use those words on purpose.

What we do not hold: no ISO 27001, no PCI DSS, no FedRAMP. If your questionnaire hard-requires any of the three, we fail it, and you are better off learning that here than on the third call.

What three customers say, and what that is worth

  • ASUS reports saving about 90 hours a week (source 39, read 2026-08-31; the case carries no publication date, so that read date is all we can stamp on it).
  • AdRoll reports 82% less engineering time on attribution and 300% ROI in the first year (source 40, 2026-05-22).
  • SoftwareOne reports 3x ROI during implementation rather than after it (source 41, 2026-05-22).

What those establish is that three customers put a number in public with their name on it. What they do not establish is a benchmark you can plan against: each is one customer, self-reported in a case study we published, the baseline and the counting method belong to that customer and are not published, and none is a comparison against the build they did not run. We have 150+ enterprise customers (source 36, as-of 2026-05). Not all of them would have been wrong to build, which is why seven situations are on this page.

The register

The evidence, and who paid for it

The register, 41 rows

How this register is built, and how to report a defect

No independent research on this question exists that we could find, and almost every survey figure below was published or commissioned by a party that sells something on one side of the answer, ours included. The Who paid for it column says which, row by row. The facts this page leans on hardest are not survey research at all: the platforms' own published version policies (source 10), the US Bureau of Labor Statistics on benefit load (source 30) and Google's own on-call arithmetic (source 33) are primary documents nobody commissioned, and you can check all three without us.

Rows are grouped the way the page argues: the market shift first, then the calendar and what running a pipeline costs, then custody and security, then procurement, then our own numbers and the three customer outcomes. Two rules hold this table together. A figure printed on this page carries a row here, reached by a link from the sentence that prints it. And a row here is cited by at least one claim on the page. We walked that map in both directions on 2026-09-07: every figure above reached its row from the sentence or the table that prints it, and every row below was reached from at least one claim. That map is also exactly the kind of thing that breaks the next time a long page is edited, so if you find a printed figure with no row, or a row nothing on the page cites, treat it as a defect rather than a judgment call: write to info@improvado.io and we will correct it and re-stamp the review date. Where the page gives a mechanism instead of a number, that is deliberate, and What we do not know below says which. Sources last reviewed 2026-09-07, which is not this page's publish date.

The register

#ClaimSourceSampleAs-ofWho paid for it
178% expect to build more of their own tools in 2026; 60% built something outside IT oversight; 35% replaced a SaaS product with a buildRetool, The Build vs Buy Shift817 builders from Retool's own user base2026-02-17Retool, which sells build tooling
2One CTO at one high-growth SaaS company reports nearly 90% of code is AI-generateda16z, How 100 Enterprise CIOs Are Building and Buying Gen AIOne CTO at one company, framed by a16z as the bleeding edge, not a market average2025-06-10a16z, which invests in the category
3Initial development is under 30% of an integration's lifetime costComposioThe vendor's own analysis, no external study behind it2026-01-16Composio, which sells integration infrastructure
4AI-generated code carried about 1.7x more issues per pull request, 10.83 against 6.45CodeRabbit, State of AI vs Human Code Generation470 real open-source pull requests2025-12-17CodeRabbit, which sells AI code review
543% of AI-generated changes still need manual production debugging after passing QAFielded by Global Surveyz, reported by VentureBeat200 director-level-and-above SRE and DevOps leaders2026-04-14Commissioned by Lightrun, which sells production debugging
657% of practitioners spend most of their time maintaining and organizing datasets, flat year over year; 70% of the same respondents reported using AI in their workdbt Labs, State of Analytics Engineering459 practitioners2025-04dbt Labs, which sells the transformation tool
717% of organizations have deployed AI agents; over 60% expect to within two yearsGartner CIO and Tech Executive Survey, via Gartner's agentic AI Hype Cycle articleGartner's own survey panel2026Gartner, subscription-funded, no sponsor disclosed
840% of enterprise applications will carry task-specific AI agents by end-2026, up from under 5%Gartner press releaseA forecast, not a measurement2025-08-26Gartner, same
9More than 900 data teams and partners have adopted the dbt MCP serverdbt Labs blogA company count including partners and prototype use, not production deployments2025-10-14dbt Labs
10Google Ads API: three sunsets in 2026 (v19 2026-02-11, v20 2026-06-10, v21 2026-08-05), each version sunset about a year after its release, each carrying its own upgrade guide. Meta: Graph API two-year minimum per version, Marketing API on its own schedule. LinkedIn: monthly versions, one-year minimum support, unversioned calls rejected. TikTok: no published version-lifetime guarantee. Google states that major versions last around 12 months and minor versions around 10, and lists v22 (released 2025-10-15) with a tentative sunset of 2026-10, a date it says can move within that month.The four platforms' own developer documentation, sunset timetables and release notesPublished policy, not a survey. A point release is not a sunset and is not counted as one here. The TikTok line is a missing guarantee, not a notice period.Google re-read 2026-09-07; Meta, LinkedIn and TikTok read 2026-08-31Nobody commissioned it. The platforms publish it and it checks without us.
11More than 85 breaking API changes in one year across one marketing stack, about seven a month, itemized across the 19 platforms the appendix inventories and graded there as 20 or more critical, 30 or more high and 35 or more mediumOne enterprise customer's build-versus-buy analysis, appendix A. Customer not named.One stack, one year, itemized per platform. Not re-run since.2025-09-17Improvado, with that customer
12Access is priced and access is granted. Enterprise API access to a single platform can run $30,000 to $50,000 a month, X's enterprise API being the widely reported example. Separately: an app-store review at a major commerce platform blocked an entire connector class of ours, the decision stated as final and the exemption request denied.Widely reported public pricing, recorded in that same customer analysis; our own record of the app-review decision. Neither platform is our customer and the commerce platform is not named.One platform for the price, one platform for the refusal. Two single instances: not a rate card, and not a denial rate.Pricing 2025-09; the refusal recorded 2026-07-17The platform sets the price and the platform made the decision; we hold the record of both
1353% of enterprise engineering capacity goes to maintaining and troubleshooting pipelines; 97% of senior data leaders say pipeline failures slowed analytics or AI initiativesFivetran Enterprise Data Infrastructure Benchmark500 senior leaders at organizations of 5,000-plus employees, fielded 2025-Q4Published 2026-03-26Fivetran, which sells ETL
14YouTube ad reporting exposes 30 days of history; Meta's attribution window runs 37 monthsThe platforms' policies, as recorded in that same analysisSecond-hand. We have not re-read the YouTube policy page ourselves, and 37 months is an attribution window, not a retention guarantee.2025-09-17The platforms set the policy; we hold one customer's record of it
15About 70% of credentials leaked in 2022 were still valid in 2025-01, and above 64% in 2026-01GitGuardian, State of Secrets Sprawl 2026GitGuardian's own scanning corpus2026-03-17GitGuardian, which sells secrets detection
161.5 million API keys and 35,000 email addresses exposed on an AI-built application; root cause was a client-side key with row-level security missing; the founder is quoted saying he did not write a single line of codeWiz ResearchOne application2026-02-02Wiz, which sells cloud security
17CVE-2025-48757: row-level security missing in 170 of 1,645 scanned applications built on one AI application platformPublic CVE record, plus the scan writeup that reported it1,645 applications scanned by the writeup's author2025A competing application platform published the scan. Read it with that in mind.
18SOC 2 Type II runs on a three to twelve month observation window and repeats annually; the examination costs $7,000 to $150,000, or $12,000 to $100,000, depending on whose guide you readSecureframe and Drata cost guidesVendor price guides, not a market survey. The two ranges do not agree.2025-2026Two compliance-automation vendors, both of which sell the preparation
19Eleven security questionnaires from nine clients over two years, and a policy pack of about 26 documents kept current; the 2026 inbound added AI-specific security reviews and an EU AI Act statement written from scratchImprovado InfoSec records. Clients not named.Our own inbound, 2024-2025, plus 2026 inbound including an AI-specific review2026-08Us
20One enterprise RFP asked for three years of uptime history, including any major outagesOne customer RFP. Customer not named.One RFP out of our 2024-2026 inbound2025-2026The customer wrote it; we hold the record
21The standard contractual clauses moved to module set 2021/914, retiring the legacy modules; signed breach-notification windows run 24, 48 or 72 hours depending on the customerEuropean Commission implementing decision 2021/914; our own signed data processing agreementsThe clause set is public law; the windows are our own contract registerOur migration closed 2026-06-25The Commission publishes the clauses; the windows are customers' terms
22Improvado's published commitments: one-hour response on a P1, 99.95% uptime targetImprovado contract terms and the technical measures in our DPAContractual targets, not a measured uptime record2026-05-19Us
23$2.95M to build against $1.2M to buy over three years. Build side, seven lines: development year 1 $670,000; maintenance years 2-3 $1.0M; infrastructure $180,000; API fees $150,000; overhead at 30% $600,000; data quality $200,000; security $150,000One enterprise customer's own modeled configuration. Customer not named.One configuration, four to five engineers. A model, not an invoice, and not a price list.2025-09-17Improvado, with that customer
2418 to 24 months for that build to reach parityThe same customer modelParity there meant one customer's own scope: 17 or more sources landing in a single warehouse, normalized so that a cost, impression or conversion figure means the same thing on every platform in the set, backfilled as far as each platform's own retention allowed, and operated with a named owner and a documented rerun path. A smaller scope is a smaller number.2025-09-17Improvado, with that customer
25Five or more engineers at roughly $750,000 a year fully loaded, 60% of that effort on connectors, $24,000 of engineering time for three basic connectors, over a year to the first reliable dashboardOne Improvado cost model, anonymizedOne modeled enterprise configuration2026-05Improvado
26$50,000 to $150,000 per integration per year, and a separate three-year scenario near $125,000TrutoThe vendor's own estimate. Two different scenarios, not one arithmetic.2026-03-11Truto, which sells a unified API
27Across our own connector fleet: Rate Limited 35%, Auth Expired 25%, API Error 20%, Timeout 15%. One platform caps a single application id at 20 requests a second across every account behind it. A different major platform is SOAP-only, which blocks pattern reuse across connectors.Improvado connector audit for the error mix, the rate ceiling and the SOAP-only platformOur fleet, not an industry average.Error mix, rate ceiling and SOAP line audited 2026-06-17Us
28Dashboard and agent framework migrations consumed about 25% of one quarter's engineering capacityImprovado product analyticsOne organization, one quarter, our own2025-Q4Us
29Per-tenant isolation shifts the security boundary from battle-tested server code onto custom codeImprovado architecture design notesA design judgment, not a measurement2026Us
30US data engineer median total compensation near $160,000; benefits add about 42% on top of wageslevels.fyi; US Bureau of Labor Statistics, Employer Costs for Employee CompensationSelf-reported comp data, and a government series. The 30% overhead line in source 23 is that customer's own assumption, not this figure.levels.fyi 2026-08; BLS reference period 2025-06levels.fyi contributors; the US government
3139% of organizations report difficulty filling AI engineering roles, 24% for data analytics rolesInfragistics developer surveyOne vendor survey2025Infragistics, which sells developer tooling
32Penetration test $4,000 to $30,000 for a web application, repeating annuallySoftware Secured pricing guideA vendor price guide2025-2026A penetration testing vendor
33A single-site 24/7 on-call rotation needs at least eight engineers, or six per site across two sites, with on-call capped at 25% of an engineer's timeGoogle, Site Reliability Engineering, the chapter on being on-callStaffing arithmetic for a 24/7 production service. Not a survey, and not a floor for an internal marketing pipeline.Read 2026-08-31Google published it
34Median Snowflake contract $100,000 a year, across a $20,000 to $600,000 rangeVendr marketplace data549 to 720 recorded deals2026Vendr, which sells SaaS buying services
35Three recurring patterns in what teams say a year after building: a field renamed upstream that made the reporting quietly wrong, a build scoped to one platform that did not scale to more, and a stack inherited from the person who wrote it and leftImprovado's own customer conversations, abstracted to pattern level. No quotes, no company names.Our own call corpus. These are teams that came to us, so the corpus is selected and cannot tell you how many builds stayed happy, and we do not count how many teams reported each pattern. It carries no approval-time figure; see What we do not know below.2024 through 2026-04Us
361,000+ platforms; 150+ enterprise customersImprovado, self-publishedOur own counts, not a studyPlatforms 2026-08-13; customers 2026-05Us
37SOC 2 Type II FY26: clean unqualified opinion, no exceptions, 46 of 46 controls, HIPAA Security Rule opinion in scopeReport issued by BARR AdvisoryAn examination and an attestation. The report itself goes out under NDA.2026-06-26We paid for the examination
381.69 billion records across 573 tables and 17 or more sources for one enterprise brand; over 1.5 billion rows across 2,379 tables for one agencyTwo Improvado customer deployments. Customers not named.Two deployments2025-2026Us
39About 90 hours a week savedASUS, quoted in a published case pageCustomer-reported. We did not measure it, no third party audited it, no method is published.Read 2026-08-31The customer said it; we publish it
4082% less engineering time on attribution, and 300% first-year ROIAdRoll, in a published case pageCustomer-reported, method not published2026-05-22The customer said it; we publish it
413x ROI during implementationSoftwareOne, in a published case pageCustomer-reported, method not published2026-05-22The customer said it; we publish it

Claims in this category that are not on this page

  • Not printed 01

    The project-failure statistic attributed to Gartner

    The trail ends at an informal 2017 remark that travelled through a since-deleted post, not at a research note. We do not reprint the number in any form, because an indexable page that restates a retired figure launders it back into circulation. The two Gartner findings this page does use are about agent adoption, at sources 7 and 8.

  • Not printed 02

    The claim that AI-assisted coding raises change-failure rates

    Widely circulated, attributed to a dataset we went and read. That dataset's own finding was no clear pattern, so the figure is not here and we do not restate it.

  • Not printed 03

    A consolidation statistic attributed to a well-known venture investor

    About how many software vendors companies cut. It is not on that investor's site, and it circulates through aggregators with conflicting attributions. We treat it as untraceable.

  • Not printed 04

    A savings figure from our own older sales material

    We could not locate its provenance in our own records, so it is off this page and out of the fact library our decks are cut from.

  • Not printed 05

    The merged version of the AI app-builder story

    Three separate incidents are commonly retold as one. Source 17 carries a CVE number and is the only one we print.

  • Not printed 06

    A wait time for platform API access

    Our call corpus is a set of conversations, not a measured sample, and no team in it is a benchmark for the next one. Source 35 carries three patterns and no clock, which is why the approval-time row further down stays empty.

What we do not know

  • Unknown 01

    The marginal cost of connectors four through twenty, and of everything past twenty

    We do not have it, which is why the band table in the cost lines prints a mechanism rather than a dollar figure.

  • Unknown 02

    The taxonomy behind the breaking-change count at source 11

    One customer's dated per-platform appendix is the entire artifact; no research dataset sits behind it and we have not re-run it.

  • Unknown 03

    The YouTube retention surface at source 14

    We hold one customer's record of it rather than a policy page we re-read ourselves.

  • Unknown 04

    Any five-year model, for building or for buying

    This page shows one-year and three-year figures and does not extrapolate past them.

  • Unknown 05

    A credible data-engineer-specific time-to-hire or attrition benchmark

    We looked, we did not find one, and we will not estimate one.

  • Unknown 06

    Developer-account and partner-program approval time, unpredictable and unowned, including by us

    A number here would be invention.

  • Unknown 07

    Whether the three customer outcomes at sources 39 to 41 would survive an independent audit

    Nobody has run one.

The deprecation rows move, so they carry their own read dates rather than borrowing the review stamp above.

FAQ

Questions people actually ask

01

Can't you just be one of our MCP sources?

Yes, and we will connect that way. But an endpoint that hallucinates or leaks is worse than no endpoint, so what you are choosing is not one more source. It is the layer your agents trust: schema-bound tools, credentials injected server-side, an audit line per call. That is a different procurement question, and the one your security team will ask.

02

We have a warehouse and an LLM. Why do we need anything else?

Most of that stack stays. A model pointed at your warehouse writes SQL against tables that already exist. It does not get Meta, Google or TikTok into the warehouse, keep them flowing through the version sunsets on someone else's calendar, or make a cost field mean the same thing across currencies, time zones and granularities.

The decision

The decision, in one paragraph

Both paths cost money and both cost time, and neither one is free of the other. What differs is the bound, which is the asymmetry: a wrong buy has a stopping point you can see from here, and a wrong build has only the one you wrote yourself. Step 7 is the answer this page has to that: a stopping rule fixed before the first connector bounds the quarters the way step 0 bounds the history, and like step 0 it returns nothing already spent. The difference from a buy stays - a contract's bound is written for you, and a build's is one you have to author. So when you build your own model, put months in the first column and dollars in the second. It is the order the cost tables use.

Exit 2

Hybrid or buy-leaning

Bring the actual source list, long-tail systems included. Keep the build column from the cost tables rather than from us, since that is the side we have an incentive to inflate. If the arithmetic still favors the build, the plan is the one we would have given you anyway.

Get a real number for the buy side of your own platform mix

You enter an email, get routed, and pick a date and time; the number comes from that call and your own source list, not from a rate card, and there is no document at the end of it.