CRM migration
Field-level mapping, validation, and rollback between ServiceTracker and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
ServiceTracker
Source
Twenty CRM
Destination
Compatibility
9 of 10
objects map 1:1 between ServiceTracker and Twenty CRM.
Complexity
BStandard
Timeline
5–10 business days
Overview
ServiceTracker is a field-service management platform built around work orders, dispatch, technician scheduling, and service-history tracking. Twenty CRM is a general-purpose open-source CRM built around People, Companies, Opportunities, Tasks, and Notes as its core objects. The two data models diverge significantly: ServiceTracker stores service records as primary entities, while Twenty stores People and Companies as primary with Opportunities linked to them. We map ServiceTracker customers to Twenty People, client organizations to Twenty Companies, and work orders to Twenty Opportunities (or a custom WorkOrder object if your setup uses custom fields that don't fit the standard Opportunity schema). Service history logs, signature captures, and parts-usage records migrate as Notes or Tasks attached to the parent Opportunity. Custom fields on ServiceTracker clients and work orders become Twenty custom fields on the equivalent object. We do not migrate ServiceTracker workflows, dispatch rules, route-optimization logic, or scheduling constraints — those must be rebuilt as Twenty workflow automations after migration. The migration runs via Twenty's REST and GraphQL APIs at up to 100 requests per minute on Cloud Pro, with a 20,000-record export limit per CSV batch that we handle in staged loads. Owner and technician resolution uses email matching against Twenty Workspace Members.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a ServiceTracker object lands in Twenty CRM, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
ServiceTracker
Customer
Twenty CRM
Person
1:1ServiceTracker customers map directly to Twenty People. The customer name maps to Person.name, phone maps to phone, and email maps to email. ServiceTracker stores the primary contact within the customer record; we extract those fields into Twenty People fields and flag the record type.
ServiceTracker
Client Organization
Twenty CRM
Company
1:1When ServiceTracker has a separate client-organization record (distinct from the customer contact), we map it to Twenty Company. The company name, industry, website, and address fields map to their Twenty equivalents. Company records must be created before Person records so the companyId relation resolves correctly.
ServiceTracker
Work Order
Twenty CRM
Opportunity
1:1ServiceTracker work orders are the primary entity in that system. We map work orders to Twenty Opportunities, mapping the work-order number to Opportunity.name, total amount to amount, and the scheduled date to closeDate. Work-order status (Open, In Progress, Completed, Cancelled) maps to Opportunity.stage with value mapping per status string.
ServiceTracker
Work Order (service-specific fields)
Twenty CRM
Custom WorkOrder object
1:1ServiceTracker work orders include technician assignment, service type, signature capture, and parts-used — fields that don't fit naturally in Twenty's standard Opportunity schema. We create a custom WorkOrder object in Twenty with these fields and link it to the Opportunity via a relation field. This requires pre-migration schema setup in Twenty.
ServiceTracker
Technician / Staff
Twenty CRM
WorkspaceMember
1:1ServiceTracker technicians map to Twenty Workspace Members by email matching. We create Person records for technicians, set their role to Workspace Member, and link their assigned work orders to the matching Opportunity's assignee field. Unmatched technicians are flagged for admin review before migration commits.
ServiceTracker
Service Activity Log
Twenty CRM
Task
1:1ServiceTracker stores activity logs with timestamps, technician name, and activity type (visit, repair, inspection). Each log becomes a Twenty Task attached to the related Opportunity. The activity type maps to Task.title, the log timestamp maps to Task.dueAt, and the technician note maps to Task.body.
ServiceTracker
Signature Record
Twenty CRM
Note
1:1ServiceTracker signature captures (customer sign-off on completed work) migrate as Twenty Notes attached to the Opportunity. The signature image is stored as a URL reference or re-uploaded to Twenty's file storage and linked. Original sign-off timestamps are preserved in the Note body.
ServiceTracker
Parts/Inventory Used
Twenty CRM
Note or Custom Line Item object
many:1Parts used per work order can be captured as a Note with a structured text block, or as rows in a custom LineItem object if the volume justifies the extra schema complexity. We surface this choice in the pre-migration planning call based on your parts tracking volume.
ServiceTracker
Contract / Service Agreement
Twenty CRM
Note or Custom Contract object
1:1ServiceTracker contracts and recurring service agreements map to a custom Contract object in Twenty if you need active-date tracking and renewal alerts. Otherwise, the contract summary migrates as a Note on the Company or Opportunity for reference. The custom Contract object supports start and end dates, renewal frequency, and linked Company or Opportunity relationships for comprehensive contract lifecycle management.
ServiceTracker
Custom Fields (Client, Work Order)
Twenty CRM
Custom Fields on respective objects
1:1ServiceTracker custom fields on clients and work orders require pre-migration creation of matching custom fields in Twenty. We deliver a field-mapping spec listing each custom field, its type (text, number, select), and the target object so your Twenty admin can create them before the migration run.
| ServiceTracker | Twenty CRM | Compatibility | |
|---|---|---|---|
| Customer | Person1:1 | Fully supported | |
| Client Organization | Company1:1 | Fully supported | |
| Work Order | Opportunity1:1 | Fully supported | |
| Work Order (service-specific fields) | Custom WorkOrder object1:1 | Fully supported | |
| Technician / Staff | WorkspaceMember1:1 | Fully supported | |
| Service Activity Log | Task1:1 | Fully supported | |
| Signature Record | Note1:1 | Fully supported | |
| Parts/Inventory Used | Note or Custom Line Item objectmany:1 | Fully supported | |
| Contract / Service Agreement | Note or Custom Contract object1:1 | Fully supported | |
| Custom Fields (Client, Work Order) | Custom Fields on respective objects1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
ServiceTracker gotchas
No native bulk data export API
Custom fields are not centrally documented
Offline mobile data must sync before migration window
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
Audit ServiceTracker data model and export capabilities
We review your ServiceTracker modules (customers, work orders, service logs, contracts, technicians) and run trial exports to confirm field availability, record counts per module, and export format constraints. We identify any custom fields, pick-list values, and relationship structures that require mapping before the migration plan is finalized. This discovery phase also validates data quality issues such as duplicate records, missing required fields, and inconsistent date formats that may need remediation before the migration run.
Design Twenty schema and create custom objects
Before data moves, we deliver a schema design spec: Twenty objects to receive each ServiceTracker entity, custom field definitions (name, type, pick-list options), and relationship fields. Your Twenty admin creates the custom WorkOrder object, custom fields, and Opportunity stage values per the spec. We validate the schema is ready before running any migration step. The spec also documents which ServiceTracker relationship IDs map to Twenty foreign keys so relationship integrity is maintained during the import.
Resolve technicians by email and flag unmatched accounts
We match ServiceTracker technician records to Twenty Workspace Members by email address. Unmatched technicians are flagged with the record ID and reason (no matching user, email mismatch). You decide whether to create Twenty users before migration or assign their work orders to a fallback owner. No Opportunity lands without an assignee decision. We also check for duplicate email addresses in ServiceTracker that may resolve to the same Twenty user, consolidating assignments to prevent duplicate Opportunity creation for the same technician.
Run a sample migration with field-level diff
We migrate a representative slice — typically 200–500 records spanning customers, companies, work orders, and activity logs — and generate a field-level diff showing source value vs. destination field for every mapped column. You verify that service types, status-to-stage mapping, and technician resolution look correct before the full run commits. The diff report highlights any truncated values, failed lookups, or data type mismatches so you can adjust the field mapping spec before we proceed to the full load.
Execute full migration with delta-pickup window
Full migration runs against Twenty via API or staged CSV imports in 20,000-record batches. A delta-pickup window (24–48 hours after initial load) captures any ServiceTracker records modified during cutover. We generate an audit log of every record inserted or updated, with rollback capability if reconciliation uncovers unexpected mapping behavior. The audit log includes the source record ID, destination object ID, transformation applied, and timestamp for compliance and troubleshooting purposes.
Platform deep dives
ServiceTracker
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 2 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across ServiceTracker and Twenty CRM.
Object compatibility
2 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
ServiceTracker: Inherits Salesforce platform API rate limits.
Data volume sensitivity
ServiceTracker exposes a bulk API — large-volume migrations stream efficiently.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during ServiceTracker to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your ServiceTracker to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave ServiceTracker
Other ways to arrive at Twenty CRM
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.