Skip to content

Deal economics

Reusable data connector investment pays back in suppliers, not sources

By SourceX Editorial · Reviewed by Noah Loul ·

10 sections

Short answer

A reusable data connector investment pays back when one build serves enough suppliers at low added cost: build plus upkeep, divided by the hours each extra supplier saves against a bespoke pull. Reuse breaks when tenant customization erodes that saving or too few suppliers share a system. In MeltanoHub's public catalog, 148 of 522 sources were built more than once, and 74% of active builds run on a shared SDK.

Value drivers

Reusable data connector

This page covers reusable data connector investment pays back in suppliers, not sources.Illustrative

Key takeaways

  • A connector is an asset only when the second and later suppliers on one system cost far less to onboard than the first.
  • The payback count equals build plus upkeep hours divided by hours saved per added supplier; tenant divergence moves it most.
  • In MeltanoHub at commit ffab408, 148 of 522 sources have two or more variants, and 53 carry two or more active ones at once.
  • Maintained reuse concentrates in shared plumbing: 74% of active variants are built on the Meltano SDK, against 1% of unknown or inactive ones.
  • Ask for suppliers served per connector, onboarding hours in arrival order and upkeep per accepted dataset before crediting any reuse claim.

What does a reusable data connector investment actually buy?

It buys a lower cost for the next supplier on the same source system, and nothing else. A connector that serves one supplier is a bespoke pull with extra code to maintain; it becomes an asset only when a second, third and tenth supplier on that system can be onboarded for a fraction of the first one's hours.

That makes a reusable data connector investment a bet on three quantities an investor can ask for: how many suppliers with licensable records use the system, how much each added supplier still costs to onboard, and how many hours the platform's own changes will demand every year. Code quality, connector counts and coverage maps are inputs to those numbers, not substitutes for them.

The useful evidence is therefore supplier-level, not connector-level: onboarding hours in the order suppliers arrived, the share of each supplier's configuration that is unique to it, and accepted datasets per connector. Counting sources covered measures building; counting suppliers served per source measures reuse. A plan that reports connectors built but not suppliers served per connector has not yet shown the second.

The payback count: how many suppliers must one build serve?

One build pays back when the hours it saves across suppliers exceed its build and upkeep. Written as a count: payback suppliers = (build hours + upkeep hours over the planning life) / (hours of a bespoke pull per supplier minus hours to onboard one more supplier on the connector), rounded up to the next whole supplier.

The denominator is where the economics live. If each added supplier still needs most of a bespoke pull's work, because its schema, credentials or rights scope differ, the saving shrinks and the payback count climbs fast. The table uses illustrative hours, not observations, to show how far: the same 440 fixed hours pay back at 8 suppliers when added suppliers cost 20 hours each, and at 18 when they cost 55.

A thin module on a shared framework changes the numerator instead. If authentication, pagination, retries and incremental state come from a library that other connectors also use, the source-specific build and its upkeep shrink, and the payback count falls even when tenants diverge. The five illustrative profiles below compare the two levers:

The payback count: how many suppliers must one build serve?
Profile (illustrative)Fixed hours: build plus 24 months upkeepHours saved per added supplierPayback countRead
A. Dedicated build, tenants use mostly standard objects440 (240 build, 100 a year)60 (80 bespoke, 20 to onboard)8 suppliersFund only with eight or more named suppliers on the system
B. Dedicated build, heavily customized tenants44025 (80 bespoke, 55 to onboard)18 suppliersUsually a cost: divergence eats the saving
C. Thin module on a shared framework, standard tenants200 (120 build, 40 a year)604 suppliersThe cheapest route to reuse when the framework already exists
D. Thin module, heavily customized tenants200258 suppliersFramework reuse can rescue a divergent system
E. Onboarding costs as much as a bespoke pull4400NeverUse supplier exports or bespoke pulls instead of a build

What 522 open-source sources show about reuse in practice

