Summary
- Skyvia: A no-code, cloud-native platform featuring visual mapping, predictable tiered pricing, and built-in tools for end-to-end ELT, dbt integration, and Reverse ETL.
- Fivetran: Fully managed enterprise ingest platform utilizing log-based CDC and automated schema drift handling, backed by a usage-based MAR pricing model.
- Airbyte: Highly customizable, open-source integration framework that gives developer-led teams absolute control over deployment, connectors, and infrastructure.
- Matillion: A specialized enterprise tool built for data engineers to execute heavy, push-down SQL and Python transformations directly inside cloud data warehouses.
- Estuary Flow: A high-throughput streaming platform providing sub-second, low-latency Change Data Capture (CDC) for real-time operational analytics.
Your pipeline says “Success,” but the numbers in the report are wrong. A column was added at the source last week, and the tool quietly left it out. Or the bill jumped after you connected two more apps. That’s usually when people go looking for a different ETL tool.
I work with the team behind Skyvia, so you’ll probably notice we’re quite familiar with it. But we also know what works beautifully for one company can become a complete disaster for another. To make this comparison useful, we looked at 12 popular tools, Skyvia included, through the same set of questions. A schema change is a good way to find out whether a pipeline has a sense of humor. We tried that with the tools we could test directly, using HubSpot and PostgreSQL data. For the remaining contenders, we went through official documentation and pricing pages to answer the same questions.
For each of the 12, you’ll see whom it suits, what happens when the source schema changes, how fast it syncs, and what it costs. Picks by job and a side-by-side table come after the list.
How we tested and checked these ETL tools
If you want to see a data integration tool’s true personality, add a column to the source and watch. Does the warehouse pick up the new column without intervention? Or will someone have to approve it first? In some tools, the answer involves editing the pipeline yourself. We cover this under Schema changes for every entry, and it turned out to be the sharpest distinction in our five hands-on tests.
Each entry answers the same questions in the same order:
- Best for: the team and the job the tool suits.
- Schema changes: what happens when a source column is added, dropped, or changes type.
- Fastest sync: the shortest schedule or delay and the plan it needs.
- Pricing: what the bill counts, the entry price with its billing basis and any free plan or trial.
- Deployment: where it runs.
I ran five of them hands-on: Skyvia, Fivetran, Airbyte, Matillion, and Estuary each loaded the same HubSpot contacts and PostgreSQL tables into Snowflake and BigQuery, using trial accounts (Airbyte through its free PyAirbyte library). When the first sync was done, I went into PostgreSQL, gave the products table a new SKU column, and ran every pipeline a second time. Along the way, I kept notes on each tool’s setup steps and its time to first sync, on what it did with the new column, and on what the bill was shaping up to be. The full setup is at the end of the article, and the test took about 40 hours.
The other seven (Informatica, AWS Glue, Azure Data Factory, Talend, Hevo, Stitch, and Integrate.io) are tools buyers often shortlist. We didn’t run them; we pulled their entries from each vendor’s pricing pages and documentation. Prices and plan limits are accurate as of October 24, 2026, in US dollars.
We make Skyvia, so it’s listed first, and we judged it on the same fields as every other tool, including its limits. The tested tools come next, then the rest.
Some tools made our long list and still didn’t make this one. dbt, for example, transforms data once it’s in the warehouse, but extracting and loading it is somebody else’s job. Apache Airflow is out for a similar reason, since it schedules and monitors workflows while other tools do the actual data movement. With Google Cloud Dataflow, you write Apache Beam pipelines yourself, and the ready-made templates stick to Google Cloud and database sources, so an app like HubSpot isn’t covered.
SQL Server Integration Services packages can run in Azure Data Factory (listed below) once you move to the cloud. Older enterprise suites such as IBM DataStage and Pentaho Data Integration mostly matter to teams already running them. Among engines you host yourself, such as Apache NiFi, Airbyte is our open-source pick.
The 12 best ETL tools
Best for teams without a data engineer: Skyvia
Skyvia is a no-code cloud platform with a visual interface. Of the five, its Replication wizard got me running fastest. Warehouse loading, reverse ETL, and two-way sync all come in one subscription (handy for small teams). Where it trips is schema changes. New source columns stay switched off until you turn them on by hand.
- Best for: teams with nobody on data engineering who want point-and-click replication into Snowflake, BigQuery, Redshift, Azure Synapse, Databricks, or a plain database.
- Schema changes: not automatic. You’ll see the new column in the replication task, just not ticked. So you tick it, hit save, and decide whether the table gets reloaded. Cloud sources such as HubSpot hide one more trap. Their metadata is cached indefinitely by default, and until you clear it, the field stays out of sight.
- Fastest sync: once a minute, if you’re on Professional or Enterprise. Standard runs hourly; Free and Basic run once a day.
- Pricing: you pay for records written each month. Basic gives you 5M records and daily runs for $79 a month billed annually ($99 billed monthly). Standard costs the same $79 a month billed annually ($99 billed monthly) for just 500K records, but you get hourly runs and Data Flow; Professional is from $399 a month billed annually ($499 billed monthly) for 10M records. Free covers 10K records a month. Over one month, our test wrote 20,198 records, which is more than Free allows but well within what Basic includes.
- Deployment: Skyvia runs in the cloud, and for on-premises databases there’s a small Windows agent that connects out over HTTPS on port 443.
What happened in our test. Four replications (two sources into two warehouses) took me about 10 minutes, and each source needed only one connection. The 999 HubSpot contacts landed in 22 seconds in either warehouse. The three PostgreSQL tables needed 32 seconds for Snowflake and 1 minute 8 seconds for BigQuery. Every row count matched. HubSpot properties came through as flat columns, and each table name got the source schema glued on the front, so public.products turned into public_products.

The schema change exposed the gap. After I added a sku column, the next run loaded zero rows. Skyvia had found the column but left it unchecked.

I ticked it, saved, and accepted the prompt to reset LastSyncTime and reload. The column then landed in both warehouses.

