Reverse ETL: Keep CRM and Marketing in Sync

Imagine a sales rep opening an account record and seeing yesterday’s customer status. The warehouse already has a newer answer, but the rep does not work in the warehouse. A marketing team can face the same gap when the audience in its campaign tool no longer reflects the customer data its analysts use. The problem is not necessarily a missing report. The people making decisions need the relevant warehouse result inside the tools where they act.

reverse ETL: a closed folder, open laptop, and megaphone arranged left to right, interlocking gears, clock, shield, closed notebook, and coffee cup

Reverse ETL addresses that last stretch. It takes data from a warehouse or another modeled source and sends it to a destination such as a CRM, marketing tool, ad platform, or support desk. Hightouch describes the direction as moving trusted warehouse data into the tools where teams take action; the model supplies the rows, and a sync determines how and when those rows reach the destination. Hightouch’s explanation of reverse ETL makes the direction clear.

The practical question is not whether a warehouse can contain a useful customer field. It is whether a particular team needs that field in a particular tool, how a row will find the right destination record, and what should happen when the warehouse result changes. My default choice is to begin with one decision that is currently made using stale or manually copied data, then design the sync around that decision. A large collection of possible fields is a poor starting point: every extra mapping creates another way for the destination to disagree with the warehouse.

Reverse ETL makes a warehouse result usable where work happens

The name describes the data flow. A warehouse model returns rows; a sync delivers those rows to a destination used by a business team. In Hightouch’s documented workflow, a sync connects one model to one destination object, list, or table and specifies a mode, a matching rule, field mappings, and a schedule or trigger. It also reports what happened during a run. Hightouch’s sync overview describes those parts and the run results.

That definition is narrower than “make all company data available everywhere.” Reverse ETL does not decide which customer qualifies for an audience or which account should receive attention. The source model has to produce that answer. Nor does a successful warehouse query guarantee that a destination accepted every row. The sync is a delivery mechanism with its own identity rules, update behavior, and failures. Thinking of it as a complete customer strategy gives the connector credit for decisions that still belong to the data and business teams.

Consider an illustrative subscription business. Its warehouse model returns one row per customer with customer_id, last_order_date, and orders_90_days. An account manager wants last_order_date on the CRM record; a marketing manager wants a list of customers whose orders_90_days meets a chosen condition. The same modeled customer data could support two syncs, but the CRM field update and the marketing list have different destinations and may need different matching and removal behavior. Hightouch documents that a model can power multiple syncs; each sync describes how its rows appear in one destination. Its concepts guide separates models from syncs for this reason.

The useful unit of planning is therefore the action, not the connector. Ask what changes for the person using the destination: Does the account manager see a current date? Does the campaign team include the right members? Does support see context that changes its response? The first two questions in the illustration lead to specific fields and membership rules. “Connect the CRM to the warehouse” does not tell anyone whether the result is correct.

This also clarifies where reverse ETL sits next to the rest of a data pipeline. Whatever process puts data into the warehouse is upstream of the model. Reverse ETL begins once a usable model exists and carries its result out to an operational tool. If the needed fact has never reached the modeled source, a sync cannot manufacture it. If a team already has a reliable direct path for one simple update, adding a warehouse model and scheduled sync may add work without improving that decision. I would reserve reverse ETL for cases where the modeled result itself is valuable: for example, a customer status based on several records or an audience that changes as the warehouse view changes.

Choose the destination decision before choosing the data to send

A good first use case has an identifiable person, destination, and action. In the illustrative subscription case, the account manager might use a recent order date to decide whether to discuss onboarding or renewal. The marketing manager might use a warehouse-defined segment to decide who belongs in a campaign. Those are separate jobs even if both begin with customer rows. Their required freshness, field mapping, and acceptable mistakes may differ.

The stronger the consequence of a wrong destination value, the more carefully I would define the model before configuring the sync. If an account status drives a customer conversation, a field name alone is insufficient. The team needs to agree what counts as an order, which customer ID ties orders to the account, and whether the date means the latest placed order or the latest completed one. Those are examples of questions to settle, not claims about any vendor’s default behavior. A connector can faithfully send a poorly defined last_order_date and still produce the wrong business outcome.