Reuse across organizations fails often, and the reuse that survives sits in shared plumbing rather than in one source's connector. That is the reading of an original count of MeltanoHub, the public catalog of extractors and other plugins for the Meltano data pipeline tool, at commit ffab408 of October 25, 2026, after excluding every variant that wraps an Airbyte connector.

The catalog keeps one file per variant of each source's extractor, and its own contributor notes say a variant is usually named after the GitHub owner of the repository, so two variants of one source are usually separate forks or rewrites kept by different owners. Of 522 sources with at least one remaining variant, 148 (28%) have two or more, and those duplicated sources hold 456 of the 830 variants. HubSpot and DynamoDB have 11 variants each.

Duplication is not only historical. On 53 sources (10% of all sources, 36% of the duplicated ones) two or more variants carry the catalog's Active (Stable) status at the same time, so the same upkeep is being paid in parallel; HubSpot, Stripe and GA4 have four active variants each, MongoDB five. Meanwhile 155 sources (30%) have no variant marked active or beta, and duplicated sources are no better off than single ones on that measure (30% each).

The strongest pattern is where the maintained builds sit. Among the 428 active variants, 316 (74%) carry the catalog's Built with the Meltano SDK flag; among the 385 marked unknown or inactive, 2 (1%) do. Meltano's SDK documentation says developers report writing about 70% less code with it and that connectors pick up new capabilities and bug fixes by updating the SDK dependency, which is framework reuse: upkeep shared across sources, not across tenants of one source.

The counts describe a public catalog, not usage, revenue or private connectors. A second variant can exist for good reasons, such as a missing stream or a vendor's own product, and a status of unknown can mean unassessed rather than abandoned. The table gives each figure with its denominator.

What 522 open-source sources show about reuse in practice
Measure, MeltanoHub extractors at commit ffab408CountShareWhat it suggests
Sources with two or more variants148 of 52228%Builds are often redone rather than reused across organizations
Variants sitting on those duplicated sources456 of 83055%Most catalog entries are alternatives, not first builds
Sources with two or more Active (Stable) variants53 of 52210%Parallel upkeep on one platform's changes
Sources with no variant marked active or beta155 of 52230%Unattended connectors lose maintained status
Active variants built on the Meltano SDK316 of 42874%Maintained reuse concentrates in a shared framework
Unknown or inactive variants built on the SDK2 of 3851%Stand-alone builds dominate the unmaintained tail
A bar chart of 522 MeltanoHub sources by number of extractor variants, 374 with one and 148 with two or more, beside two bars showing 74 percent of active variants and 1 percent of unknown or inactive variants built on the Meltano SDK.
Original count of MeltanoHub extractors at commit ffab408 (October 25, 2026), Airbyte-wrapper variants excluded.

Why two suppliers on the same system rarely share one connector

Because the system name is shared but the tenant is not. Two suppliers on Salesforce share the platform's standard objects and its API, yet each org can add its own objects and fields: Salesforce's help pages put the default at 200 custom objects for Enterprise Edition and 2,000 for Unlimited, with a 3,000-object ceiling, and allow 500 custom fields per object on Enterprise and 800 on Unlimited.

At a glance

Why two suppliers on the same system rarely share one connector

Connector design decides who absorbs that divergence. The Singer specification notes that some taps hard-code the schema for each stream while others query the source for the streams it has. A hard-coded connector never sees a supplier's custom objects; a discovering connector sees them but passes the mapping work downstream, where it becomes per-supplier hours unless a shared mapping covers most fields.

Upkeep behaves differently from onboarding. It scales with the platform, not with suppliers, so reuse spreads it thinly when the platform changes. Salesforce retired versions 21.0 through 30.0 of its SOAP, Bulk and REST APIs in the Summer '25 release for every API-enabled org, and its notice says calls to retired versions fail with an error that the endpoint is deactivated. One fix serves every supplier on a maintained connector; one missed fix stops all of them at once. Four breakers to measure on the first suppliers:

  • Schema divergence: the share of each supplier's delivered fields that the shared mapping covers without edits. Measure it on the first two suppliers before funding the third.
  • Credential and edition differences: auth flows, API editions or sandbox rules that change per tenant. Count configuration entries used by only one supplier.
  • Rights scope: each supplier licenses a different subset, so the connector needs supplier-specific filters that must be tested against the signed scope, not assumed.
  • Platform change: retired API versions, renamed fields and new rate rules. Log each forced change with the hours it took and whether any supplier needed separate work.