Strengths
- Replication is covered, as is Import with reverse ETL. Need to export data or keep two systems in sync? Same subscription. Data Flow handles more involved pipelines from Standard onward, while Professional adds Control Flow for sequential or parallel execution. Hosted dbt Core runs are part of the offering too.
- Every Data Integration plan allows unlimited users. Connections don’t have a numerical cap either.
- Set up a connection once, use it again. We connected HubSpot and reused that same connection to feed both warehouses. No reason to repeat the setup just because the destination changes.
- Records-based tiers are easy to forecast, and overage stays off unless you turn it on, so runs pause at the limit instead of adding charges.
Limitations
- New columns need a manual step, as the test showed.
- Native change capture covers SQL Server only, through Change Tracking; every other source loads by timestamp-based incremental updates.
- One-minute schedules need Professional, and there’s no streaming for sub-second needs.
Best for hands-off managed connectors: Fivetran
Fivetran is a fully managed ELT service with 700+ connectors, and in our test it picked up the new column without any help. It now sells ingestion, hosted dbt, and reverse ETL (Fivetran Activations, formerly Census) on one plan, after merging with dbt Labs in June 2026. The catch is a usage bill that’s hard to predict when you run many connections.
Note: Check which connector type your source uses, because the hands-off promise applies most clearly to Fivetran-managed connectors.
- Best for: data teams that want connectors they never have to babysit and can budget for usage-based billing.
- Schema changes: automatic by default. Each connection has a setting with three choices (Allow all new data, Allow new columns, Block all new data). New columns get added, dropped ones stay with NULLs from then on, and a column whose type changes is widened to fit.
- Fastest sync: Free and Standard can’t go below 15 minutes, while Enterprise and above sync every minute.
- Pricing: billed on monthly active rows (MAR), counted separately for each connection. On Standard, paid as you go, each connection costs a $5 monthly base charge plus $495 per million MAR up to 1M, and the rate falls as that connection grows. The Free plan covers 500,000 MAR a month. Annual contracts start at $12,000 a year, with discounts from 5%.
- Deployment: cloud; a hybrid agent that keeps data in your network needs Enterprise or above.
What happened in our test. Setup ran somewhere between 15 and 30 minutes. In Fivetran, every connection links exactly one source to exactly one destination. Because I was loading two warehouses, I had to sign in to HubSpot twice and enter the PostgreSQL settings twice as well. Once saved, the destination schema name is locked, and Fivetran refused to reuse an existing one. That’s how my PostgreSQL tables ended up in a schema called FIVETRAN2_PUBLIC rather than the one I’d planned.
The HubSpot contacts were in Snowflake after 49 seconds. The three PostgreSQL tables took 9 seconds to extract, 6 to process, and 5 to load (28 seconds end to end). HubSpot into BigQuery failed until I gave Fivetran’s service account the BigQuery Data Owner role.

The sku column needed nothing from me. My connection was set to Allow all new data; the next sync re-sent only the products table, and the column was there.


Strengths
- Schema changes flow through without editing the pipeline, and one switch per connection limits that to new columns or blocks it.
- Ingestion, dbt Core runs, dbt Cloud orchestration, and reverse ETL sit on one plan and one invoice, with Free included.
- Every rate is public, down to the cent, in Fivetran’s service consumption table.
Limitations
- Fivetran pricing went through quite some changes during 2025-2026. Now, many small connections cost more than their rows suggest. Each starts at the top of its own price curve and carries its own $5 monthly base charge, and deletes count as paid MAR.
- One-minute syncs, cron schedules, Oracle connectors, and hybrid deployment need Enterprise or higher.
- A connection can’t be reused for a second destination, and its destination schema can’t be renamed, as the test showed.
- “Managed” doesn’t cover every connector. Fivetran distinguishes Standard, Lite, Partner-built, and Connector SDK connectors, with different coverage, release cycles, and SLAs. Partner-built connectors carry partner-based SLAs, and Connector SDK connectors are Python code that you write and maintain yourself.
Best for custom connectors and self-hosting: Airbyte
You can run Airbyte three ways. There’s the managed cloud service, Airbyte Core if you’d rather host it yourself, and PyAirbyte, a Python library that runs its connectors inside your own code. That flexibility suits engineering teams. In our test, it also meant the longest build by far.
- Best for: engineering teams that want to self-host, write their own connectors, or keep pipelines in Python, although the managed cloud service with 700+ connectors suits teams that don’t.
- Schema changes: you control this per connection with a setting called “Detect and propagate schema changes,” which offers four behaviors: propagate field changes only, propagate all field and stream changes, approve all changes yourself, or stop future syncs. An optional backfill fills a new column for every existing row.
- Fastest sync: Cloud Standard stops at hourly, Plus gets you to 15 minutes, and Pro or Enterprise Flex to 5. Log-based CDC runs on the same schedule; it isn’t streaming.
- Pricing: billed in credits on Standard and Plus. Cloud Standard starts at $20 a month, billed monthly, with 5 credits included, and extra credits cost $5 each (6 credits per million rows from APIs, 4 per GB from databases and files). Plus is sold in monthly credit packages from $189 a month; Pro and Enterprise Flex are capacity-based quotes. There’s no free Cloud plan, only a 14-day trial. Core and PyAirbyte are free software.
- Deployment: cloud; self-hosted Core on Kubernetes; hybrid data planes in your own infrastructure on Enterprise Flex.
What happened in our test. I built this one in code with PyAirbyte, which needed Python and Docker but no Airbyte account. It took the longest of the five: about three working days, two of them on a single error. The HubSpot source kept failing with “Config validation error: ‘credentials’ is a required property” until I set docker_image=True, and the message says nothing about Docker. On a Linux VM with 6 cores and 16 GB of RAM, first syncs took 1 minute 31 seconds (HubSpot to Snowflake), 1 minute 2 seconds (PostgreSQL to Snowflake), 2 minutes 24 seconds (HubSpot to BigQuery), and 1 minute 19 seconds (PostgreSQL to BigQuery).

