Build vs Buy: Replacing Heroku Connect with Debezium, Airbyte, or a Managed Sync Platform

With Heroku in sustaining mode after the Feb 6, 2026 announcement, teams are weighing whether to self-host Salesforce CDC on Debezium, Airbyte, or Kafka — or buy a managed platform like Stacksync. The build path is feasible but underestimates 5 hidden costs that easily run $300K–$600K year one. Here is the tradeoff and a 90-day vs 14-day timeline.

Why this question is suddenly live

Two shifts collided. Salesforce's sustaining-mode decision (covered by Salesforce Ben and other industry press) made every Heroku Connect customer ask whether to keep paying. And open-source CDC tooling — Debezium, Airbyte, Apache Kafka — has matured to the point where a senior backend team can credibly consider self-hosting the replacement.

The conversation now happening at every Salesforce-shop engineering team is some version of: "Heroku Connect costs us $25K per month. Could we just build it?" The answer is sometimes yes, often no, and the dividing line is rarely where teams expect.

For migration urgency framing, see our companion post on Heroku Connect end of life. For the architectural primer on what a CDC-based sync stack actually is, see Salesforce CDC vs Heroku Connect.

What the build path actually entails

A complete Salesforce-to-Postgres bidirectional sync, built from primitives, has eight layers. Heroku Connect bundles all eight; build paths reproduce them piece by piece.

1. Change source. Salesforce CDC delivered via the Pub/Sub API. Sub-second latency, 72-hour replay window. This is the "easy" layer.
2. Stream consumer. A gRPC client subscribed to the Pub/Sub API, persisting events into Kafka, Kinesis, or directly into Postgres. Existing Kafka shops have most of this; greenfield builds need to design it.
3. Initial bulk load. Salesforce Bulk API 2.0 for backfilling existing data. Must coordinate with the CDC stream so you don't double-apply or miss records during the cutover.
4. Write-back path. Salesforce REST API + idempotency keys + retry logic + dedupe to prevent loops between your writes and incoming CDC events. This layer alone is 6–8 weeks of senior engineering.
5. Schema-drift detection. Salesforce admins add custom fields. CDC carries the new field. Your destination schema doesn't. The sync silently drops the field unless you build detection + alerting + auto-evolution.
6. Conflict resolution. When the same record changes in Salesforce and Postgres in the same window, who wins? Last-write-wins is the easy answer; per-object configurable rules is what production teams need.
7. Replay storage beyond 72 hours. CDC's window is 72 hours. If your consumer is offline for 73 hours, you need a Kafka topic in front with longer retention or a periodic full-reconciliation job using Bulk API 2.0 snapshots.
8. Observability + alerting. Sync lag, dropped events, schema drift, conflict count, write-back failures. None of these come for free; all of them are required for production operation.

Heroku Connect did all eight, badly in places (10-minute polling instead of CDC streaming), but it did them. Replacing Heroku Connect from primitives means rebuilding all eight.

The three most-considered open-source / hybrid stacks

Debezium + Kafka

Debezium is the canonical CDC framework in the Postgres / MySQL world. As of 2026, Debezium does not ship a stable Salesforce source connector — the Salesforce-specific work has historically lived in adjacent projects, not in upstream Debezium. Teams building on Debezium typically combine it with a Salesforce Pub/Sub API client (Java or Python) that emits records into Kafka, then use Debezium's Postgres sink.

Strengths: battle-tested at scale, mature operational tooling, large community. Weaknesses: no first-class Salesforce connector, requires Kafka in production, and your team owns the Salesforce-side gRPC client.

Airbyte (open-source)

Airbyte's Salesforce source connector is well-maintained and actively used. The default mode is incremental sync on a schedule (typically 5 minutes or longer). Airbyte does not natively run on a sub-second streaming model; it is closer to "modern Fivetran" than "real-time CDC."

Strengths: easy to deploy, broad connector library, reasonable for analytics-style sync. Weaknesses: not real-time in the Heroku Connect sense, no built-in bidirectional write-back, scheduled rather than streaming.