The reuse ledger: six numbers to ask for before reuse is claimed

Ask for six numbers, each with a stated denominator, and treat any connector program that cannot produce them as unproven reuse. The ledger below turns the payback count into measurements that accumulate supplier by supplier, so the claim can be checked after the second supplier rather than after the tenth.

Two habits make the ledger honest. Report onboarding hours in the order suppliers arrived, because averages hide whether the fifth supplier was cheaper than the first. And count a supplier as served only when an accepted dataset came through the connector, not when credentials were connected:

The reuse ledger: six numbers to ask for before reuse is claimed
MetricDefinitionDenominatorWarning sign
Suppliers served per connectorSuppliers with at least one accepted dataset pulled through the connectorConnectors live 12 months or longerMedian below the payback count
Marginal onboarding hoursHours from credentials received to first accepted pull, for the nth supplierEach supplier, in arrival orderThe third supplier costs as much as the first
Supplier-specific shareConfiguration entries or code paths used by exactly one supplier, divided by allPer connector, after each new supplierRises with every supplier added
Shared-map coverageDelivered fields mapped by the shared mapping without supplier editsFields delivered per supplierBelow the threshold set when the build was funded
Forced changesPlatform-driven changes that needed a release, with hours and suppliers affectedPer connector-yearA change that needed separate work per supplier
Upkeep per accepted datasetUpkeep hours across all connectors divided by accepted datasetsPer quarterRising for two quarters in a row

Decision tree and milestones for funding the next connector

Fund a source-specific connector only after rights, pipeline and divergence each pass, and release money in tranches tied to supplier evidence. The tree runs in order and stops at the first failed question, because a later answer cannot rescue an earlier one: a perfect mapping layer is worthless on a platform whose terms bar the extraction.

The six questions come first and the milestone table follows it, splitting the commitment so each tranche buys the evidence for the next. The thresholds are illustrative and should be replaced by the plan's own payback count:

  • 1. Rights and access: do the platform's terms and each supplier's authority allow extraction for licensing? If not, stop; no reuse math applies.
  • 2. Pipeline: are at least as many suppliers as the payback count named on this system, with records pre-screened for rights? If not, use supplier exports or bespoke pulls.
  • 3. Divergence: after two suppliers, does the shared mapping cover the agreed share of delivered fields? If not, fund mapping tools before the connector.
  • 4. Shared layer: does an existing framework or maintained connector already handle authentication, pagination and incremental state? If yes, build a thin module, not a stand-alone connector.
  • 5. Upkeep: do expected forced changes a year, times hours per change, fit the plan? If not, partner for the connector and keep the mapping in-house.
  • 6. All five pass: build, and fund the first tranche only.
Decision tree and milestones for funding the next connector
MilestoneEvidence to seeReleasesReverse if
Pipeline provenNamed suppliers on one system at or above the payback count, rights pre-screenedBuild budget for the first moduleFewer than half pass the rights screen
Second supplier onboardedMarginal hours for supplier two well below supplier oneOnboarding budget for suppliers three to fiveSupplier two takes as long as supplier one
Third supplier on the shared mapSupplier-specific share flat or falling; coverage at thresholdGeneralized mapping workEach supplier adds its own branch
First forced change absorbedOne release fixed every supplier on the connectorA second system's pipeline reviewThe fix needed separate work per supplier
Steady stateUpkeep per accepted dataset falling over two quartersUpkeep budget at the observed rateUpkeep per accepted dataset rising

Could connector spending outrun accepted supply?