Airbyte had its own ideas about my target schema. I specified one for the PostgreSQL tables; it went with the source schema, public, instead. HubSpot contacts arrived with flattened key columns, though the original properties JSON came along for the ride. At least the new sku column appeared on the next run without touching the code. There’s a catch to that result: my script was doing a full refresh every time.

Strengths
- Four schema options per connection, from full auto-propagation to manual approval, plus a column backfill that Cloud doesn’t bill.
- Self-hosting Core costs nothing, and if the catalog lacks a source, the Connector Builder or the Python CDK lets you add it.
- Run out of credits on Standard or Plus, and your syncs keep going. You just get billed for the overage later.
Limitations
- Standard syncs at most hourly; faster schedules need Plus or Pro.
- Marketplace connectors are maintained by the community and fall outside Airbyte’s support terms, and on Core even Airbyte’s own connectors get Slack-only support.
- Self-hosting Airbyte still means looking after your own infrastructure, although abctl handles the local Kubernetes setup through Docker. The license has its own fine print: commercial use is fine, but offering Airbyte itself as a hosted service is restricted under ELv2. CDC schema changes deserve a little caution too. Airbyte recommends approving them manually, with new columns requiring a refresh before CDC can track them.
Best for SQL and Python modeling in the warehouse: Matillion
Pipelines in Matillion are drawn on a drag-and-drop canvas, while the transformations themselves run inside your warehouse (push-down). There’s an AI assistant layered on, too, and the platform is now called Maia Foundation (it used to be Data Productivity Cloud). Do your complex transformations happen after the load, in Snowflake, Databricks, Redshift, or BigQuery? If so, Matillion was built for you.
- Best for: data engineers who already model in the warehouse with SQL, Python, or dbt and would like ingestion and orchestration to live in the same tool.
- Schema changes: manual for batch pipelines. Its own docs admit the connectors “do not automatically adapt to schema drift,” which leaves you updating the component and the target table by hand. Streaming CDC pipelines on the Scale plan do pick up new columns once they hold data.
- Fastest sync: any plan can schedule runs every minute, and Scale adds near-real-time streaming CDC.
- Pricing: credits pay for the hours your pipelines run, at 1 credit per task hour for orchestration and 3 for transformation, plus any extra developer users. You can buy Developer, Teams, or Scale as an annual package or pay-as-you-go. What you won’t find is a dollar figure, since every price comes from sales. The 14-day trial gives you 500 credits to play with.
- Deployment: fully hosted on any plan; on Scale, Hybrid SaaS puts the runner in your own AWS or Azure account.
What happened in our test. Work in Matillion lives in projects, and each destination gets its own environment. I gave the Maia assistant a go, but it was slow for this job, so I built the two pipelines by hand: HubSpot and PostgreSQL into Snowflake, then the same pair into BigQuery. Each PostgreSQL table wanted a Load component of its own, and that gets tedious fast. As a first-time user, I needed about two hours, including a BigQuery permission error.

The Snowflake pipeline ran in 21 seconds. The sku column didn’t flow through on its own: Matillion showed it when I opened the component, and I edited the pipeline to add it, exactly as the docs describe. BigQuery rejected HubSpot column names such as “Country/Region,” so I removed those columns, and that run took 16 seconds. Afterward, 499.9 of the trial’s 500 credits were left.

Strengths
- Task hours are charged only while a pipeline is actually running, and validating or sampling data costs nothing.
- The same product works across Snowflake, Databricks, Redshift, and BigQuery; SQL pushes down on all four, Python on Snowflake only.
- Your Git-hosted dbt project can run inside a pipeline through a dbt Core component, and there’s a connector for kicking off dbt Cloud jobs too.
Limitations
- New source columns mean editing components by hand in batch pipelines, as the test showed.
- Streaming CDC, hybrid deployment, and custom SSO need the Scale plan, and Premium connectors need an extra subscription on any plan.
- There’s no public price per credit, per plan, or for overage. Want a number? Talk to sales first.
Best for real-time data from production databases: Estuary
Estuary, which was Estuary Flow until March 2026, captures database changes nonstop. Each destination then gets them in real time or on a schedule- your call. It’s the tool here for teams whose dashboards can’t wait for the next batch. The bill counts connector hours as well as data, which caught me out.
- Best for: Teams that want production database changes showing up in operational dashboards while they’re still relevant. Alerts and applications benefit too. Estuary is particularly appealing when you need continuous data capture but have no desire to maintain a streaming stack yourself.
- Schema changes: New columns usually don’t need your attention. Estuary Captures checks the source every 15 minutes by default and carries new fields into the destination automatically, even on the free plan. Historical rows won’t suddenly acquire values, though. They’ll show NULL until you backfill. Breaking changes are a different matter: by default, the destination backfills the affected table. You can change that behavior to avoid backfilling, deactivate the task, or stop it altogether.
- Fastest sync: Capture doesn’t wait around for the next scheduled batch; it runs continuously. Delivery to a warehouse is another story. The default interval is 30 minutes, though setting Sync Frequency to 0s tells Estuary to push changes as quickly as possible.
- Pricing: The meter runs on data movement, at $0.50 per GB. Bear in mind that the same data counts once when captured and again for each destination it reaches. Connector instances have their own monthly charge: $100 apiece at first, falling to $50 for instances beyond the sixth. There’s no long-term commitment. The free Developer plan gives you 10 GB per month and two connector instances. Exceed that allowance, and you’re moved into a 30-day free trial rather than straight onto a paid bill.
- Deployment: cloud in US, EU, and APAC regions; private and bring-your-own-cloud deployments on Enterprise contracts.
What happened in our test. Estuary calls source integrations captures and destination integrations materializations. For PostgreSQL, Estuary requires a publication and a replication slot; the connector can create the replication slot automatically, and may create the publication automatically if it has suitable permissions. For Snowflake, Estuary first uploads data changes to a Snowflake table stage before transactionally applying them to the target table, so Snowflake stage permissions can affect setup.docs.