The model should return the smallest set of rows and fields that can support the action. For the CRM update, that may mean one row per account and one or two calculated fields. For an audience, it may mean membership rows and a matchable customer identifier. Starting narrowly makes the result easier to inspect and reduces the number of records whose meaning or permissions must be settled. The cost is that a second use case may need another model or another sync later. That is usually a better cost than launching a broad feed whose fields have no clear owner or consumer.

Reverse ETL is a poor fit when the requirement is really an immediate reaction to a new event. Hightouch distinguishes direct event streaming, which sends newly collected events straight to destinations, from warehouse syncs, which are suited to enriched or aggregated context. Its event streaming guide draws that distinction. If the business action must follow a just-completed event as soon as it arrives, I would examine a direct event path. If the action depends on a customer’s history across records, I would favor a warehouse model and accept that the answer arrives on the model and sync timetable. Some workflows need both: a quick event to start an action and a later warehouse result to add context.

The reverse ETL decision should also include who owns the destination value after it arrives. Suppose a sales rep edits a CRM field that a scheduled sync also writes. The team must decide whether the warehouse is meant to replace that edit on the next run or whether the rep’s field should remain separate. Overwrite behavior depends on the field mapping and destination. My choice would be to keep human-entered notes out of a warehouse-controlled field and make the source of each calculated value plain to the people who use it.

A stable row key is the foundation of every change

Once the intended action is clear, the first technical question is what one source row represents. Is it one customer, one account, or one transaction? The answer determines the primary key. Hightouch’s change data capture compares results between runs using a unique primary key to identify which rows were added, changed, or removed. A missing or duplicated key makes that comparison unreliable. Its change data capture documentation explains the need for stable row identity.

In the illustrative subscription model, customer_id could identify a customer row if it is unique and stable for that model. last_order_date cannot: many customers may share a date, and the value changes precisely when an order occurs. An email address can also be a poor account key if several accounts share one contact address or if the address changes. These are identity consequences of the example, not a claim that every system uses the same IDs. The test is whether the chosen value identifies exactly one modeled row across successive runs.

Source identity and destination matching are related but distinct. The source key lets the sync compare this run with the previous one. The destination matching rule tells the destination which existing record a source row should update. The two values can be the same when both systems share a customer ID. If the destination stores only another identifier, the team needs a dependable relationship between them before an update can land on the intended record. Hightouch lists record matching separately from the source model and field mapping in its sync overview.

This is where an apparently successful integration can be misleading. Suppose, illustratively, the warehouse has 100 customer rows, but two have no identifier that matches an existing CRM record. A query that returns 100 rows proves only that the warehouse model produced 100 rows. It does not prove that 100 CRM records were updated. The right check is the run’s destination results and the two individual records. Hightouch’s run view distinguishes rows queried, operations attempted, successful operations, and rejected operations, and it exposes rejected rows for inspection. The sync overview documents those views.

The primary key also makes row removal a business question. A row absent from a later model result may mean the customer no longer qualifies for a segment, a filter changed, or an upstream record is temporarily missing. Change data capture can notice that the row disappeared, but the sync mode and destination determine what operation follows. Before using a removal or archive behavior, decide what absence is supposed to mean in that specific destination. For a marketing audience, removal may be the intended membership change. For a CRM account, deleting the account because it left a campaign model would be a very different choice. Hightouch’s change data capture guide separates detection of removed rows from the sync mode that acts on them.

Matching, mode, and field mapping determine what actually changes

With the row key settled, configure the destination behavior deliberately. The source model names the rows to send. The destination identifies the object, list, or table receiving them. The mode states the kind of write, the matching rule locates the target record, and the field map states which source values land in which destination fields. Hightouch documents all of these as distinct parts of a sync, along with its schedule. Its sync overview is a useful reference because it does not collapse “connected” into “correctly updated.”

For the illustrative CRM field, I would first determine whether each source customer should already have a CRM record. If so, the desired operation is to update an existing record using a dependable match. If the team expects new customers to be created, it needs a mode that can create them as well as update existing ones, and it must decide what fields a newly created record requires. Those choices are different from appending an event to a history. The correct mode follows the business meaning of the destination object, not the fact that a connector offers a menu of modes.