Yes, and connector programs are especially prone to it because every build adds upkeep that continues whether or not suppliers arrive. A team that builds ten connectors ahead of its pipeline carries ten streams of forced changes; if three systems produce most accepted datasets, the other seven turn engineering hours into fixed cost.

The catalog count shows how often that cost ends up abandoned rather than paid: 30% of sources have no variant still marked active or beta. Inside a company, the equivalent is a connector that stays live with no accepted dataset for two quarters. Hiring more engineers to keep such connectors current raises cost faster than accepted delivery, and automation that generates connectors faster makes the problem worse unless the pipeline grew first.

Three checks separate real reuse from spending that outruns supply: upkeep hours per accepted dataset across the whole portfolio, the number of connectors with no accepted dataset in the last two quarters, and the ratio of connectors built to systems with at least the payback count of named suppliers. If the third ratio is well above one, the build pace is ahead of the evidence.

What could make the reuse case wrong

Reuse economics could weaken in several ways, and an investor should hear the company's view on each before believing a connector moat. Most of these risks move the payback count rather than ending the case, so ask which way each one pushes the plan's own count:

  • Platform terms could close the route. A software vendor can restrict third-party extraction or launch its own data program, which turns a reusable connector into a stranded one regardless of how many suppliers it served.
  • Build costs could fall. If code generation makes a working connector cheap to produce, the saving from reuse shrinks and the moat moves to mapping, rights scoping and acceptance testing.
  • Early suppliers could flatter divergence. The first suppliers onboarded are often the simplest; coverage measured on them can overstate how well the shared mapping fits later tenants.
  • Correlated failure grows with reuse. A single platform change can stop every supplier on a connector at once, as Salesforce's API version retirement illustrates, so concentration on one system is a delivery risk as well as a saving.
  • Catalog evidence is indirect. MeltanoHub counts show listing and maintenance status, not hours, usage or revenue; private connectors may behave differently.

SourceX's published intake, and questions for any connector plan

SourceX publishes its intake steps, not its connector economics. Its How it works page says a company lists its systems, years of history and what can be exported, and that SourceX completes the inventory with the company, runs the rights check and sets the processing route; it also says qualifying companies list at least 5 systems, and that the Dataset Deal Confirmation for each deal fixes the processing route along with the dataset and rights.

Read against this article, that means reuse is decided per system and per deal: a supplier with five systems is five reuse questions, and the processing route is a signed term rather than a default. SourceX does not publish which systems it pulls from, how routes are chosen or what extraction costs; its investors page says company and commercial metrics go to investors directly. Its current raise is limited to accredited investors under Rule 506(c), with materials available on request. Questions worth asking SourceX or any company with connectors in its plan:

  • Which three systems produced most accepted datasets last year, and how many suppliers did each serve?
  • What were onboarding hours for the first, second and third supplier on your most reused system?
  • What share of each supplier's configuration is unique to that supplier, and is it falling?
  • Which connectors had no accepted dataset in the last two quarters, and what do they cost to keep current?
  • How did the last forced platform change land: one release for every supplier, or separate work for some?

Methods note: the MeltanoHub count and the payback model

Data: the meltano/hub repository at commit ffab408cfd406c433d113328a05060472236ec01 (committed October 25, 2026), cloned and read on October 27, 2026. Population: every file matching _data/meltano/extractors/<source>/<variant>.yml, 1,075 files. Exclusion: a variant is dropped when its keywords list contains airbyte_protocol, which removed 244 files named airbyte.yml and the tap-airbyte-wrapper plugin, 245 in all; the script prints every excluded file. A source is an extractor directory with at least one remaining variant: 522 sources, 830 variants.

Rules: status is the variant's maintenance_status field as written (active, beta, development, inactive or unknown). Parallel active upkeep means two or more remaining variants of one source with status exactly active. No active or beta build means no remaining variant with either status. SDK-based means the keywords list contains meltano_sdk, the field the catalog uses to show its Built with the Meltano SDK flag. Hidden variants (29) stay in the population. Percentages come from exact integer counts, rounded half up once to whole percents. No random draw is used.