Rows arrived almost as soon as I published, and the sku column appeared on the next sync with no change from me. Estuary’s dashboard doesn’t display how long a run takes, which is why there’s no timing for it here. HubSpot properties land as raw JSON, which you parse in SQL.
I’d been so focused on moving data that I’d forgotten streaming pipelines also spend a lot of time doing absolutely nothing. Billable nothing, as it turns out. When I checked partway through September, 0.10 GB of data had somehow come with 1,123 task hours at $0.14 an hour, so $157.22 billed so far, thankfully paid for by the trial credit.

Strengths
- Estuary charges the same whether you deliver changes in real time or on a schedule. How often the destination gets updated is up to you, not your subscription tier.
- New columns are rarely a reason to get involved. Even the free plan handles schema evolution automatically. Breaking changes are where you get a say: each destination can have its own rules for dealing with them.
- Your source database only has to do the work once. A single capture can supply several destinations. Add another one later, and Estuary backfills it from data already stored in the cloud rather than going back to interrogate the source database all over again.
Limitations
- Every GB is billed again for each destination it reaches, and volume is measured as uncompressed JSON, so compressed sources bill larger than they look.
- Connector instances bill by the hour while they run, whether or not data moves, as the test bill showed.
- SSO, a HIPAA BAA, private networking, and dedicated support all sit behind an Enterprise contract, and the SaaS reverse ETL catalog is short (HubSpot, Slack, Google Sheets).
Best for governed enterprise integration: Informatica
Informatica’s cloud ETL lives inside its Intelligent Data Management Cloud (IDMC), next to ELT, replication, and change data capture. Salesforce has owned Informatica since completing the acquisition in November 2025. It’s designed for large organizations, the kind with many systems, strict controls, and a dedicated team to run the platform.
- Best for: enterprises that are standardizing integration, replication, and data management on one governed platform, as well as PowerCenter customers moving off on-premises servers.
- Schema changes: depend on the service. By default (Asynchronous), mapping tasks refresh the schema when you edit them; set to Dynamic, they refresh it on every run and can alter the target table. CDC replication jobs set a policy per change type (add, modify, drop, or rename a column): ignore, replicate, stop the job, or stop the table.
- Fastest sync: scheduled tasks as often as every 5 minutes; CDC replication runs continuously.
- Pricing: billed in IPUs consumed across IDMC services, and no price is published: it’s a sales quote. On the free Cloud Data Integration plan, you get up to 20M rows or 10 compute hours a month, and IDMC services come with a 30-day trial as well.
- Deployment: pick one of three (Informatica hosts it, it runs serverless on AWS or Azure, or a Secure Agent sits in your own network or cloud).

Strengths
- Log-based CDC reads from Oracle, SQL Server, MySQL, PostgreSQL, Db2, SAP HANA, and MongoDB, and Snowflake, BigQuery, Redshift, and Databricks are among the places it writes to.
- Schema drift rules set separately for each kind of change, down to stopping one table.
- A genuinely usable free tier for smaller jobs.
Limitations
- No public prices, and estimating IPU use means working through Informatica’s measurement guide.
- PowerCenter 10.5.x lost support on March 31, 2026, which leaves on-premises shops with an IDMC migration ahead of them.
- A CDC job won’t notice a schema change until some row in that table changes. BigQuery targets, for their part, can’t take renamed or modified columns at all.
Best for AWS-first engineering teams: AWS Glue
Amazon’s answer is AWS Glue, a serverless ETL service built around Spark and Python jobs and crawlers that catalog what you have. If your data and your warehouse already sit in AWS, it’s the obvious place to start. Being at home in Apache Spark helps a lot, too.
- Best for: AWS engineering teams after pay-per-second ETL into S3, Redshift, or a lakehouse, who are happy writing Spark.
- Schema changes: handled by the crawler’s schema change policy, which by default updates the Data Catalog to match the source; you can limit it to adding new columns or have it ignore changes. ETL jobs can update a table’s schema on their own only for Amazon S3 targets.
- Fastest sync: scheduled jobs and crawlers can’t run more often than every 5 minutes, although Spark Streaming jobs keep running continuously.
- Pricing: AWS bills DPU-hours by the second, with a 1-minute minimum per job. In US East, Spark jobs are billed at $0.44 per DPU-hour on Glue 5.1 and $0.308 on Glue 6.0, and crawlers are billed at $0.44 per DPU-hour with a 10-minute minimum per run. There’s no free tier for jobs; the Data Catalog is free up to 1 million objects and 1 million requests a month.
- Deployment: serverless, on AWS only. Jobs reach private databases through VPC connections.

Strengths
- Per-second billing with no platform fee, and Glue 6.0 cut the Spark rate by 30%.
- Its native HubSpot connector reads and writes, and with Snowflake and BigQuery connections on top, a pipeline like our test could run entirely in Glue.
- Redshift can get fresh database records without a line of code from you. Glue’s zero-ETL integrations continuously bring in data from self-managed databases. PostgreSQL is covered, as are MySQL, Oracle, and SQL Server. Your database still does its job; Glue takes care of getting those changes into Redshift.
Limitations
- Without database log access, Glue jobs have to rely on bookmarks and a steadily increasing key for incremental loads. Log-based zero-ETL gets around that limitation, though only when the destination is provisioned Redshift.
- For warehouse targets, Glue’s docs describe no automatic column propagation, so new columns mean job changes.
- The version label sets the price: a Spark job left on Glue 5.1 pays about 43% more per DPU-hour than on 6.0.
Best for Azure and SSIS migrations: Azure Data Factory
Azure Data Factory (ADF) is Microsoft’s managed service for building ETL and ELT pipelines on Azure, with a visual designer, Spark-based mapping data flows and a way to rehost SSIS packages. It fits teams whose data already lives in Azure. One thing to know first. Microsoft now describes Data Factory in Microsoft Fabric as “the next generation of Azure Data Factory,” and that’s where new features go.
- Best for: Azure-first teams, and doubly so when SSIS packages or on-premises SQL Server workloads are moving to the cloud.
- Schema changes: a setting in mapping data flows. Tick Allow schema drift in the source and sink (with auto-mapping on), and new columns pass through. The simpler Copy activity needs an existing target table to contain every source column.
- Fastest sync: pipelines are batch and can be triggered every minute; a CDC resource, still in preview, can pick up changes continuously.
- Pricing: pay as you go per activity run, data movement, and compute. In East US, orchestration costs $1 per 1,000 activity runs, cloud data movement $0.25 per DIU-hour, and mapping data flows $0.274 per vCore-hour (General Purpose) on a cluster of at least 8 vCores. There’s no free tier for ADF itself. The general Azure free account is the only way to use it at no cost, with a one-time $200 credit for the first 30 days.
- Deployment: runs on Azure, with a self-hosted integration runtime for on-premises or private networks and an Azure-SSIS runtime for the packages you already have.

