Getting external database data into Salesforce is one of the most common integration challenges in the Salesforce ecosystem. For decades, the default answer has been ETL: extract data from the source, transform it, and load it into Salesforce custom objects on a schedule. It works, but it carries real costs in staleness, storage, and operational overhead. ForceCnx offers a different architecture entirely, using Salesforce Connect External Objects to read data in real time without copying it. Here is how the two approaches compare.
How Manual ETL / Batch Sync Works
Traditional ETL (Extract, Transform, Load) uses a middleware platform or custom scripts to move data from your database into Salesforce on a recurring schedule. The process follows a well-established pattern:
- Extract: Connect to the source database and pull rows that have changed since the last sync (or pull everything for a full refresh).
- Transform: Reshape the data to match Salesforce's schema. This might include renaming fields, converting data types, aggregating rows, or enriching records with data from other sources.
- Load: Push the transformed data into Salesforce custom objects using the Bulk API, REST API, or SOAP API.
Common tools for this include MuleSoft, Informatica Cloud, Talend, Jitterbit, Workato, Apache Airflow, and custom Python or Node.js scripts using Salesforce's APIs. Many teams also use Salesforce Data Loader for simpler, manual syncs.
The sync typically runs on a schedule: every hour, every 15 minutes, nightly, or on a trigger. Between syncs, the data in Salesforce is a snapshot from the last successful run.
How ForceCnx Works
ForceCnx takes a fundamentally different approach. Instead of moving data into Salesforce, it lets Salesforce query your database directly. ForceCnx connects to your PostgreSQL, Google Cloud SQL, or Amazon RDS database, introspects the schema, and generates a managed OData 4.0 endpoint. Salesforce Connect consumes this endpoint and presents the data as External Objects.
When a user views a record, runs a report, or a SOQL query references an External Object, Salesforce sends a real-time request to the OData endpoint. ForceCnx translates that into a SQL query, executes it against your database, and returns the results. The data never leaves your database. There is no copy, no batch job, and no sync window.
Head-to-Head Comparison
| Dimension | Manual ETL / Batch Sync | ForceCnx | |---|---|---| | Data freshness | Stale between syncs (minutes to hours) | Real-time, always current | | Data movement | Copies data into Salesforce | No data movement — reads in place | | Salesforce storage | Synced records count against org limits | Zero — External Objects store no data | | Setup effort | Build pipeline, configure mappings, test | Configure database connection, select tables | | Ongoing maintenance | Monitor jobs, fix failures, update mappings | Managed service, no pipelines to maintain | | Schema changes | Update ETL mappings and redeploy | Re-sync schema in the ForceCnx UI | | Failure handling | Retry logic, deduplication, alerting | No batch jobs to fail | | API usage | Consumes Salesforce API calls and Bulk API limits | Does not use Salesforce data APIs | | Write to Salesforce | Yes — loads data as native custom objects | No — External Objects are read-only | | Salesforce automation | Full — triggers, flows, workflow rules | Limited — External Objects do not trigger automation | | Data transformation | Built into the pipeline | Not applicable — queries source data directly | | Tooling cost | ETL platform licensing (often significant) | Subscription (free tier available) | | Scalability | Constrained by API limits and sync window | Scales with database query performance |
When to Choose Manual ETL
ETL is not obsolete. It remains the right choice for specific integration patterns.
When you need Salesforce automation on external data. Flows, process builder, workflow rules, and Apex triggers only fire on standard and custom objects. If your business processes depend on Salesforce automation reacting to changes in external data, that data needs to be loaded as native objects. ETL is how you get it there.
When data transformation is essential. If the raw data in your source database needs significant reshaping before it is useful in Salesforce — aggregation, enrichment from multiple sources, complex calculations, or structural changes — an ETL pipeline gives you a natural place to perform that transformation. ForceCnx exposes your tables and views as they are.
When you need write access in Salesforce. Data loaded via ETL becomes native Salesforce objects that users can edit, update, and delete. External Objects are read-only. If your users need to modify external data from within Salesforce, ETL (or a complementary write-back mechanism) is necessary.
When complex cross-object reporting is required. While External Objects support Salesforce reports, some advanced reporting scenarios work better with native objects, especially multi-level joins and cross-object formulas.
When offline access matters. ETL-loaded data is stored in Salesforce, so it is available even when the source database is unreachable. For mobile users in low-connectivity environments, this is a real advantage.
When to Choose ForceCnx
ForceCnx is the better fit when real-time access, cost, and operational simplicity are what matter.
When your users need current data. If your data changes frequently — inventory, pricing, order status, transaction logs, IoT telemetry — and your users need to see the current state in Salesforce, real-time External Objects eliminate the sync-lag problem entirely.
When Salesforce storage costs are a concern. Loading millions of rows into Salesforce means paying for that storage at Salesforce's rates, which are not cheap. External Objects use zero storage. For large datasets, the cost difference can be substantial.
When you want to eliminate pipeline maintenance. ETL pipelines break. Jobs fail, schemas drift, API limits get hit, mappings need updating. Every pipeline is a liability that needs monitoring and on-call support. ForceCnx replaces the entire pipeline with a managed endpoint.
When you want fast time-to-value. Building and testing an ETL pipeline takes weeks or months. Configuring ForceCnx and seeing External Objects in Salesforce takes minutes. If you need the integration working this week, not this quarter, the speed difference matters.
When you want to preserve Salesforce API capacity. ETL syncs consume Bulk API jobs and REST API calls, which count against your org's daily limits. Other integrations competing for the same API capacity can create contention. External Objects do not consume Salesforce data API calls.
When the data is read-only in Salesforce. Order history, transaction logs, external user profiles, product catalogs, warehouse data — much of the data teams integrate into Salesforce is reference data that users view but do not edit. For read-only use cases, External Objects are a natural fit and ETL is overkill.
Bottom Line
Manual ETL and ForceCnx solve the same problem through opposite architectures. ETL copies data into Salesforce, giving you full-featured native objects at the cost of staleness, storage, and operational overhead. ForceCnx reads data in real time via External Objects, giving you always-current data with zero storage cost and no pipelines to maintain, at the cost of read-only access and limited automation support.
For teams that need Salesforce automation, write access, or heavy data transformation, ETL remains the right tool. For teams that need fresh data, low cost, and minimal maintenance — which describes a large share of Salesforce integrations — ForceCnx replaces the entire ETL pipeline with a managed service that takes minutes to set up and nothing to maintain.