RevOps Playbook: HubSpot–Salesforce Field Mapping and Lifecycle Design

Purpose and Scope

This playbook defines a practical, low‑friction field map and lifecycle contract for the HubSpot–Salesforce integration. It establishes a shared vocabulary for Marketing, Sales, and RevOps, constrains unnecessary sync, and ensures the two systems reflect the same business reality without fighting over ownership. The outcome is fewer duplicates, higher SLA adherence, and reporting that leadership trusts.

Principles

Map fields to decisions: if a field does not drive routing, prioritization, or reporting, do not sync it.
One owner per field: avoid bidirectional updates unless the value is inherently collaborative and strictly normalized.
Minimize free text: prefer enumerations; when free text is unavoidable, do not sync until normalized.
Document everything: publish field dictionary, truth ownership, and sync direction in a living artifact.

Object Coverage

HubSpot Contacts ⇄ Salesforce Leads/Contacts.
HubSpot Companies ⇄ Salesforce Accounts.
HubSpot Deals ⇄ Salesforce Opportunities.
Campaign touches: selective, high‑signal events only.

Field Map Framework

Segment fields by purpose:

Identity: email, user_id, company domain, external_id. One‑way from creator to consumer with strict normalization; never overwritten by enrichment.
Routing and SLA: lead_source, country/state, segment, territory_code, inferred_industry. Owner is Salesforce; HubSpot proposes only when empty.
Lifecycle: lifecycle_stage, mql_date, sal_date, sql_date, lifecycle_cohort. HubSpot owns pre‑SQL; Salesforce writes post‑SQL outcomes.
Sales context: last_touch_channel, primary_intent, last_engagement_date. HubSpot → Salesforce one‑way.
Revenue outcomes: opportunity_stage, amount, close_date, is_closed_won. Salesforce → HubSpot one‑way.
Governance: do_not_market, do_not_sell_share, consent_source, consent_date. Single source of truth replicated to both systems.

Minimal Viable Field Set (MVP)

Contacts/Leads:

email (owner: creator; direction: creator → consumer)
first_name, last_name (bidirectional with human edit precedence)
phone (bidirectional E.164)
title (bidirectional, normalized list where possible)
lifecycle_stage (HubSpot → Salesforce pre‑SQL; Salesforce → HubSpot post‑SQL flags)
lead_status (Salesforce → HubSpot)
last_touch_channel (HubSpot → Salesforce)
persona (bidirectional, enumerated)
country/state (bidirectional, standardized; validation required)

Companies/Accounts:

domain (creator → consumer)
account_tier (Salesforce → HubSpot)
employee_range, industry (enrichment → shadow → promoted)
customer_status (Salesforce → HubSpot)

Deals/Opportunities:

opportunity_stage, amount, close_date (Salesforce → HubSpot)
originating_touch_channel (HubSpot → Salesforce; write‑once)
external_id (creator → consumer)

Picklist Harmonization

Create a cross‑system list for key picks: Country, State/Province, Lead Status, Lifecycle Stage, Persona, Segment, Industry (high‑level). In HubSpot, restrict editors to the same option set as Salesforce to avoid drift. Document allowed transitions (e.g., Lead Status: New → Working → Nurturing → Qualified/Unqualified). Denormalize for analytics only in derived fields (e.g., Lifecycle Cohort YYYY‑MM).

Lifecycle Model

Define lifecycle stages in HubSpot and mirror salient milestones in Salesforce.

Subscriber/Lead: net‑new or unknown intent; maintain nurture eligibility.
MQL: fit + intent threshold reached. HubSpot stamps mql_date and sets lifecycle_stage = MQL.
SAL: Salesforce owner accepts within SLA; set sal_date and lead_status = Accepted.
SQL: opportunity created or explicit qualification flag; set sql_date. Salesforce is truth; push back to HubSpot.
Customer: closed won; mirror to HubSpot customer_status and lifecycle_stage.
Recycle: disqualified or no immediate fit; preserve reason; retain eligibility windows.

Scoring and Qualification