Strengths
- Schema drift is a per-source and per-sink choice in mapping data flows, so new columns can flow through, and nobody has to redesign anything.
- You’re billed $1 per 1,000 activity runs for orchestration, which is cheap, and runtime is prorated by the minute.
- It reaches both worlds, with on-premises sources connected through the self-hosted runtime and existing SSIS packages running unchanged.
Limitations
- New capabilities ship to Fabric Data Factory, which uses capacity-based pricing. ADF stays fully supported with no forced upgrade, but its What’s new page lists mostly Fabric migration items for the past year.
- The HubSpot connector reads only, so writing back to HubSpot needs another tool.
- Continuous CDC is a preview feature without self-hosted runtime support, and Snowflake and BigQuery aren’t among its targets. Every data flow run also bills a minimum 8-vCore cluster.
Best for replication with data quality checks: Talend (Qlik Talend Cloud)
Talend’s product now lives on as Qlik Talend Cloud, which puts Qlik’s replication and CDC together with Talend’s transformation, data quality, and governance tools. Anyone looking for the free Talend Open Studio is out of luck, because it was retired in January 2024. What’s on sale today is a commercial product. Buy it if you’d rather have CDC, data quality, and governance from one vendor than glue separate products together.
- Best for: bigger organizations running real-time database replication with data quality checks on the way in, often Qlik analytics users already.
- Schema changes: a setting called Automatic schema evolution, configured per change type. For an added column, a type change, or a dropped column, you choose Apply to target, Ignore, Suspend table, or Stop task. SaaS sources like HubSpot support only data type changes this way.
- Fastest sync: hourly on Starter. Install Qlik’s Data Movement gateway yourself and databases sync continuously from Standard up, while SaaS sources get 15-minute syncs on Standard and 5-minute syncs on Premium and Enterprise.
- Pricing: a capacity subscription measured on data volume moved (plus job executions and duration on Premium and Enterprise). All four editions (Starter, Standard, Premium and Enterprise) are priced by sales quote. The 14-day trial needs no card and has no data limit.
- Deployment: Qlik Cloud with a fully managed gateway on Starter; hybrid with your own Data Movement gateway from Standard up; fully client-managed options under separate Qlik products.

Strengths
- From Standard up, you get continuous log-based CDC from SQL Server, Oracle, and Db2, and every edition can run scheduled CDC from MySQL, PostgreSQL, and SQL Server.
- Database schema changes get an action per change type, including suspending just the affected table.
- The trial includes Talend Studio for building jobs, with no credit card.
Limitations
- No published prices for any edition.
- Starter tops out at hourly syncs, and because it can’t use the self-installed Data Movement gateway, real-time CDC isn’t available on it.
- Date fields from HubSpot arrive as raw UNIX millisecond timestamps, and converting them is your job, not Qlik’s. Qlik documents no dbt integration.
Best for no-code ELT with published prices: Hevo
Hevo is a managed no-code ELT service that publishes monthly and annual prices for its Starter and Professional tiers, which is rarer than it should be in this category. Teams who want SaaS and database pipelines that run on their own, inside a fixed monthly quota, will feel at home here. Before you sign, ask which pipeline type you’ll land on, because Hevo is moving customers from Standard pipelines to a newer one called Edge.
- Best for: analysts and small data teams who want no-code ELT into a warehouse, with log-based change capture from production databases on top.
- Schema changes: Edge pipelines have one Schema Evolution Policy per pipeline, set to Allow all changes, Allow column-level changes only, or Block all changes. Under the first two, a new column loads as soon as Hevo detects it, with NULLs in older rows. Standard pipelines do the same through an Auto Mapping switch.
- Fastest sync: hourly on Starter. Streaming exists for log-based pipelines, but Hevo’s sales team turns it on.
- Pricing: billed on events, where each record inserted, updated, or deleted in the destination counts as one. Starter is $299 a month billed monthly ($265 a month billed annually) for 5M events. The Free plan covers 1M events a month with no card, and there’s a 14-day trial.
- Deployment: cloud.