The saved snapshot holds only source names and integer counts per source; variant file names, which are often personal GitHub handles, and maintainer records were not kept. The payback model is a formula with illustrative hour inputs, not measurements from any company, SourceX included. Salesforce limits and its API retirement were checked on October 27, 2026 through searches limited to help.salesforce.com. Not measured: connector usage, hours, private connectors, Airbyte connectors and the reasons any variant was created.

Frequently asked questions

How many suppliers does a data connector need to pay back?

Divide the build hours plus upkeep over the planning period by the hours each added supplier saves against a bespoke pull, and round up. In this article's illustrative profiles, 440 fixed hours pay back at 8 suppliers when each added supplier costs 20 hours to onboard, but at 18 when it costs 55. The saving per added supplier matters more than the build estimate.

Why can't one Salesforce connector serve every supplier on Salesforce?

Each Salesforce org can add its own objects and fields: Salesforce's help pages give defaults of 200 custom objects on Enterprise Edition and 2,000 on Unlimited, and 500 or 800 custom fields per object. A connector with hard-coded schemas misses them, and one that discovers them hands the mapping work to someone downstream.

Should a data company build connectors or a shared framework?

When few suppliers share each system, a shared framework usually pays first, because authentication, pagination and incremental state are written once and reused across sources. In MeltanoHub, 74% of active extractor variants are built on the Meltano SDK, against 1% of variants marked unknown or inactive.

What metrics show that a company's connectors are really reused?

Suppliers with an accepted dataset per connector, onboarding hours for each supplier in arrival order, the share of configuration unique to one supplier, shared-map coverage of delivered fields, forced changes per connector-year and upkeep hours per accepted dataset. Connector counts and coverage maps alone show building, not reuse.

Do platform API changes make reusable connectors riskier?

They make reuse both cheaper and more fragile. Salesforce retired versions 21.0 through 30.0 of its SOAP, Bulk and REST APIs in Summer '25 for every API-enabled org; on a maintained connector one release fixes every supplier, but a missed change stops them all at the same time.

Sources

  • MeltanoHub lists 1,075 extractor variant files at commit ffab408; after excluding Airbyte wrappers, 522 sources and 830 variants, with 148 sources having two or more variants, 53 having two or more active ones, 155 having none active or beta, and 316 of 428 active variants built on the Meltano SDK. Source
  • MeltanoHub keeps one file per plugin variant, and the file name is the variant name, usually the GitHub owner of the repository. Source
  • MeltanoHub labels maintenance statuses Active (Stable), Prerelease (Beta), Development, Inactive or Stale and Unknown, and shows a Built with the Meltano SDK flag when a variant's keywords include meltano_sdk. Source
  • Meltano says developers report writing about 70% less code with its SDK and that connectors gain new capabilities and bug fixes by updating the SDK dependency. Source
  • The Singer specification says some taps hard-code the schema for each stream while others connect to an API that describes the available streams. Source
  • Salesforce gives default custom object limits of 200 for Enterprise Edition and 2,000 for Unlimited, with a total ceiling of 3,000 that cannot be raised. Source
  • Salesforce allows 500 custom fields per object on Enterprise Edition and 800 on Unlimited Edition. Source
  • Salesforce retired versions 21.0 through 30.0 of its SOAP, Bulk and REST APIs in the Summer '25 release for all API-enabled orgs; calls to them fail with an endpoint-deactivated error. Source
  • SourceX's How it works page says companies list systems, history and exportability, SourceX completes the inventory, runs the rights check and sets the processing route, qualifying companies list at least 5 systems, and each Dataset Deal Confirmation fixes the processing route. Source
  • SourceX's investors page says it shares company and commercial metrics with investors directly and takes requests for investor materials. Source

Request SourceX investor materials

SourceX shares company and commercial metrics with investors directly. Any offering is made only to verified accredited investors.

See if your company qualifies