Confluent Salesforce CDC Source Connector

Confluent's managed Salesforce CDC Source Connector is the closest off-the-shelf "Salesforce → Kafka" path. Streaming-based, supports CDC and Platform Events. Production-ready. Pairs naturally with Debezium's Postgres sink.

Strengths: managed, streaming, production-grade. Weaknesses: requires Confluent Cloud or a self-hosted Kafka Connect cluster, license costs are non-trivial at scale, still requires you to build the write-back path.

The 5 hidden costs of building

These are the costs that surprise teams six weeks into the build. Each is real engineering time, not optional.

1. Reconciliation pipelines. CDC delivery is at-least-once with a 72-hour replay window. Production teams find that 0.1–1% of events need reconciliation against a Bulk API 2.0 snapshot — typically because of consumer downtime, hard deletes, or schema-drift gaps. Building reconciliation infrastructure: 4–6 weeks of senior engineering time.
2. Bidirectional write-back. Salesforce REST API + idempotency + dedupe + conflict resolution for the Postgres-to-Salesforce direction. Includes handling Salesforce API rate limits, validation rule failures, and retry logic. 6–8 weeks.
3. Schema-drift detection. Salesforce custom field added → CDC carries it → your destination doesn't have a column → silent loss. Building detection that compares incoming CDC payloads against the destination schema and either evolves it automatically or alerts: 2–4 weeks initially, plus ongoing maintenance.
4. Multi-org / multi-tenant support. If you sync more than one Salesforce org or run a SaaS where each customer has their own Salesforce, you need per-tenant routing, isolation, and observability. 6–12 weeks.
5. On-call burden. Once production: 2–4 hours per engineer per week in steady state, with periodic incident spikes. Distributed across the team, this is typically equivalent to one full-time engineer over the long run.

Add up the engineering time: roughly 18–34 weeks of senior backend work before the system is production-grade. At loaded cost (~$300K–$500K per senior backend year), the year-one TCO of building lands at $300K–$600K, with ongoing operational cost equivalent to ~1 FTE.

Side-by-side comparison

The economics rarely favor building until you cross 100M events per day, where managed pricing inverts and a self-hosted Kafka stack becomes cheaper at unit cost. Below that volume, the managed-platform total cost (license + zero ongoing engineering) is typically 30–60% of the build path's loaded cost.

When the build path actually wins

There are four genuinely good reasons to build.

Strategic ownership of the data pipeline. Some companies treat their integration stack as a core competency — fintech companies that sync customer data across many systems, or large SaaS platforms whose product is fundamentally about data movement. For these teams, owning the pipeline end-to-end is the right call regardless of TCO.

Multi-tenant Salesforce data with strict isolation. SaaS platforms running on per-customer Salesforce orgs sometimes need org-level network isolation that managed sync platforms can't provide on standard tiers. Self-hosting in your own VPC solves this — at the cost of building the rest.

Compliance constraints requiring on-prem / VPC-hosted CDC. Regulated industries that cannot egress data to a third-party SaaS platform. The compliance bar drives the architecture; cost is a secondary consideration.

Cost at very large scale. Above ~100M Salesforce CDC events per day, managed-platform pricing typically inverts and self-hosted Kafka becomes cheaper at unit cost. Most Heroku Connect customers are not at this volume; for the ones who are, building is a defensible economic call.

When the build path loses

Three signals that say buy.

Team size under 5 backend engineers. The build path requires sustained 2–3 senior engineers for 3–6 months and ongoing operational ownership. Smaller teams cannot afford the opportunity cost.

Bidirectional sync required from day one. The write-back layer alone is 6–8 weeks. Teams that need bidirectional in production fast almost always lose by building.

No streaming platform already in production. If you don't run Kafka or equivalent today, the build path includes standing up Kafka — adding 4–8 weeks of operational work plus ongoing platform engineering. Buy.