Strengths
- A permanent Free plan and a public monthly and annual price for every Starter and Professional tier.
- The Edge schema policy documents what happens for each kind of change, and it widens column types on its own (Integer to Float to String, for example).
- Six database families get log-based CDC, and Edge even does native SQL Server CDC.
Limitations
- What happens when the month’s events run out? Hevo’s own pages don’t agree: the pricing FAQ charges extra events on demand, but the docs describe a short grace period followed by paused pipelines.
- You can’t create new in-pipeline transformations anymore, so transforming happens after loading, with dbt (and Edge only accepts dbt projects hosted on GitHub).
- Edge doesn’t detect a new column until it holds data. And “Block all changes” doesn’t block type changes, which still reach the destination.
Best for simple scheduled replication: Stitch
Stitch is a plain, inexpensive cloud ELT service built on the open-source Singer connectors, and it’s now a Qlik product. It’s cheap to start and fully self-serve: $100 a month buys 5M rows, paid by card. Its own site, though, now steers new users to Qlik Talend Cloud instead.
- Best for: small teams after simple scheduled replication from SaaS apps and databases into one warehouse, bought with a card and no sales call.
- Schema changes: there’s no policy setting. Key-based incremental and full-table syncs pick up a new column and tack it on with NULLs in existing rows. Want it backfilled? That takes a table reset, and the re-replication eats into your row quota. Log-based syncs from SQL Server, MySQL, or Oracle are less forgiving, since any structural change forces you to reset the table by hand.
- Fastest sync: the interval scheduler goes down to 30 minutes.
- Pricing: billed on replicated rows per month. Standard begins at $100 a month for 5M rows with monthly or annual billing, and Advanced runs $1,500 a month for 100M rows, billed annually. A free plan? No. You get a 14-day trial instead, and it doesn’t ask for a card.
- Deployment: cloud only, in a North America or Europe region chosen at sign-up, and you can’t move it afterward.

Strengths
- A low, published entry price with no sales call, plus a free first week of historical loading for every new integration.
- 130+ sources, plus custom ones through any Singer tap or the Import API.
- The connectors haven’t been abandoned either, since the HubSpot integration received updates in October 2026.
Limitations
- Standard caps you at one destination, five users, and at most 10 source types.
- On log-based replication from SQL Server, MySQL, and Oracle, any schema change means a full table reset, so Stitch suggests that method only for tables whose shape rarely changes.
- Change a column’s data type, and Stitch leaves the original alone, adding a suffixed copy instead (age__fl in Snowflake). Any report reading only the original quietly misses the new values. Stitch documents no dbt integration or reverse ETL.
Best for high row volumes at a flat price: Integrate.io
Integrate.io is a low-code platform that bundles a visual ETL designer, log-based CDC replication, and reverse ETL under one flat fee. That fee is the point: the price doesn’t move with data volume.
- Best for: mid-size and larger teams moving a lot of rows that want ETL, CDC, and reverse ETL from a single vendor for one fixed price.
- Schema changes: for MySQL and PostgreSQL sources in ELT and CDC pipelines, a new column shows up once the next row changes, while SQL Server has to wait for a pipeline restart. Older rows aren’t backfilled without a table re-sync, and type-change handling is a setting that’s off by default. ETL packages make it easier: the Snowflake and BigQuery destinations have an “Automatically add missing columns” option.
- Fastest sync: 60 seconds for CDC replication; five minutes, per the vendor, for reverse ETL freshness.
- Pricing: flat, with no usage meter at all. Core costs $1,999 a month with unlimited data volume, pipelines, and connectors. Whether that’s billed monthly or annually, the pricing page doesn’t say. You won’t find a free plan. There’s a 14-day trial with no credit card, but to actually buy, you start with a demo.
- Deployment: cloud, with SSH tunnels or AWS PrivateLink to access private databases.