Build a transparent score with a small ruleset (intent, engagement, firmographic fit). Publish boundary values for MQL so Sales can understand the pipeline mix. Record “qualification reason” and “disqualification reason” in controlled picklists—these are key feedback signals into nurture and product.

Sync Directions by Lifecycle

Pre‑MQL: Salesforce can update identity, but HubSpot drives engagement context. No owner switch.
MQL → SAL: HubSpot stamps MQL; Salesforce must accept or reject with a reason. HubSpot mirrors SAL with read‑only field.
SQL and beyond: Salesforce dictates stage, amount, and outcomes; HubSpot reflects for revenue reporting and suppression.

Data Entry Controls

Forms in HubSpot: use dependent fields and validation; avoid free text for country/state.
Selling UI in Salesforce: simplify page layouts; surface marketing context (channel, recent activity) prominently to increase adoption.
Imports: require templates with validation; any bypass triggers quarantine.

Shadow Field Pattern

For volatile or low‑confidence inputs (e.g., enrichment or inferred industry), write into shadow fields (enriched_industry, inferred_industry). Promote to the canonical field when confidence exceeds threshold, the user hasn’t edited in X days, and a rule permits overwrite. This prevents clobbering clean data.

Testing and UAT

Build a sandbox map: replicate a small, representative dataset with duplicates and edge cases.
Run directionality tests: confirm no oscillation on bidirectional fields by simulating edits in both systems.
Validate lifecycle: walk sample records through MQL → SAL → SQL → Closed Won/Lost; verify timestamps and ownership transitions.
Reconcile dashboards: HubSpot and Salesforce should agree on cohort counts within 3–5%.

Change Control

Treat field mapping as code:

Versioned dictionary with owners and last modified dates.
Pull‑request workflow for edits; reviewers: RevOps + Admin + Data.
Release notes that explain impact to routing, forms, and reporting.

Common Anti‑Patterns

Syncing every field “just in case.”
Using free‑text lead sources and then trying to build attribution.
Allowing both systems to own the same pivotal field (owner, lifecycle, stage).
Introducing dozens of picklist values that are indistinguishable to Sales.

Example Field Dictionary Snippet

This example illustrates decision‑oriented mapping and ownership.

lifecycle_stage (HubSpot → Salesforce, guarded). Values: Subscriber, Lead, MQL, SQL, Customer, Recycle.
lead_status (Salesforce → HubSpot). Values: New, Working, Accepted, Nurturing, Qualified, Unqualified.
last_touch_channel (HubSpot → Salesforce). Values normalized from UTMs.
do_not_market (Bidirectional, with consent_source guard; HubSpot is initiator).
opportunity_stage (Salesforce → HubSpot). Values mirror Salesforce pipeline.

Reporting Enablers

Lifecycle Cohorts: write a YYYY‑MM field at each milestone for stable historical trends.
MQL Definition Snapshot: stamp the scoring rules version on each MQL for auditability.
Source Canonicalization: two fields only—Primary Touch Channel and Last Touch Channel.

Rollout Plan

Week 1: inventory, dictionary draft, and stakeholder review.
Week 2: sandbox implementation; build forms validation and page layouts.
Week 3: UAT with sample records; adjust picklists and directions.
Week 4: production release; hypercare with daily reconciliation.

FAQ

How many fields should we sync at MVP?

Aim for 20–30 decision‑driving fields across Contacts/Leads, Companies/Accounts, and Deals/Opportunities. Add fields only when a clear decision or report needs them.

Can lifecycle_stage be bidirectional?

Avoid it. Let HubSpot own pre‑SQL and Salesforce own post‑SQL outcomes. Mirror the non‑owner’s values as read‑only to maintain context.

What if Sales edits marketing fields like persona or industry?

Permit edits only if the fields are normalized picklists and guarded. Consider shadow fields so human edits are not overwritten by enrichment unless confidence is high.

How do we handle multiple brands or regions?

Reuse the core dictionary; overlay brand/geo codes and territory logic in Salesforce. Push only the minimum necessary segmentation flags back to HubSpot.

What breaks most integrations?

Free‑text sources, uncontrolled picklists, and unclear ownership. Enforce validation, document the dictionary, and automate reconciliation.