Next, inspect the field map one destination field at a time. last_order_date should go into a field intended for that meaning, with a format the destination accepts. A calculated eligibility flag should not silently overwrite a field that sales staff maintain by hand. If the destination expects a different representation, transform the source value intentionally and document what the destination user will see. These are design decisions for the selected connector because destinations can differ in accepted field types and update behavior.

Null or missing values deserve an explicit decision. In the subscription illustration, a blank last_order_date might mean no order has occurred, an upstream record is absent, or the model failed to calculate a date. Those meanings should not be treated as interchangeable. Before launch, inspect examples of each condition in the model and determine whether the destination field should be cleared, left as it is, or the row withheld until the meaning is known. That choice depends on the model and destination. A generic “send all columns” mapping cannot make it for you.

The first run and later runs should be interpreted differently. Hightouch’s documented change data capture compares current model results with an earlier result and sends changes, so the first run commonly processes the full current set while later runs can be smaller. Its sync overview describes this pattern. A low later operation count is therefore not automatically a failure: perhaps no mapped values changed. Conversely, a sudden jump in changed rows deserves investigation because a model or mapping change could have altered many values at once. The useful comparison is between the current model result, the expected changes, and the destination results—not a fixed assumption that every run should write the same number of rows.

I would also separate a model change from a scheduling change. If the qualifying rule for a campaign changes, first inspect how many rows enter and leave the model; only then let the sync apply the new membership. If the same model is simply running more often, ask whether the extra runs deliver a decision sooner. More frequent schedules cannot improve the underlying warehouse data’s arrival time. They can only reduce the wait between an available model result and the next sync, subject to the run and destination. That is a consequence of the documented model-to-destination sequence, not a promised latency for every connector.

Set freshness by the decision, not by the fastest available schedule

“Current” needs a concrete meaning. For the account manager, a date that updates before the next working day may be enough; for a message triggered by a just-completed event, it may be too late. Both are illustrative service expectations. The first calls for checking when the warehouse model updates and scheduling a sync after that point. The second points back to an event path that sends the event directly. Hightouch describes event streaming as the direct route for newly collected events and warehouse syncs as a route for enriched or aggregated data. Its event streaming guide supports that choice.

It helps to trace the whole sequence instead of calling a sync “real time” or “daily” in isolation. A business event occurs; source data reaches the warehouse; the model returns a new row or value; the next sync reads it; the destination accepts the operation; the user sees it. If the warehouse model updates after the scheduled sync, the user waits for another run. If the destination rejects that row, faster scheduling does not by itself correct the invalid value. The model, schedule, and destination outcome each contribute to the experienced freshness.

I would set the cadence by the latest time at which the destination value remains useful, then observe whether the pipeline meets it. A campaign list prepared for a planned send might tolerate a scheduled warehouse sync. A support workflow that needs a newly submitted request immediately should be examined for direct delivery. The cost of the warehouse path is waiting for modeled context; its advantage is that the destination can receive a result already shaped by that context. The right trade depends on whether the decision needs history and aggregation more than immediacy.

A completed run still needs a record-level check

Once a sync is live, the run status is only the first signal. Hightouch distinguishes a run that fails as a whole from a run that finishes while some records are rejected. The latter can complete with errors: some rows land and others do not. Hightouch’s retry documentation makes that distinction and advises checking rejected records. A dashboard that says the job finished is not enough to conclude that the account manager’s particular record was updated.

Return to the illustrative 100-row run. If 98 operations succeed and two records are rejected, the useful report says 98 of 100 attempted records landed, subject to what the run actually counts. The two rejected records are the work, especially if one is the account the team needed today. A percentage alone can hide that. Hightouch’s run details expose record-level errors as well as totals, so a person can inspect the destination’s message for a rejected row. Its sync overview describes the run and rejected-row views.

Retry behavior is another reason to inspect the individual error. Hightouch documents that retry handling varies by destination and error type, and that rejected records can be retried on a later run. Its retry guide explains those behaviors. A temporary rejection might clear later. A persistent mismatch in a required destination field needs a changed value, mapping, or destination setup. Repeated attempts do not make an invalid identifier valid. I would assign a person to investigate recurring rejected rows rather than treating an automatic retry as a complete recovery plan.

Alerts can shorten the time between a problem and a human response. A sync owner should watch failed rows, unexpectedly long runs, and sudden changes in record counts, then decide which conditions page a person and which can wait for review. Fivetran Activations’ alert documentation describes configurable signals for these cases. The destination and business decision still determine the right threshold and response.