Strengths
- 2 million rows or 200 million, the price doesn’t move, and it already includes ingestion, transformations, and reverse ETL.
- Every 60 seconds, changes read from PostgreSQL, MySQL, SQL Server, and Oracle logs land in Snowflake, BigQuery, Redshift, or S3.
- Reverse ETL, upserts included, comes in the same product and writes to HubSpot, Salesforce, and other apps.
Limitations
- You need a fairly serious budget just to get through the door: $1,999 per month, with no cheaper tier or free plan available.
- Don’t assume a schema change that worked smoothly in one source will behave the same way in another. MySQL automatically discovers new tables, while SQL Server requires a restart. HubSpot’s standard objects, contacts included, miss out on the new-column detection available to custom objects.
- dbt is another gap. There’s no documented integration with Integrate.io, leaving you to run your dbt projects separately.
Which ETL tool fits which job
Nobody wins everything here, and the test was never meant to crown anyone. So which tool for which job? Roughly this:
- No data engineer, a warehouse to fill, and a fixed budget: Skyvia. You get record-based tiers and the quickest setup we saw, though new columns will cost you a manual step.
- Connectors you never want to touch: Fivetran. It took the schema change without help. Budget for MAR on every connection.
- Self-hosting or custom connectors: Airbyte. Run Core on your own Kubernetes for free, and when one of the 700+ connectors is missing, build it in the Connector Builder.
- Heavy SQL or Python modeling inside Snowflake, Databricks, Redshift, or BigQuery: Matillion.
- Dashboards fed straight from production databases: Estuary, provided somebody keeps an eye on the connector hours.
- A large enterprise with many systems, strict controls, and a team to run them: Informatica or Talend.
- Your workflow already lives in one cloud: on AWS that means AWS Glue, and on Azure it’s Azure Data Factory.
- Published prices and a 14-day trial when you only need to connect a few sources to one warehouse: Hevo. Stitch works too if a plain $100-a-month start is what you’re after.
- Lots of rows and a preference for a flat bill: Integrate.io.
ETL tools by stack. Shopping for one stack? We’ve written separate ETL tools guides for each of these: Salesforce, HubSpot, QuickBooks, Zoho, Oracle, SQL Server, PostgreSQL, BigQuery, Redshift, Databricks, Azure, AWS, and Tableau. By approach, there are lists of no-code ETL tools, ELT tools, reverse ETL tools, ETL tools for small businesses, and Fivetran alternatives.
ETL tools compared: schema changes, sync speed, and price
Prices are list prices in US dollars as of October 24, 2026, for the entry plan or the published unit rate.
| Tool | Schema changes | Fastest sync | What the bill counts | Entry price |
|---|---|---|---|---|
| Skyvia | Manual: select the new column, then reload | 1 minute (Professional); daily on Basic | Records written per month | $79 a month billed annually ($99 monthly) for 5M records; Free plan 10K records |
| Fivetran | Automatic, with allow all, new columns only or block | 15 minutes (Standard); 1 minute (Enterprise) | Monthly active rows, per connection | $5 a month per connection plus $495 per million MAR (Standard, pay-as-you-go); Free plan 500K MAR |
| Airbyte | Setting: propagate, approve yourself or stop syncs | 1 hour (Standard); 5 minutes (Pro) | Credits on Standard and Plus; capacity on Pro | From $20 a month with 5 credits (Standard); Core free to self-host |
| Matillion | Manual in batch pipelines; automatic in streaming CDC (Scale) | 1 minute | Credits per task hour | Not published: sales quote; 14-day trial with 500 credits |
| Estuary | Automatic | Continuous capture; warehouse delivery every 30 minutes by default | GB moved plus connector instances | $0.50 per GB plus $100 a month per connector instance; Free plan 10 GB a month |
| Informatica | Per change type in CDC jobs; refresh on edit or every run in mappings | 5 minutes scheduled; CDC continuous | IPUs | Not published: sales quote; free tier 20M rows or 10 compute hours a month |
| AWS Glue | Crawler policy; jobs update schemas only for S3 targets | 5 minutes scheduled; streaming jobs continuous | DPU-hours, billed per second | $0.308 per DPU-hour for Spark on Glue 6.0 (US East), 1-minute minimum |
| Azure Data Factory | Allow schema drift setting in mapping data flows | 1 minute (batch triggers) | Activity runs, DIU-hours, vCore-hours | $1 per 1,000 activity runs and $0.25 per DIU-hour (East US) |
| Talend | Per change type for databases; type changes only for SaaS | 1 hour (Starter); continuous for databases with the gateway | Capacity: data volume moved | Not published: sales quote; 14-day trial |
| Hevo | Policy: allow all, columns only or block | 1 hour (Starter) | Events written to the destination | $299 a month billed monthly ($265 annually) for 5M events; 14-day trial |
| Stitch | Picked up automatically; log-based syncs need a table reset | 30 minutes | Replicated rows per month | From $100 a month for 5M rows |
| Integrate.io | Depends on source; type changes off by default | 60 seconds (CDC) | Flat fee, unlimited volume | $1,999 a month (Core) |
What to check before you buy an ETL tool
Every vendor leads with its connector count. Once your data sources and data warehouses are on the list, though, that number stops mattering. These questions separate the tools above faster.
What kind of connector it is. Hundreds of connectors sound impressive until you discover they’re not all playing by the same rules. Fivetran has Standard and Lite connectors, alongside Partner-built options and those created with its Connector SDK. Support isn’t necessarily coming from the same place, and neither are the release schedules or SLAs. With a Partner-built connector, you’re relying on the partner’s SLA. Build one using the SDK, and congratulations, the code is now yours to maintain. Check the type of each connector you actually need before getting too excited about the total.
Where the transformation happens. With ETL tools, the cleanup happens before the data ever touches the warehouse. ELT skips that step and loads everything raw, leaving the data processing to the warehouse’s own compute later, usually in SQL or dbt. Moving the transformation doesn’t make it go away. Fivetran says its ETL approach doesn’t include in-pipeline data cleaning or business logic, so that work lands in the warehouse, in dbt or in another tool. Count it in the plan and the budget.
Reverse ETL runs the other way: a customer score you built in the warehouse goes back into business applications like Salesforce or HubSpot. All three in one tool, or two tools side by side? Decide that early.
How changes are captured. A daily report doesn’t need a pipeline running at full speed. Scheduled polling can check for new rows every few minutes or hours and do the job perfectly well. Log-based CDC is kinder to busy databases because it reads their transaction logs, while continuous streaming suits applications that can’t wait around for scheduled updates. As for advertised sync speeds, read the pricing page before getting impressed. The fastest number is only useful if it’s included in your plan.
What happens on schema drift. Automatic propagation spares you a pile of maintenance on data pipelines. It isn’t always welcome, though. A new column full of personal data, or a type change from a source bug? You wouldn’t want either in the warehouse before someone has looked at it. Better tools let you decide per connection (pass changes through, park them for review, or block them).
How you find out something broke. “Success” on a run doesn’t prove the data is right, as the missing-column example at the top of this article shows. Fivetran recommends including observability in the ETL decision, meaning monitoring and alerting. Ask what the tool tells you when a sync finishes but a column is missing, a table is empty, or a run is late, and whether those alerts reach the people who can act on them.
What makes the bill grow. Every ETL vendor has its favorite way of counting your money. Some charge for records written, while others count monthly active rows separately for each connection. Then there are event-based and per-GB models, not to mention compute-hour billing. Flat fees look reassuring by comparison, but the real question is what happens when your pipelines start doing more work.
Take a full reload. Under row-based pricing, you may end up paying for data you’ve already moved. Hevo points out that even a schema change or rollback can cause previously counted rows to show up on the bill again under row and MAR models. Your warehouse may also charge extra compute for processing that reload. Leave a connector running under task-hour pricing, and the clock keeps ticking whether much data moves or not. Push-down transformations have their own appetite for warehouse resources.
Before committing to a year, do the math using the volume you expect next year, not just today’s tidy little test.
And don’t stop at the subscription price. Fivetran’s ETL guidance includes cloud compute and storage in the total cost, along with data egress. Keeping connectors working takes time, too. Someone still has to deal with schema changes, monitor the pipelines, and answer the occasional late-night alert. Hevo makes much the same argument, counting warehouse costs and manual effort alongside platform fees. A cheap entry price can look rather different once everyone involved gets paid.
Where it runs. Host an open-source tool yourself, and you trade data engineering time for control. A managed service swaps that time for a subscription. Data that can’t leave your network calls for a hybrid agent, plus whatever security certifications your team insists on.
How we built the test lab
Want to repeat the test? This part is for you. Same data, same targets, same change, for every tool.
Sources. A free HubSpot account with 999 contacts, all fictitious. On the PostgreSQL side, a Neon database held three tables: 500 products, 1,797 orders, and 3,603 order_items. The customers live in HubSpot and the transactions in PostgreSQL.

