How a Databricks lakehouse and HubSpot can exchange data in both directions: HubSpot's CRM records, engagements and marketing activity landing in Delta tables for analysis, and the scores, product usage and lifetime value the data team computes flowing back to the HubSpot records that sales, marketing and service act on.
Databricks is where many data teams join product, billing, support and web data into one model of the customer. HubSpot is where marketing, sales and service act on that customer. This assessment covers how the two share data.
Public documentation. The client's own admin issues credentials, with no vendor approval needed.
Open API. The REST APIs are documented publicly. A workspace or account admin creates the service principal.
Based on the vendor's public documentation. Access terms are confirmed with the vendor and the client in discovery.
Databricks runs SQL, jobs and governance through documented REST APIs, so HubSpot can act on what the lakehouse knows, and the lakehouse can see everything HubSpot records.
Campaign Creators assessment
HubSpot's Databricks for Data Studio connector is the starting point. With Data Hub Enterprise, it brings Databricks tables into Data Studio datasets that feed reports, workflows and CRM records, in the direction Databricks → HubSpot. Databricks also offers its own HubSpot ingestion connector, which covers marketing emails and, in Beta, contacts. The custom case is narrower: the full HubSpot model landing in Delta tables (all objects, engagements, associations, property history, marketing activity), portals without Data Hub Enterprise, computed tables written to specific objects and custom objects under agreed write rules and associations, near-real-time triggers, more than one workspace, and governance through Unity Catalog. CC builds it on the SQL Statement Execution API, the Jobs API and HubSpot's CRM APIs.
Ratings are CC judgments from Databricks' public documentation and HubSpot's knowledge base. Warehouse sizing, workspaces and the tables in scope are confirmed with the client's data team during discovery.
The SQL Statement Execution API runs parameterized SQL on a SQL warehouse and returns results inline (up to 25 MiB) or as external links (up to 100 GiB). The integration's service principal sees only what Unity Catalog grants it.
A SQL warehouse bills while it runs, so frequent polling has a cost. CC reads only changed rows through Delta Change Data Feed, in batches, on a schedule agreed with the data team.
If HubSpot's Data Studio connector already writes a field, the client decides whether it keeps that field or the custom build takes it over. The data team also approves which tables and columns may reach HubSpot.
Seven parts of the Databricks platform matter to HubSpot. Two are existing connectors to scope around; five carry the custom build.
HubSpot's connector brings Databricks tables into Data Studio datasets. Datasets can drive reports and workflows, and can create or update CRM records against a match key.
Databricks offers a managed connector that ingests HubSpot data into Unity Catalog tables. Its documentation covers marketing emails, and contacts in Beta.
Runs SQL on a SQL warehouse over REST. The integration uses it to read changed rows and to merge HubSpot data into Delta tables.
HubSpot data lands in Delta tables by MERGE, keyed on HubSpot IDs. Outbound reads use Change Data Feed, so only rows that changed since the last run go to HubSpot.
Jobs run on a schedule, when a source table updates, or when files arrive. A table-update trigger starts a push to HubSpot as soon as a score table changes.
Decides what the integration may read and write. The service principal gets USE CATALOG, USE SCHEMA and table privileges on named schemas only.
The integration signs in as a Databricks service principal, not a person. It exchanges a client ID and secret for an access token.
A CC-built integration layer sits between the lakehouse and HubSpot. Outbound, it pulls changed HubSpot records and merges them into Delta tables. Inbound, a Databricks job signals when a score or usage table changes, and the layer reads only the changed rows, applies the write rules and updates HubSpot in batches.
Contacts, companies, deals and owners are created and edited in HubSpot. The lakehouse adds computed fields to those records and never creates a second copy of a person.
Scores, lifetime value and usage rollups are computed in Databricks, where the data team can test and version them. HubSpot receives the result, not the raw events.
The service principal sees only the schemas Unity Catalog grants it. Personal data columns are masked or left out of the views HubSpot reads.
Each phase ends on a gate the client signs off before the next begins. HubSpot data lands in the lakehouse first, so the data team can key every score on HubSpot IDs.
List the workspaces, catalogs and tables in scope, the HubSpot subscription, and whether the Data Studio connector or the Databricks HubSpot connector is in use. Create a service principal per workspace with an OAuth secret.
For every HubSpot field the lakehouse feeds, agree the source column, the target object, when it may overwrite, and the match key. Agree which HubSpot data may land in Databricks.
Design the Delta tables for HubSpot objects, engagements, associations and events in a dedicated Unity Catalog schema, with grants, column masks and Change Data Feed on the outbound views.
Create the custom properties, the Product Account custom object, association labels and custom event definitions in a HubSpot sandbox.
Build the extractor (HubSpot → Delta by last-modified date), the change reader (Change Data Feed → HubSpot), the writer with an error replay queue, and the job triggers.
Load HubSpot history into Delta, then send the first full set of scores and usage values to HubSpot, paced under HubSpot's API limits.
Build score-driven lists, alerts and views with notifications paused, run two weeks in parallel, then switch on.
Databricks table and column names below are examples; the client's data team names the real tables in discovery. HubSpot names are HubSpot's documented properties or the dbx_ custom properties in the schema below.
| Databricks field | HubSpot property | Object | Direction | Notes |
|---|---|---|---|---|
| HubSpot → Delta tables | ||||
| contacts table | hs_object_id + agreed properties | Contact | HS → DBX | MERGE on hs_object_id; lastmodifieddate drives incremental pulls. |
| companies table | hs_object_id + agreed properties | Company | HS → DBX | Same pattern; domain kept for joins. |
| deals table | dealstage, amount, closedate, pipeline | Deal | HS → DBX | Owner and pipeline names resolved to labels. |
| line_items table | name, quantity, price, hs_product_id | Line item | HS → DBX | Joined to deals by association. |
| engagements tables | calls, emails, meetings, notes, tasks | Engagement objects | HS → DBX | One table per type. Body text optional; governance decides. |
| associations table | from ID, to ID, association label | All objects in scope | HS → DBX | Lets SQL join contacts, companies and deals. |
| property_history table | property, value, timestamp, source | Contact, Company, Deal | HS → DBX | Lifecycle and stage timing. Fields chosen in discovery. |
| marketing_activity table | marketing email and form activity | Contact | HS → DBX | Source endpoints depend on HubSpot tier. Confirm in discovery. |
| Scores & metrics → HubSpot | ||||
| account_scores.health_score | dbx_health_score | Company | DBX → HS | Overwrites each run. Owned by Databricks. |
| lead_scores.propensity_score | dbx_propensity_score | Contact | DBX → HS | Feeds lists and lead routing. |
| ltv.predicted_ltv | dbx_predicted_ltv | Company | DBX → HS | Currency. |
| product_usage.active_users_30d | dbx_active_users_30d | Company | DBX → HS | Rolled up per account in the lakehouse. |
| product_usage.last_active_at | dbx_last_active_at | Contact | DBX → HS | Written only when newer than the HubSpot value. |
| product_usage.plan_tier | dbx_plan_tier | Company | DBX → HS | Dropdown values agreed in discovery. |
| score_runs.model_version | dbx_model_version | Company | DBX → HS | Shows which model produced the score. |
| Modeled records & associations | ||||
| product_accounts table | Product Account | Custom object | DBX → HS | One record per product account or workspace. |
| account_to_company map | Product Account ↔ Company | Association | DBX → HS | Labelled association. |
| user_to_account map | Contact ↔ Product Account | Association | DBX → HS | Role on the account as the label. |
| subscriptions table | Subscription custom object or Deal | Custom object | DBX → HS | Choice confirmed in discovery. |
| product_milestones | Custom event: Product milestone | Contact | DBX → HS | Timeline entry, e.g. first project created. |
| Identity & keys | ||||
| hubspot_id column | hs_object_id | Contact, Company | ↔ Both | Written back to the lakehouse after create, so later runs match on ID. |
| Contact | ↔ Both | Fallback match key. | ||
| domain | domain | Company | ↔ Both | Fallback match key for companies. |
| account_key | dbx_account_key | Company | DBX → HS | Unique property; the lakehouse's account ID. |
Databricks limits below come from its API reference. Values Databricks does not publish as fixed numbers, such as warehouse cost, are confirmed with the client's data team.
| Topic | Databricks | HubSpot |
|---|---|---|
| Access model | A service principal per workspace, created by a workspace or account admin. Unity Catalog grants decide what it can read and write. | Private app in the client portal, scoped per object. Custom objects and custom events need an Enterprise hub. The Data Studio warehouse connector needs Data Hub Enterprise; the custom build does not. |
| Interfaces | SQL Statement Execution API (REST) on a SQL warehouse, Jobs API, Delta Lake tables with Change Data Feed, Unity Catalog. | REST APIs: CRM objects, properties, associations, custom events, batch upserts. |
| Authentication | OAuth M2M: client ID and secret exchanged at /oidc/v1/token for an access token valid one hour. Account-level tokens can reach several workspaces. | Private app access token or OAuth 2.0 public app. |
| Query limits | Results INLINE up to 25 MiB or EXTERNAL_LINKS up to 100 GiB; statement text up to 16 MiB; external links expire within 15 minutes; results kept 12 hours. | Per-10-second burst and daily limits by subscription tier; batch endpoints take up to 100 records per call. |
| Freshness | Jobs run on a schedule, on table update, on file arrival or continuously. Change Data Feed returns changed rows by commit version. | Writes are immediate. HubSpot changes are read by last-modified date. |
| Compute cost | Each read runs on a SQL warehouse, which bills while running. Not published as a fixed figure. Size and auto-stop confirmed with the data team. | A direct warehouse-to-CRM sync in Data Studio uses no HubSpot Credits; joins and calculated fields there do. |
| Sensitive data | Unity Catalog grants, row filters and column masks applied to the service principal. Personal data excluded from outbound views unless approved. | Sensitive data properties on Enterprise; field-level permissions by team. |
Severity reflects impact on the SOW, not technical difficulty alone.
Frequent polling keeps a SQL warehouse running. CC reads changed rows in batches, lines runs up with the warehouse's auto-stop, and writes the run frequency into the SOW.
The Data Studio connector, the Databricks HubSpot connector and the custom build can overlap. A signed ownership matrix gives every HubSpot field one writer.
Scoring every record every night can mean hundreds of thousands of updates. The integration sends only values that changed, in batches of 100.
Lakehouse account keys rarely match HubSpot IDs at the start. The HubSpot ID is written back to the lakehouse after the first match, and email and domain cover the rest.
Service principals, grants and column masks are set by the client's admins. Make them a client-owned dependency in the SOW, with a date.
Development, production or regional workspaces each need their own principal and configuration. Only production writes to the live HubSpot portal.
Account health and buying propensity sit on the company and contact record, so owners see risk and intent without opening a dashboard.
Active users, last activity and plan tier trigger onboarding, expansion and save plays in HubSpot workflows.
HubSpot engagements, pipeline and marketing activity join billing and product data in Delta, so the data team can measure what actually drives revenue.
Key product events appear on the contact timeline as custom events, next to emails, meetings and deals.
Lists built from dbx_ properties stay current as the models rerun, with no manual exports.
Predicted lifetime value lands in HubSpot reports beside original source and campaign data.
Both directions share one identity map. Building the HubSpot → Delta copy first gives the data team HubSpot IDs to key every score on, so the return trip matches cleanly.
All custom properties use the dbx_ prefix in a Databricks property group. Values are computed in the lakehouse; HubSpot stores the result.
| Internal name | Label | Object | Type | Source / logic |
|---|---|---|---|---|
| dbx_account_key | Lakehouse Account Key | Company | Single-line text | Lakehouse account ID; unique |
| dbx_health_score | Health Score | Company | Number | Account health model |
| dbx_propensity_score | Propensity Score | Contact | Number | Buying propensity model |
| dbx_predicted_ltv | Predicted LTV | Company | Number (currency) | Lifetime value model |
| dbx_active_users_30d | Active Users (30 days) | Company | Number | Distinct active users, rolled up |
| dbx_last_active_at | Last Product Activity | Contact | Date and time picker | Latest product event |
| dbx_plan_tier | Plan Tier | Company | Dropdown | Current product plan |
| dbx_usage_trend | Usage Trend | Company | Dropdown | Rising, flat or falling |
| dbx_model_version | Score Model Version | Company | Single-line text | Model that produced the scores |
| dbx_last_synced | Last Lakehouse Sync | Company | Date and time picker | Set on each successful write |
| dbx_product_account_id | Product Account ID | Product Account | Single-line text | Product account key; unique |
| dbx_seats | Seats | Product Account | Number | Licensed seats on the account |
Choose the data and fields for this engagement and the direction each one syncs. Required fields are the keys the integration cannot run without. Copy the summary into the SOW or a reply to the client.
Based on public documentation from Databricks and HubSpot. Warehouse sizing, workspace layout and table names are confirmed with the client's data team during discovery.
Yes. With Data Hub Enterprise, HubSpot’s Databricks for Data Studio connector brings Databricks tables into Data Studio datasets that feed reports, workflows and CRM records, and Databricks offers its own HubSpot ingestion connector. Campaign Creators builds a custom layer on the SQL Statement Execution API, the Jobs API and HubSpot’s CRM APIs for what those do not cover, such as the full HubSpot model landing in Delta tables, portals without Data Hub Enterprise and near-real-time triggers.
HubSpot contacts, companies, deals, line items, engagements, associations, property history and marketing activity land in Delta tables. Health and propensity scores, predicted lifetime value, product usage, plan tier, product accounts and product milestones flow back to HubSpot records.
HubSpot owns the customer record: contacts, companies, deals and owners are created and edited there. The lakehouse owns the math: scores, lifetime value and usage rollups are computed in Databricks and HubSpot receives the result. A signed ownership matrix gives every HubSpot field one writer.
Seven phases, each closed by a client sign-off: discovery and access (a service principal per workspace), ownership and write rules, landing design in Unity Catalog, the HubSpot data model, the build, backfill, and workflows with a two-week parallel run before launch.
Timeline and cost depend on the workspaces, tables and directions in scope, the existing connectors in use and how often the sync runs. Campaign Creators confirms these in discovery and provides a fixed scope before the build starts.