I would start by routing rejected-row and whole-run failure alerts to someone who can read both the model and destination error. For a high-impact audience, a sudden drop in model size deserves attention too: it could reflect an intentional eligibility change, or it could mean that an upstream filter now excludes the intended people. A long run matters if it misses the time when the team needs the destination value. Alert thresholds therefore follow the business schedule and the normal size of that specific model. A universal row-count threshold would misread a small audience and a broad customer model in different ways.

The review loop is short but concrete. Compare the model’s current row count with the run’s queried count; inspect added, changed, and removed operations; look at successful and rejected results; then check a few records in the destination whose values matter to the user. If a record is wrong in the model, fix the model. If the model is right but the operation is rejected, inspect matching, mapping, and destination requirements. If the operation succeeds but the user sees a different value, inspect how that destination displays or later edits the field. Hightouch’s run view supplies counts and rejected-row messages, but the judgment about the correct business value remains with the team. The sync overview documents what the run view exposes.

Keep access and ownership as narrow as the first use case

Moving a warehouse result into a business tool changes who can see and act on it. The field map is therefore also an access choice: if a destination user needs an eligibility flag, sending the underlying purchase detail may be unnecessary. I would select the minimum fields that support the destination decision, then confirm that the destination’s own users and permissions suit those fields. The fact that data is already in a warehouse does not by itself authorize copying it into every connected tool.

Warehouse permissions need the same specificity. Hightouch says its basic warehouse connection uses limited read access, while certain logging and advanced sync features require a separate write permission in a configured warehouse location. Its security overview distinguishes those cases. That means “reverse ETL is read-only” is too broad a procurement or setup assumption. Before enabling an advanced feature, check the actual permissions it needs and the location to which it writes. The destination also needs whatever authority permits the intended update; the source warehouse permission alone cannot grant that.

Ownership should follow the path of a wrong value. Someone must know the business definition in the model; someone must maintain the match and field map; someone must answer for the destination workflow. One person may fill several roles in a small team, but the roles still exist. If a campaign excludes the wrong customer, the team should know whether to inspect the eligibility rule, the model row, the match key, or the rejected-row result first. That is a practical cost of the warehouse-to-tool approach: it shares a modeled answer across systems, and each boundary can change what a user sees.

Start with one sync whose outcome a user can recognize

For a first implementation, I would choose a bounded use case such as the illustrative CRM date update. Write down what one row means, the stable source key, the destination record it should match, the exact destination field, and the latest acceptable arrival time. Then inspect the model results for ordinary rows and edge cases: no order date, a changed date, and an identifier with no destination match. These examples are deliberately chosen because they exercise the parts of a sync that a happy-path record cannot reveal.

Next, configure one model-to-destination sync with the appropriate mode, matching rule, field map, and schedule. Those are the documented components of the sync, not optional finishing details. Hightouch’s sync overview lays them out. Keep the initial mapped fields small enough that a user can verify each one in the destination. If the use case is audience membership, write down what should happen when a person stops qualifying before choosing any removal behavior.

After the first run, compare the model rows with the run results and the destination records. Pay special attention to rejected rows and to whether the right existing record was updated. On a later run, change a controlled input in the illustrative test set and confirm that the resulting source row is recognized as changed and reaches the intended destination record. Hightouch’s change data capture depends on a unique source key for this comparison, and its run view reports both overall and record-level outcomes. The change data capture guide and sync overview support those checks.

Only then would I expand to more fields or another destination. A second sync from the same model may be efficient, but it inherits the model’s definitions and identity choices while adding its own match, mode, schedule, and failure paths. If the first model’s meaning is still disputed, replication will spread the dispute. If the first result is dependable and useful to its user, a second destination is a reasonable next step because its expected outcome can be described and checked just as concretely.

Reverse ETL succeeds when the warehouse answer reaches the right record in the tool where a decision happens, at a time when it is still useful. The connector provides the route. The real work is deciding which modeled answer to send, preserving row identity, choosing what changes in the destination, and noticing the records that did not land. Start with one decision whose outcome a CRM or marketing user can see, and the value of the next sync will be much easier to judge.

One person. A whole marketing team.

Invite only