Why Neon. Fivetran, Airbyte, and Estuary, the three log-based tools, all read PostgreSQL changes from the write-ahead log. That only works when wal_level is set to logical, your tables sit in a publication, and a replication slot exists. Neon supports that setup. Each table also has a replica identity:
ALTER TABLE products REPLICA IDENTITY DEFAULT;
ALTER TABLE orders REPLICA IDENTITY DEFAULT;
ALTER TABLE order_items REPLICA IDENTITY DEFAULT;
Targets. In Snowflake, each tool got its own schema in a SALES_WAREHOUSE database (SKYVIA, FIVETRAN, AIRBYTE, MATILLION, ESTUARY), so no tool overwrote another’s tables. In BigQuery, each tool got its own dataset. The grants for one schema looked like this, repeated per tool:
GRANT USAGE ON WAREHOUSE COMPUTE_WH TO ROLE PUBLIC;
GRANT USAGE ON DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
GRANT USAGE ON SCHEMA SALES_WAREHOUSE.SKYVIA TO ROLE PUBLIC;
GRANT USAGE ON SCHEMA SALES_WAREHOUSE.AIRBYTE TO ROLE PUBLIC;
GRANT USAGE ON SCHEMA SALES_WAREHOUSE.FIVETRAN TO ROLE PUBLIC;
GRANT USAGE ON SCHEMA SALES_WAREHOUSE.MATILLION TO ROLE PUBLIC;
GRANT USAGE ON SCHEMA SALES_WAREHOUSE.ESTUARY TO ROLE PUBLIC;
GRANT CREATE TABLE ON SCHEMA SALES_WAREHOUSE.SKYVIA TO ROLE PUBLIC;
GRANT CREATE TABLE ON SCHEMA SALES_WAREHOUSE.AIRBYTE TO ROLE PUBLIC;
GRANT CREATE TABLE ON SCHEMA SALES_WAREHOUSE.FIVETRAN TO ROLE PUBLIC;
GRANT CREATE TABLE ON SCHEMA SALES_WAREHOUSE.MATILLION TO ROLE PUBLIC;
GRANT CREATE TABLE ON SCHEMA SALES_WAREHOUSE.ESTUARY TO ROLE PUBLIC;
GRANT SELECT ON FUTURE TABLES IN DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
GRANT INSERT ON FUTURE TABLES IN DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
GRANT UPDATE ON FUTURE TABLES IN DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
GRANT DELETE ON FUTURE TABLES IN DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
GRANT CREATE SCHEMA ON DATABASE SALES_WAREHOUSE TO ROLE PUBLIC;
Using the PUBLIC role kept the test simple, but in production each tool deserves a role of its own. Estuary loads through Snowflake stages, so it also needed GRANT CREATE STAGE on its schema.
Authentication. Every tool connected to Snowflake as one non-admin test user with key-pair authentication. Snowflake is phasing out single-factor passwords: its schedule moves all users to stronger methods between August and October 2026, and service users like an ETL tool’s can’t use passwords at all. BigQuery had its own hiccups. Fivetran and Estuary failed until their service accounts were given the BigQuery Data Owner role, and Matillion threw a permission error until the Google Cloud APIs were switched on.
Limits of the test. Free tiers and trials kept the data small, and fewer than 7,000 rows can’t tell you anything about performance or scalability at volume. Push-down transformations weren’t tested either. Two warehouses were for comparison only; most companies run one. Every run was started by hand.
Want to see how your own HubSpot or PostgreSQL data lands in Snowflake or BigQuery? Skyvia’s free plan covers 10K records a month without a credit card, and a replication takes a few minutes to set up in the wizard. Create a free Skyvia account and run your first sync today.
FAQ for Best ETL Tools in 2026
How is log-based CDC different from incremental updates?
Log-based change data capture goes straight to the transaction log. Every insert, update, and delete shows up there, and not one query has to touch the tables. Incremental updates do query the source, asking for whatever changed since the last run, usually by timestamp. That gap counts on big, busy databases, where CDC is lighter on the source and nearer to real time. A few thousand rows an hour? Timestamps handle that fine.
Is open-source ETL you host yourself cheaper than a managed service?
Sometimes, but the license is the smallest cost. Servers, upgrades, and monitoring still cost money, and so does the engineer who fixes a broken connector at 2 a.m. Our PyAirbyte pipeline costs nothing in software and about three working days to build. With a managed tool, the vendor takes that work on and bills you for it.
How do cloud ETL tools reach databases behind a firewall?
Usually through a small agent installed inside your network that makes outbound connections to the cloud service, so you don’t open inbound ports. Informatica’s Secure Agent, Azure Data Factory’s self-hosted integration runtime, and Skyvia’s Windows agent all get installed inside your network, and Skyvia’s reaches out over HTTPS on port 443. Other common routes are SSH tunnels and private networking.
Do ETL tools work with dbt?
Most of the ELT tools here do, in different ways. Some will run your dbt Core project after every load, others trigger dbt Cloud jobs, and a few hand scheduling to an orchestrator like Airflow. Talend, Stitch, and Integrate.io don’t document any dbt integration, while Skyvia runs dbt Core projects straight from Git (there’s no dbt editor).
Is ETL the same as SQL?
No. SQL is a language for querying and changing data. ETL is a process: extract data from sources, transform it, and load it somewhere useful. SQL often does the heavy lifting in the transform step, but ETL can also run on Python, Spark, or dedicated tools.
Is Databricks ETL or ELT?
It handles both, but it leans ELT. Most teams land raw data in Delta Lake first, then clean and reshape it in place with Spark or SQL, often in bronze, silver, and gold layers. You can still transform before loading if your pipeline needs it.
What is an ETL data warehouse?
It’s a warehouse fed by ETL pipelines. Data is pulled from apps, databases, and files, cleaned and standardized, then loaded into one central store built for reporting. The result is consistent, analysis-ready data instead of scattered raw records.

