Jobber to Salesforce migration
Moving from Jobber to Salesforce Sales Cloud transforms field-service operations into a fully-structured CRM with pipeline management, forecasting, and territory controls. FlitStack AI maps every Jobber client, property, job, quote, and custom field to the corresponding Salesforce object — preserving original timestamps, owner assignments, and property-to-account relationships so your Salesforce reporting reflects the full operational history from day one.
FlitStack AI migrates contact + accounts, account or property__cs, opportunity or quotes, task + case or job__cs and order or invoice__cs from Jobber to Salesforce, with their history and the associations between records. Every field is mapped and validated, a sample run is checked with you before the full migration, and the whole move can be rolled back in one click. Typical timeline: 72–96 hours for under 30,000 records.

What moves from Jobber to Salesforce?
Jobber stores field-service data in a flat client-property model where clients, properties, jobs, quotes, and invoices are separate but loosely linked records.
Read the full summary
Salesforce Sales Cloud uses a hierarchical Account-Contact model where Contacts attach to Accounts, Opportunities attach to Accounts, and all objects have foreign-key relationships governed by Salesforce's sharing and security model. The migration maps Jobber Clients to Salesforce Contacts with their parent Account, Jobber Properties to Salesforce Accounts (or a custom Property__c object for multi-location tracking), Jobber Jobs to Salesforce Tasks or a custom Job__c object, Jobber Quotes to Salesforce Opportunities or Quotes, and Jobber Invoices to Salesforce Orders or Invoices. Custom fields on all six Jobber objects migrate to Salesforce custom fields with the __c suffix, preserving data types where possible and flagging pick-list mismatches for manual value-mapping. We do not migrate Jobber's scheduling engine, route-optimization data, or client portal configurations — those require Salesforce-native rebuilds using Salesforce Scheduler, Field Service, or custom Flow. Our migration uses the Jobber API for data extraction and the Salesforce Bulk API 2.0 for ingestion, with field-level validation against the target Salesforce org's schema before commit.
Client → Contact + Account
Jobber Client maps to a Salesforce Contact with its primary property promoted to an Account record.
How it maps
The Account captures the primary service address and company-level billing info; the Contact holds client name, email, phone, and a reference back to Account via AccountId. Jobber does not enforce a company hierarchy, so we create a default Account using the client's display name when no company association exists.
Property → Account (secondary) or Property__c (custom)
When a client has a single primary service location, Jobber Property maps directly to a Salesforce Account record with type='Service Location'.
How it maps
When a client has multiple properties (common for commercial HVAC or property-management clients), the first property becomes AccountId on the Contact, and additional properties migrate to a custom Property__c object linked to the Account via lookup. This split preserves every service address and its associated job history.
Quote → Opportunity or Quote ( Salesforce native Quote object)
Jobber Quotes contain line items, pricing, and client-acceptance status.
How it maps
In Salesforce, quotes can live as Salesforce-native Quote records (which attach to Opportunities and support approval workflows) or as Opportunity records with custom fields holding the same data. We default to Opportunity-based quoting for simpler setups and surface the Quote object as an option when your team uses Salesforce CPQ or quote-approval routing.
Job → Task + Case or Job__c (custom)
Jobber Jobs map to Salesforce Tasks linked to the Contact (for work performed at a client location) with the associated AccountId populated for reporting.
How it maps
For teams that need to track job-type metadata (e.g., job category, priority, assigned crew), we recommend creating a custom Job__c object before migration so each work order is a first-class record with its own custom fields, related to the Contact and Account via lookup.
Invoice → Order or Invoice__c (custom)
Jobber Invoices migrate to Salesforce Orders by default (preserving invoice number, total amount, status, and line items).
How it maps
If the Salesforce org uses Salesforce Billing or a third-party billing integration, the Order object is the correct target. For teams without Salesforce Billing, we surface invoice records as a custom Invoice__c object with a PDF attachment placeholder so the financial record is preserved even if the billing workflow is not active.
Team Member → User
Jobber Team Members map to Salesforce Users by email address match.
How it maps
Unmatched team members are flagged before migration — either they are already Salesforce users or the team must decide to create them as Salesforce users before the full migration runs. We do not migrate role-based permissions from Jobber since Salesforce's sharing model (profiles, permission sets, roles) is destination-side schema configuration.
- ClientContacttransformed
- PropertyAccount or Property__csplit
- QuoteOpportunity or Quotemerged
- JobTask1:1
- InvoiceOrder or Invoice__c1:1
- Team MemberUser1:1
+ 5 more in the mapping below
How Jobber and Salesforce differ
The differences that decide how each record is mapped. These are what a CSV export and a native importer don't resolve for you.
| Dimension | Jobber | Salesforce |
|---|---|---|
| Core data model | Flat client-property schema; jobs and quotes link directly to clients and properties as separate objects | Hierarchical Account-Contact-Opportunity model; contacts must attach to accounts via AccountId lookup |
| Scheduling and dispatch | Native scheduling board, drag-to-reschedule, GPS routing, and technician assignment built into every plan | Salesforce Scheduler and Field Service (separate licenses) required for comparable dispatch capability |
| Quote-to-job workflow | Quotes convert to Jobs with one click; line items, pricing, and client acceptance all preserved in the job record | Quotes link to Opportunities; converting to Orders or Field Service work orders requires separate configuration |
| Multi-property tracking | Clients can have unlimited Properties with address, access notes, and service history per location | Account has one primary address; additional service locations require Account Contact Relationships or a custom Property__c object |
| Custom field extensibility | Custom fields available on all six core objects (Client, Property, Quote, Job, Invoice, Team Member) via Jobber's custom-field API | Custom fields use __c suffix on standard or custom objects; requires Salesforce admin access to create before migration |
| User licensing model | Per-user pricing from $29–$529/month; field techs, office staff, and admins all on same license tier | Sales Cloud from $25/user/month (Starter) to $550/user/month (Agentforce 1 Sales); separate Field Service license adds cost |
Jobber to Salesforce field mapping
The 30 most-used fields of 48 mapped for this pair. Custom fields are added from your own schema during scoping. Download the full mapping (CSV) ↓ or open it in the field mapping template.
-
first_nameClientFirstNameContact -
last_nameClientLastNameContact -
emailClientEmailContact -
phoneClientPhoneContact -
mobile_phoneClientMobilePhoneContact
| Jobber field | Salesforce field | Mapping | Note |
|---|---|---|---|
Client.first_name | Contact.FirstName | direct | |
Client.last_name | Contact.LastName | direct | |
Client.email | Contact.Email | direct | |
Client.phone | Contact.Phone | direct | |
Client.mobile_phone | Contact.MobilePhone | direct | |
Client.company_name | Account.Name | direct | |
Client.tags | Contact.Description | transformed | Jobber tags are comma-separated strings; stored as Description or a custom multiselect pick-list in Salesforce if the tag set is fixed. |
Client.created_at | Contact.Original_Create_Date__c | custom_field_required | Salesforce CreatedDate is set at migration time. Original Jobber create timestamp preserved as a custom datetime field for reporting continuity. |
Client.jobber_id | Contact.Source_System_ID__c | custom_field_required | Jobber's internal ID stored as an external ID field on Contact for delta-run deduplication and cross-reference. |
Property.address_line_1 | Account.BillingStreet | direct | |
Property.city | Account.BillingCity | direct | |
Property.state | Account.BillingState | direct | |
Property.postal_code | Account.BillingPostalCode | direct | |
Property.country | Account.BillingCountry | direct | |
Property.property_name | Account.Name | direct | |
Property.access_instructions | Account.Site__c | custom_field_required | Jobber property access notes migrate to a custom text area field on Account. For multi-property clients, this field holds instructions for the primary location. |
Quote.quote_number | Opportunity.Name | direct | |
Quote.total_price | Opportunity.Amount | direct | |
Quote.status | Opportunity.StageName | value_mapping | Jobber quote statuses (Draft, Sent, Accepted, Declined, Expired) map to Salesforce Opportunity Stage values. Each stage requires explicit value-mapping; unrecognised statuses default to the nearest Salesforce stage. |
Quote.valid_until | Opportunity.CloseDate | transformed | Jobber valid-until date maps to Opportunity CloseDate as the expiration deadline. For accepted quotes, CloseDate reflects when the work is scheduled to begin. |
Quote.line_items | OpportunityLineItem.Quantity + UnitPrice | transformed | Jobber line items map to OpportunityLineItem records requiring a PricebookEntry. We pre-create the Pricebook and products in Salesforce before migration so line items attach correctly. |
Quote.jobber_id | Opportunity.Source_System_ID__c | custom_field_required | |
Job.job_number | Task.Subject | direct | |
Job.status | Task.Status | value_mapping | Jobber job statuses (Scheduled, In Progress, On Hold, Completed, Cancelled) map to Salesforce Task Status values. Custom Jobber statuses require explicit value-mapping. |
Job.scheduled_date | Task.ActivityDate | direct | |
Job.assigned_technician | Task.OwnerId | transformed | Jobber technician assignments resolve to Salesforce User records by email match. Unmatched technicians are flagged before migration so the team can create Salesforce users or reassign. |
Job.job_type | Task.Type | direct | |
Job.internal_notes | Task.Description | direct | |
Job.created_at | Task.Original_Create_Date__c | custom_field_required | |
Job.jobber_id | Task.Source_System_ID__c | custom_field_required |
What to watch for in a Jobber to Salesforce migration
The issues we plan around on this pair: limits and data-model gaps that the official import tools leave to you.
Multi-property client-to-account collapse creates duplicate or orphaned address records
Jobber allows a single client to have an unlimited number of Properties, each with its own address, access notes, and service history.
How we handle it
Salesforce Accounts have a single primary billing address field (BillingAddress). When a Jobber client has more than one property, we promote the first property to the Account's BillingAddress, but every additional property must become either a secondary Account record (for genuinely separate client entities) or a Property__c custom object linked back to the primary Account. If the team does not decide on the mapping strategy before migration, additional properties land in Salesforce without a parent Account reference, breaking reports that filter by service location. We surface the property-split decision in the pre-migration schema plan so the Salesforce admin creates the Property__c object before data lands.
Jobber quote-status pick-list values require explicit Salesforce stage value-mapping
Jobber quote statuses (Draft, Sent, Accepted, Declined, Expired) are not the same as Salesforce Opportunity Stage values.
How we handle it
If the Salesforce org's sales process uses different stage names or has stage probability rules configured per record type, a direct status-to-stage map will land quotes in the wrong pipeline stage, which distorts forecasting. We require a value-mapping worksheet for every Jobber quote status, mapped to the exact StageName pick-list value in the target Salesforce org's sales process. Mismatches are flagged before migration runs so the Salesforce admin can add missing stage values to the Opportunity Stage pick-list rather than forcing quotes into incorrect stages.
Jobber custom fields require Salesforce admin to pre-create schema before migration
Jobber's custom field API exposes custom fields on all six core objects including Team Members and Property.
How we handle it
Salesforce requires a Salesforce admin to create each custom field (with the __c suffix on standard objects) in Setup before data can be loaded into those fields. If a Jobber setup has 30+ custom fields, the migration plan must include a schema-creation phase where the admin provisions every field with the correct data type (text, number, pick-list, date, checkbox). We cannot load data into a custom field that does not exist in Salesforce — the migration will fail validation on those fields. We deliver the full list of required custom fields with API names and data types in the pre-migration package.
Technician-to-User email match breaks if Salesforce users are not pre-provisioned
Jobber assigns technicians to jobs and visits using internal team member IDs.
How we handle it
Salesforce Tasks and Events require an OwnerId pointing to an actual Salesforce User record. We resolve the mapping by matching Jobber team member email addresses to Salesforce User emails — but this only works if the Salesforce org has User records for every technician before migration day. If a technician has no Salesforce User account, their assignments land as unowned Tasks, which Salesforce routing rules may reassign or drop. We run an owner-resolution audit before the migration and flag any Jobber team member who does not have a corresponding Salesforce User so the team can provision accounts or designate fallback owners.
Jobber invoice and payment data has no native Salesforce billing equivalent
Salesforce does not have a native invoicing or payment-processing engine — Invoice, Payment, and billing automation live in Salesforce Billing (a separate product) or third-party payment apps such as Stripe, PayPal, or Common Ledger.
How we handle it
Migrating Jobber invoices to Salesforce Orders or a custom Invoice__c object preserves the financial record, but the ability to send invoices, process payments, and reconcile transactions in Salesforce requires activating a billing integration. We surface this gap in the pre-migration plan and can recommend billing-integration partners, but the payment workflow rebuild is outside the scope of the data migration itself.
How the migration runs
Audit Jobber schema and Salesforce target org
We export the full Jobber object inventory including all custom fields, pick-list values, and relationship links via the Jobber API.
What this step covers
Simultaneously, we inventory the target Salesforce org's schema — existing custom fields, Opportunity Sales Processes, Order Status pick-list values, and active Record Types. The output is a gap analysis: every Jobber field that has no Salesforce target, every pick-list value with no match, and every required custom field that must be created before migration. We deliver this as a schema setup checklist your Salesforce admin completes before step three.
Provision Salesforce users for all team members
Jobber team members (technicians, dispatchers, office staff) map to Salesforce Users by email address.
What this step covers
We run an owner-resolution query against the Salesforce org to identify which Jobber team members already have User accounts and which do not. For unmatched team members, your Salesforce admin creates User records (or assigns a fallback owner for their records). No Task or Event can be assigned to a non-existent User — resolving this before migration prevents orphaned work orders.
Create Salesforce custom fields and objects
Using the schema setup checklist from step one, your Salesforce admin creates all required custom fields (with __c suffix on standard objects or on custom objects), the Property__c custom object (if multi-property mapping is selected), and the Job__c custom object (if the team prefers custom objects over Tasks for work orders).
What this step covers
We provide the exact field labels, API names, data types, and pick-list value sets needed. This step is the longest planning phase for Jobber migrations with heavy custom-field usage.
Run sample migration with field-level diff
A representative slice of records — typically 200–500 covering clients, properties, quotes, jobs, and invoices — migrates first into a Salesforce sandbox.
What this step covers
We generate a field-level diff showing every mapped field, its source value in Jobber, and its destination value in Salesforce. You verify quote-status-to-stage mapping, property-to-account resolution, owner assignment, and custom field population. No records commit to production until you approve the sample diff.
Execute full migration with delta-pickup window
The full migration runs against the production Salesforce org using the Salesforce Bulk API 2.0.
What this step covers
A delta-pickup window of 24–48 hours captures any records created or modified in Jobber during the cutover window so Salesforce reflects Jobber's final state at go-live. All operations are logged in an audit trail, and one-click rollback is available if post-migration reconciliation identifies data integrity issues. The final reconciliation report shows record counts per object, any unmapped fields, and any records that failed validation with reasons.
Jobber - Connect
- Map
- Sample
- Migrate
- Verify
- Contacts48,210 / 48,210 Done
- Companies9,134 / 9,134 Done
- Deals6,377 / 11,920 In progress
- Before sample runRestore point 01Restore
- Before full migrationRestore point 02Restore
- After verificationRestore point 03Current
How long it takes, and what drives the quote
A quote scales with record count across all six core Jobber objects (clients, properties, jobs, quotes, invoices, team members), the number of custom fields requiring Salesforce schema creation, and the degree of data-model divergence — particularly multi-property-to-account mapping and quote-to-opportunity routing logic. Jobber setups with more than 20 custom fields or more than three active quote/job statuses fall into the upper range because each pick-list value requires manual value-mapping against Salesforce's stage and status pick-lists before migration validation runs. The volume of historical notes, attachments, and visit logs may also affect processing time, as these require conversion to Salesforce ContentNotes or Files and are stored as long-text fields. Moreover, the presence of multi-currency settings in Salesforce may necessitate exchange-rate mapping for invoices and quotes, influencing the complexity of the migration. Every quote is scoped with you; there is no self-serve pricing.
Get a quote for Jobber to Salesforce →Why teams move from Jobber to Salesforce
- Jobber's flat client model cannot represent multi-location franchise or commercial operations where one client has 10+ service properties each with separate billing, contract terms, and contact hierarchies. Salesforce's Account-Contact-AccountContactRelation model scales to that structure without workaround objects or duplicate client records.
- Reporting depth in Jobber caps out at plan-level dashboards — there is no native cross-object report builder for pipeline velocity, technician utilization, or revenue-by-property segmentation. Salesforce's report builder and Tableau CRM (included at Unlimited tier) handle those analyses natively and can be scheduled for automatic delivery.
- Enterprise sales teams acquired as part of a growth strategy already run Salesforce — the migration is part of consolidating field-service records into the parent company's CRM so the entire revenue pipeline lives in one org with unified forecasting for better decision-making.
- Jobber's per-user pricing becomes unpredictable at scale as the team grows beyond the plan user cap. Salesforce's unlimited-edition model or per-feature licensing gives finance teams better predictability for annual planning because cost overages are tied to out-of-plan user counts and tier upgrades, whereas Salesforce's pricing provides fixed per-user rates with optional add-ons for advanced features.
- Advanced automation logic — dynamic service-agreement renewal triggers, tiered SLA routing, and custom invoicing rules — requires development work in Jobber that is cheaper and more maintainable in Salesforce Flow with a dedicated admin because Flow's visual builder, built-in debug tools, and version control reduce testing cycles and simplify hand-offs between business analysts and developers.
Questions, answered
Jobber to Salesforce migration questions
How long does a Jobber to Salesforce Sales Cloud migration take?
Most Jobber-to-Salesforce migrations complete in 72–96 hours of clock time for under 30,000 records across clients, properties, jobs, quotes, and invoices. Jobber setups with more than 200,000 records or complex multi-property-to-account splits extend to 5–10 days. The longest single step is Salesforce schema creation — if the org needs 20+ custom fields and a Property__c custom object, plan an additional 3–5 business days for your admin to provision those before migration day.
Will my Jobber automations (triggers, scheduling rules, notifications) migrate to Salesforce Flow?
No. FlitStack AI migrates data and schema only — Jobber automations, scheduling rules, notification templates, and client-portal configurations do not transfer. They must be rebuilt in Salesforce using Flow, Process Builder, or Salesforce Scheduler. We export your active Jobber automation definitions as a rebuild reference document for your Salesforce admin, covering trigger conditions, action types, and any conditional logic so the Flow rebuild mirrors the original intent as closely as possible.
What happens to Jobber quotes in Salesforce?
Jobber quotes migrate to Salesforce Opportunities (or Salesforce native Quote records if your org uses quote-approval workflows). The quote total maps to Opportunity.Amount, the valid-until date maps to CloseDate, and line items map to OpportunityLineItem records using a pre-created Pricebook. Quote status values (Draft, Sent, Accepted, Declined, Expired) require explicit value-mapping to your Salesforce Opportunity Stage pick-list — we surface mismatches before migration runs so your admin can add missing stage values to Salesforce.
Can I migrate Jobber custom fields to Salesforce?
Yes, but every Salesforce custom field must be created by a Salesforce admin in Setup before migration. We deliver a complete custom-field manifest listing each Jobber custom field's name, data type, target Salesforce object, and suggested API name (ending in __c for standard objects). If Jobber has pick-list custom fields, we also provide the full pick-list value set so your admin creates matching values in Salesforce's pick-list definition before migration validation runs.
How does Jobber's multi-property model map to Salesforce?
Jobber allows one client to have unlimited service Properties. In Salesforce, an Account has a single primary BillingAddress. We handle this by promoting the first Jobber Property to the Account's BillingAddress and creating additional properties as records in a custom Property__c object linked to the same Account. This preserves every service location's address, access notes, and job history while keeping all properties under one parent Account in Salesforce reporting.
Does the migration affect my Jobber account during the cutover?
No. FlitStack AI uses scoped read access on Jobber via the API — your team continues working in Jobber throughout the migration. A delta-pickup window of 24–48 hours captures any new or modified records created during the cutover window so Salesforce reflects Jobber's final state at go-live. No records are written to Jobber, and no workflows or automations are triggered on the source side.
What happens to Jobber invoices and payment records in Salesforce?
Jobber invoices migrate to Salesforce Orders (or a custom Invoice__c object if Salesforce Billing is not active). Payment records migrate as a custom Payment__c object linked to the Order, preserving transaction ID, amount, date, and payment method. Salesforce does not have native payment processing — if you want to send invoices, process credit cards, or reconcile payments inside Salesforce, you need Salesforce Billing or a third-party payment integration such as Stripe. We can recommend partners for that rebuild but the integration itself is outside the migration scope.
What about Jobber visits, GPS check-in data, and route information?
Jobber visits map to Salesforce Events with the original start and end time, assigned technician (OwnerId), and parent Contact and Account. GPS check-in and check-out timestamps have no native Salesforce equivalent — we store them as custom datetime fields (Jobber_Check_In__c and Jobber_Check_Out__c) on the Event record for reference. Jobber's route-optimization data and dispatch-board state cannot be represented in Salesforce's standard calendar model and is not migrated; Salesforce Scheduler or a third-party dispatch integration handles that rebuild.
Related migrations
Salesforce implementation
Set up Salesforce and migrate into it as one engagement.
See the service → Highrise to SalesforceMapping · history · rollbackTwenty CRM to SalesforceMapping · history · rollbackBlackbaud to SalesforceMapping · history · rollbackSuiteCRM to SalesforceMapping · history · rollbackClose to SalesforceMapping · history · rollbackBitrix24 to SalesforceMapping · history · rollback Jobber to HubSpotMapping · history · rollbackJobber to Dynamics 365Mapping · history · rollbackJobber to Zoho CRMMapping · history · rollbackSources: official documentation
- Custom Field Attributes — Salesforce Help (External ID)
- Increase Limit of Salesforce Big Object Storage Allocation — Salesforce Help
- Uploading Activity data to Salesforce — Salesforce Stack Exchange
- Sandboxes — Staging Environments for Customizing and Testing
- Case Comment STRING_TOO_LONG — Salesforce Stack Exchange
- Salesforce Data Migration: 7 Challenges and How to Solve Them — DEV
- Salesforce Duplicate Management — Salesforce Stack Exchange
Get a quote
Moving from Jobber to Salesforce?
Tell us roughly how many records and objects you have. We scope the mapping and the Salesforce setup with you, then send a quote.
Get a quote