CRM migration
Field-level mapping, validation, and rollback between CRM Service and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
CRM Service
Source
Twenty CRM
Destination
Compatibility
7 of 12
objects map 1:1 between CRM Service and Twenty CRM.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Moving from CRM Service to Twenty CRM is a migration from a licensed enterprise platform to a self-hosted open-source CRM. CRM Service uses Salesforce's Account-Contact-Opportunity model with custom __c fields, whereas Twenty CRM uses a Company-People-Opportunity model with a cleaner, modern interface built on React and PostgreSQL. We resolve the Account-to-Company and Contact-to-People mapping, preserve the original Salesforce field labels in Twenty's custom field descriptions for auditability, and handle activity history as Task or Note records in Twenty. Twenty's GraphQL API gives us flexible querying during migration scoping. We do not migrate Salesforce Flows, Approval Processes, or Workflow Rules; we deliver a written inventory of every automation requiring manual rebuild in Twenty's permission and view configuration system. The self-hosted nature of Twenty means the customer's team handles infrastructure provisioning (Docker, PostgreSQL, hosting on PikaPods or similar) before data migration begins.
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 CRM Service 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.
CRM Service
Account
Twenty CRM
Company
1:1CRM Service Accounts map directly to Twenty CRM Company records. The Account Name field becomes Company Name, Industry maps to Twenty's industry select, Annual Revenue maps to the revenue fields, and billing/shipping addresses map to the address fields. We use Account Name as the dedupe key during import. Company is created before any People import so that the relationship is satisfied at the moment of Contact insert.
CRM Service
Contact
Twenty CRM
People
1:1CRM Service Contacts map to Twenty CRM People records. The Contact's AccountId lookup resolves to the Twenty Company record already imported. Email, phone, title, and department fields map directly. We preserve the original Salesforce Contact ID in a custom field as a reference back to the source system for audit and reconciliation.
CRM Service
Opportunity
Twenty CRM
Opportunity
1:1CRM Service Opportunities map to Twenty CRM Opportunities. StageName maps to Twenty's stage property, Amount maps to the amount field, CloseDate maps to the close date, and Probability migrates as a percentage field. Note that Reddit users have flagged that Twenty v2.0 lacks an automated incremental numbering system for Opportunity or project IDs; we flag this during scoping and the customer's admin sets up a manual naming convention or external ID system before go-live.
CRM Service
Lead
Twenty CRM
People (new record type)
1:manyCRM Service Leads do not have a direct Twenty equivalent because Twenty CRM does not ship a separate Lead object. We handle this in two ways based on customer preference: either convert all Leads to Twenty People records with a custom type field set to Lead, or create a separate custom object in Twenty called Lead to mirror the source. We preserve the Lead Status and any lead scoring values in custom fields on the destination record.
CRM Service
Custom Object (__c)
Twenty CRM
Custom Object
1:1CRM Service custom objects with the __c suffix migrate to Twenty CRM Custom Objects. Twenty requires all custom fields to be created in Settings → Data Model before CSV import begins. We pre-create the destination schema including all custom fields, their types, and any lookup relationships during the schema design phase. Custom object naming conventions differ: Salesforce uses __c suffix; Twenty uses clean API names that we define during mapping.
CRM Service
Task
Twenty CRM
Task
1:1CRM Service Tasks migrate to Twenty CRM Tasks. Subject, Status, Priority, ActivityDate, and Description fields map directly. Owner assignments resolve via email matching against the Twenty Members list, which must be provisioned before Task import (Twenty documentation explicitly requires inviting team members before importing data with owner references).
CRM Service
Event
Twenty CRM
Note
lossyCRM Service Events (meetings, calendar entries) map to Twenty CRM Notes because Twenty does not have a native Event object equivalent. We preserve the event Subject as the Note title, the StartDateTime and EndDateTime as text in the Note body, and Location as a separate line. The Note is linked to the related Company or People record via Twenty's relationship system.
CRM Service
Attachment
Twenty CRM
Attachment
1:1CRM Service Attachments and Files (ContentDocument/ContentVersion) require separate export via Salesforce ContentDocument or Attachment objects. File sizes and storage limits in Twenty depend on the customer's self-hosted PostgreSQL storage allocation. We export files to a staging location, then upload to Twenty's attachment system linked to the parent record. Very large files may require the customer to provision additional storage.
CRM Service
Campaign
Twenty CRM
Company tag or custom object
lossyCRM Service Campaigns track marketing initiatives with member status and response data. Twenty CRM does not have a native Campaign object. We map Campaigns to Twenty Companies with a tag applied for segmentation, or we create a custom Campaign object during schema setup. Campaign-to-Contact associations migrate as custom relationship records.
CRM Service
Case
Twenty CRM
Custom object or Note
lossyCRM Service Cases from Service Cloud do not have a direct Twenty CRM equivalent. For teams migrating both sales and service data, we create a custom Case object in Twenty during schema setup, mapping Status, Priority, Origin, and the Contact association. For teams only migrating sales data, Cases map to Notes on the related Company or People record.
CRM Service
User
Twenty CRM
Member
1:1CRM Service Users map to Twenty CRM Members. We match by email address. Twenty's documentation explicitly requires inviting all Members and waiting for acceptance before importing data that references owners or assignees. We extract every distinct Owner referenced on Contacts, Accounts, Opportunities, and Tasks and match against the provisioned Twenty Members list. Any Owner without a matching Member goes to a reconciliation queue for the customer's admin to provision.
CRM Service
Product2
Twenty CRM
Custom field or custom object
lossyCRM Service Products (Product2 records) do not have a native Twenty CRM equivalent. We map Products to a custom Product object in Twenty, creating the schema during setup and importing Product Name, Product Code, and Description fields. Price book entries require a custom pricing configuration in Twenty.
| CRM Service | Twenty CRM | Compatibility | |
|---|---|---|---|
| Account | Company1:1 | Fully supported | |
| Contact | People1:1 | Fully supported | |
| Opportunity | Opportunity1:1 | Fully supported | |
| Lead | People (new record type)1:many | Fully supported | |
| Custom Object (__c) | Custom Object1:1 | Fully supported | |
| Task | Task1:1 | Fully supported | |
| Event | Notelossy | Fully supported | |
| Attachment | Attachment1:1 | Fully supported | |
| Campaign | Company tag or custom objectlossy | Fully supported | |
| Case | Custom object or Notelossy | Fully supported | |
| User | Member1:1 | Fully supported | |
| Product2 | Custom field or custom objectlossy | 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.
CRM Service gotchas
API rate limits vary by edition without public documentation
Data Export frequency limited by edition tier
Custom object __c suffix causes field name mismatches in exports
Automations and flows do not migrate between platforms
Multi-select picklist values may exceed destination field limits
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
Discovery and schema inventory
We audit the source CRM Service org across all objects including standard objects (Account, Contact, Opportunity, Lead, Task, Event, Campaign, Case), custom objects with __c suffix, custom fields with their API names and types, active workflows and flows, and engagement volume per object. We also inventory the self-hosted Twenty CRM instance: PostgreSQL version, Docker configuration, hosting environment, and any existing data. The discovery output is a written migration scope document with record counts, object list, and custom field inventory.
Schema design and field pre-creation
We design the destination Twenty CRM schema based on the source inventory. This includes creating all custom fields in Settings → Data Model (text, number, date, select fields), creating custom objects where needed, and configuring field settings (required, unique, select options). We also map the Salesforce Account-Contact-Opportunity model to Twenty's Company-People-Opportunity model. All fields must be created in Twenty before any CSV import runs.
Member provisioning and owner reconciliation
We extract every distinct CRM Service User referenced on Contacts, Accounts, Opportunities, Tasks, and any custom object. We match these by email against a provisioned Twenty Members list. Any User without a matching Member goes to a reconciliation queue. The customer's admin provisions missing Members in Twenty, and we verify all users appear in the Members list before proceeding. This step is blocking for all subsequent object imports.
Sandbox migration and data cleansing
We run a full migration into a staging environment using representative data volume. Twenty's self-hosted model means we can provision a staging instance alongside production. The customer's team reconciles record counts, spot-checks 25-50 random records against the CRM Service source, and validates that Company-People-Opportunity relationships are intact. Data cleansing decisions (removing duplicates, archiving stale records, resolving null required fields) happen here, not in production.
Production migration in dependency order
We run production migration in record-dependency order: Members (verified), Companies (from Accounts), People (with CompanyId resolved), Opportunities (with CompanyId, OwnerId, and stage resolved), Tasks (with OwnerId resolved), custom objects (last, because they often have lookups to standard objects), and attachments (with parent record reference resolved). Each phase emits a row-count reconciliation report. We use Twenty's CSV import with chunking and email-based owner resolution for standard records.
Cutover, validation, and automation handoff
We freeze CRM Service writes during cutover, run a final delta migration of records modified during the window, then enable Twenty CRM as the system of record. We deliver the Workflow and Flow inventory document to the customer's admin team for manual rebuild in Twenty's Views and permissions system. We support a one-week hypercare window where we resolve any reconciliation issues. We do not rebuild CRM Service automations as Twenty configurations inside the migration scope; that is manual configuration work handled by the customer's admin.
Platform deep dives
CRM Service
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 3 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 CRM Service and Twenty CRM.
Object compatibility
3 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
CRM Service: Varies by edition and license type; not publicly documented with specific numbers.
Data volume sensitivity
CRM Service 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 CRM Service to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your CRM Service 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 CRM Service
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.