For a deeper view of why Heroku Connect's architecture itself caps at 10-minute polling and what a modern replacement architecture looks like, see Stacksync's architecture deep-dive on Heroku Connect's limits.

90-day reference timeline if you build

The realistic timeline for a senior team of 2–3 backend engineers building a production-grade Heroku Connect replacement on Debezium-style architecture.

1. Weeks 1–2: Architecture spike. Stand up a Pub/Sub API gRPC consumer in your language of choice (Java, Python, Go). Subscribe to one CDC channel. Prove sub-second latency end-to-end. Decide Kafka vs direct-to-Postgres landing.
2. Weeks 3–4: Bulk API 2.0 initial load. Build the backfill job. Coordinate it with the CDC stream so the cutover from "bulk load" to "incremental CDC" is exact (no duplicates, no gaps).
3. Weeks 5–8: Bidirectional write-back. Salesforce REST API client. Idempotency keys. Retry with exponential backoff. Dedupe logic to prevent loops between your writes and incoming CDC events. Conflict resolution rules per object.
4. Weeks 9–10: Schema-drift detection and auto-evolution. Compare incoming CDC payloads against destination schema. Either auto-add columns or alert. Build the alerting integration into your existing on-call.
5. Weeks 11–12: Observability + replay storage. Dashboards for sync lag, conflict counts, dropped events. Long-retention Kafka topic (or equivalent) for replay beyond 72 hours.
6. Week 13: Shadow run. Run the new stack against the existing Heroku Connect deployment for 14 days. Reconcile data integrity hourly. Flag and resolve every discrepancy before cutover.

13 weeks for the engineering work, then a 14-day shadow window. Total: roughly 90 days from kickoff to production cutover, with 2–3 senior backend engineers committed full-time.

14-day reference timeline if you buy (using Stacksync as an example)

For comparison, the typical timeline for a managed-platform migration:

• Day 1–3: Connect Salesforce + target database. Map first object set. Validate authentication and basic sync.
• Day 4–7: Validate sync direction, conflict resolution settings, observability dashboards. Configure alerts.
• Day 8–10: Shadow window against the existing Heroku Connect deployment. Reconcile row counts and hashes.
• Day 11–14: Cut over write traffic. Maintain dual reads for 7 days for instant rollback. Decommission Heroku Connect.

Total: 14 days end-to-end with 1–2 engineers part-time. This is what managed real-time sync that scales actually looks like in practice.

FAQ

Can Debezium sync Salesforce to Postgres?
Not directly with stock Debezium. Debezium does not ship a first-class Salesforce source connector as of 2026. Teams building on Debezium combine it with a custom Pub/Sub API gRPC client (or Confluent's Salesforce CDC Source connector) that emits records into Kafka, then use Debezium's Postgres sink for the destination side. The full stack is feasible but is not a turnkey Debezium deployment.

Is Airbyte real-time?
No, not in the Heroku Connect sense. Airbyte's Salesforce source connector runs on incremental scheduled syncs — typically 5 minutes or longer. It is closer to "modern Fivetran" than "real-time CDC." For sub-second latency, you need a Pub/Sub API client (Confluent's Salesforce CDC Source connector or a custom gRPC client), not Airbyte.

What's the cheapest open-source Heroku Connect alternative?
There is no perfect drop-in. The closest pattern is Confluent Salesforce CDC Source connector → Kafka → Debezium Postgres sink, plus a custom write-back service. License costs are minimal at small scale (Confluent has a free tier; Kafka and Debezium are open source). Engineering build cost dwarfs license cost — typically $300K+ in year one for FTE-loaded build time.

How long does it take to build a Heroku Connect replacement?
Three to six months for a production-grade build with 2–3 senior backend engineers. The dominant time sinks are the bidirectional write-back layer (6–8 weeks), reconciliation pipelines (4–6 weeks), and the integration of all the layers under a single observability surface. Teams that estimate "two weeks to wire up a CDC consumer" are estimating layer 1 of 8.

Does Salesforce CDC support bidirectional sync?
No. CDC is a one-way Salesforce → consumer event stream with no built-in write primitive. Bidirectional sync requires a separate write-back path using the Salesforce REST API or Bulk API 2.0, with idempotency keys, dedupe logic, and conflict resolution. We cover the architectural details in Salesforce CDC vs Heroku Connect.

How much does it cost to replace Heroku Connect?
For most teams, a managed sync platform lands in the $20K–$120K per year range — typically 50–80% lower than equivalent Heroku Connect Enterprise spend. Self-hosting on Debezium/Airbyte/Kafka usually runs $300K–$600K in year one (FTE-loaded engineering time) plus ongoing operational cost equivalent to roughly one full-time engineer. The economics only invert at very high scale.

What's a realistic timeline to migrate off Heroku Connect?
Buying a managed platform: 14 days end-to-end with 1–2 engineers part-time (3 days connect, 4 days validate, 4 days shadow, 3 days cutover). Building from primitives: 3–6 months with 2–3 senior backend engineers full-time. Larger Heroku Connect deployments (50+ sync flows, 100M+ rows) extend either timeline by 2–4 weeks for reconciliation work.

Is Confluent's Salesforce CDC connector production-ready?
Yes. Confluent's Salesforce CDC Source Connector is a managed, production-grade connector that subscribes to Salesforce CDC events via the Pub/Sub API. It is the most reliable off-the-shelf Salesforce → Kafka path. It does not provide bidirectional sync; that layer is still on you.

When is buying always better than building Salesforce sync?
Three conditions: team size under 5 backend engineers, bidirectional sync required from day one, or no Kafka equivalent already in production. If any one is true, the build path's engineering cost almost always exceeds the multi-year managed-platform license cost. Above 100M CDC events per day with a senior team, the math can flip.

How do managed sync platforms charge — record-based, connection-based, or flat?
Different platforms charge differently. Stacksync uses a transparent subscription model based on connection count and tier. Whalesync uses a record/sync-volume model. Some legacy iPaaS platforms charge per record processed, which scales poorly at high volume. Always model your expected sync volume against each pricing model before signing.

Closing — Decision recommendation

Run the three "buy" signals first. If any one is true, buy. If all three are false (you have ≥5 senior backend engineers, you don't need bidirectional from day 1, and you already operate Kafka), the build path becomes worth modeling — but compare year-1 and year-3 TCO honestly.

If you are migrating off Heroku Connect specifically and the volume is below 100M CDC events per day, Stacksync's managed real-time sync that scales is the path most teams pick. We've seen 14-day cutovers consistently across mid-market migrations.

About the authors

[AT integration architect — name TBD], Integration Architect, Atypical Tech. [Bio paragraph: 60–80 words on integration architecture, build-vs-buy economics, Salesforce platform experience. To be filled with real engineer profile before publish.] LinkedIn.

[Stacksync solutions architect — name TBD], Solutions Architect, Stacksync. [Bio paragraph: 60–80 words on Salesforce Pub/Sub API, Bulk API 2.0, Heroku Connect migrations. To be filled with real engineer profile before publish.] LinkedIn.

Sources

• Salesforce Ben — Salesforce Shuts Down Heroku Enterprise Sales: https://www.salesforceben.com/salesforce-shuts-down-heroku-enterprise-sales-for-new-customers/
• Salesforce Developers — Pub/Sub API Overview: https://developer.salesforce.com/docs/platform/pub-sub-api/overview.html
• Salesforce Developers — Bulk API 2.0: https://developer.salesforce.com/docs/atlas.en-us.api_asynch.meta/api_asynch/asynch_api_intro.htm
• Salesforce Developers — Change Data Capture: https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm
• Debezium — Project home: https://debezium.io/
• Airbyte — Salesforce source connector: https://docs.airbyte.com/integrations/sources/salesforce
• Confluent — Salesforce CDC Source Connector: https://docs.confluent.io/kafka-connectors/salesforce-cdc-source/current/overview.html
• Apache Kafka — Documentation: https://kafka.apache.org/documentation/