CRM migration
Field-level mapping, validation, and rollback between Crust CRM and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Crust CRM
Source
Twenty CRM
Destination
Compatibility
8 of 11
objects map 1:1 between Crust CRM and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Crust CRM to Twenty CRM is a migration between two self-hosted, open-source CRMs with different architectural philosophies. Crust CRM uses a configurable module architecture with an automated workflow engine and enterprise identity management; Twenty CRM uses a custom object model built via a /metadata API with a GraphQL layer, versioning control, and CI/CD-friendly extensibility introduced in v2.0. We run a pre-migration schema audit against the Crust instance to enumerate every custom object, its field types, and module dependencies, then pre-create the equivalent Twenty custom objects before importing any data. Standard Crust objects (Contacts, Companies, Deals) map 1:1 to Twenty People, Company, and Opportunity. Crust workflows, automated sequences, and enterprise messaging modules do not migrate as code; we deliver a written inventory of every active Crust workflow with a recommended Twenty equivalent for the customer's admin to rebuild. The AGPL-3.0 licensing on Twenty is relevant for teams that intend to modify the source code; self-hosting remains free beyond hosting costs on both platforms.
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 Crust CRM 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.
Crust CRM
Contact
Twenty CRM
Person (People)
1:1Crust CRM Contacts map to Twenty Person records. Standard fields (name, email, phone, address) map directly. The Crust contact's lifecycle stage or custom status property maps to a Twenty custom field person_type__c that the customer configures during scoping, since Twenty's Person object does not have a built-in Lifecycle Stage equivalent. We use email as the dedupe key during import and link each Person to a Company via the Company link field.
Crust CRM
Company
Twenty CRM
Company
1:1Crust Companies map directly to Twenty Company records. Company name, domain, industry, employee count, and address fields map to their Twenty equivalents. We use the Crust company domain as the Website field and as the dedupe key. Company is created before Person import so that the company link relationship is satisfied at Person insert time.
Crust CRM
Deal
Twenty CRM
Opportunity
1:1Crust Deals map to Twenty Opportunities. The dealstage property maps to a Twenty pipeline stage value that we configure in Settings before migration. Pipeline and stage names migrate from Crust's pipeline-stage map as a translation table, with the Crust pipeline becoming a Twenty pipeline defined in Settings Data Model.
Crust CRM
Pipeline
Twenty CRM
Pipeline + Stage
lossyCrust pipelines with arbitrary stage names map to Twenty Pipelines defined in Settings Data Model. Each Crust pipeline stage becomes a Twenty Stage with a probability value translated from Crust. Stage ordering is preserved. If Crust has multiple pipelines, each becomes a separate Twenty Pipeline.
Crust CRM
Lead
Twenty CRM
Person (People)
1:manyWhere Crust CRM has a distinct Lead object separate from Contact, we treat all Lead records as Person records in Twenty with a person_type__c value set to Lead. Twenty's People object unifies contacts and leads without a separate object, so we preserve any Crust lead_score or lead_source fields as custom Person fields rather than splitting into separate objects.
Crust CRM
Activity (Call, Email, Meeting, Note, Task)
Twenty CRM
Task, Event, Note
1:1Crust activity records (calls, emails, meetings, tasks, notes) migrate as Twenty Task or Note records linked to the parent Person, Company, or Opportunity via the target_object and target_record_id fields. We set the activity date from the Crust timestamp to preserve timeline ordering. Call duration and disposition map to custom Task fields if defined in the Crust schema.
Crust CRM
Custom Module/Object
Twenty CRM
Custom Object
1:1Crust configurable modules are the most migration-specific object type. We run a pre-migration schema audit against the Crust instance (via REST API for cloud-hosted or database export for self-hosted) to enumerate every custom object, its field types (text, number, date, relation, multi-select, etc.), and any module-to-module lookup dependencies. We then use Twenty's /metadata API to pre-create the equivalent custom objects with matching field names and types before importing any Crust custom module data. Any field types that do not have a direct Twenty equivalent (e.g., complex Crust-specific types) are flagged during scoping with a transformation recommendation.
Crust CRM
User/Owner
Twenty CRM
WorkspaceMember
1:1Crust Users (owners assigned to contacts, companies, deals) map to Twenty WorkspaceMembers by email match. We resolve the owner assignment during import by looking up the WorkspaceMember record by email. Any Crust Owner without a matching Twenty WorkspaceMember goes to a reconciliation queue for the customer's admin to provision before record import resumes.
Crust CRM
Attachment
Twenty CRM
Attachment (via File storage)
1:1Crust attachments stored per record are exported individually with filename and record association preserved. We re-attach them in Twenty using the native file attachment mechanism. If Crust stores attachments in an external storage backend (S3, local filesystem), we coordinate with the customer's technical team for access credentials during scoping.
Crust CRM
Tag
Twenty CRM
Tag
1:1Crust tags (simple label fields on any object) map to Twenty Tag records. Tags are linked to the parent record (Person, Company, Opportunity) via the taggable_id and tag_id fields. We preserve tag names exactly as they appear in Crust.
Crust CRM
Enterprise Messaging Module
Twenty CRM
Note (documentation only)
lossyCrust CRM's enterprise messaging and identity management modules store collaboration metadata (user mentions, discussion threads, team channels) that has no direct equivalent in Twenty's data model. We export this metadata as a JSON manifest and attach it as a Note on the relevant Workspace record in Twenty for the customer's admin to review. Actual messaging history does not migrate as it is not a CRM record in Twenty.
| Crust CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact | Person (People)1:1 | Fully supported | |
| Company | Company1:1 | Fully supported | |
| Deal | Opportunity1:1 | Fully supported | |
| Pipeline | Pipeline + Stagelossy | Fully supported | |
| Lead | Person (People)1:many | Fully supported | |
| Activity (Call, Email, Meeting, Note, Task) | Task, Event, Note1:1 | Fully supported | |
| Custom Module/Object | Custom Object1:1 | Fully supported | |
| User/Owner | WorkspaceMember1:1 | Fully supported | |
| Attachment | Attachment (via File storage)1:1 | Fully supported | |
| Tag | Tag1:1 | Fully supported | |
| Enterprise Messaging Module | Note (documentation only)lossy | 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.
Crust CRM gotchas
No free trial limits pre-migration evaluation
Self-hosting shifts infrastructure responsibility to the customer
Custom object schemas require explicit discovery before migration
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
Schema audit and scoping call
We audit the Crust CRM instance across all modules (standard and custom), enumerating every object, field type, pipeline definition, stage names, owner assignments, and active workflow count. We determine whether the Crust instance is self-hosted (requiring database or SSH access) or cloud-hosted (requiring API credentials). We pair this with a Twenty workspace readiness check: confirming the customer has provisioned their Twenty workspace, verified SMTP and storage configuration, and identified any standard fields that need to be added in Settings Data Model before import. The scoping output is a written migration scope document and a fixed-price proposal.
Data export from Crust CRM
For cloud-hosted Crust instances, we extract data via the REST API with rate-limit handling and exponential backoff, paginating through all object endpoints (Contacts, Companies, Deals, Activities, Custom Modules). For self-hosted instances, we connect via database credentials or SSH and run structured export queries against the Crust database schema. We export attachments separately with filename and parent-record reference preserved. We export workflow definitions as a JSON manifest for the inventory document.
Twenty custom object provisioning
We use Twenty's /metadata API to pre-create any custom objects required by the migration. This includes creating the custom object definition (name, API name, icon), adding all custom fields with correct types (text, number, date, relation, multi-select, etc.), and configuring any lookup relationships between custom objects. Standard Twenty objects (People, Company, Opportunity) are verified as present and configured with any missing standard fields identified during scoping. Pipelines and stages are defined in Settings Data Model with probability values translated from Crust.
Data transformation and mapping
We transform exported Crust records into Twenty-compatible format. This includes splitting Crust Deals into Twenty Opportunities with pipeline and stage resolved via the translation table, mapping Crust Leads to Twenty People with person_type__c set to Lead, resolving Crust owner email addresses to Twenty WorkspaceMember records, and applying any field-level transformations (date format normalization, phone number formatting, currency conversion if applicable). Custom module records are transformed according to the schema audit output.
Import and reconciliation
We import data into Twenty in dependency order: Companies first (as the base for People link), then People, then Opportunities, then Activities and Notes, then Custom Objects last (because they may have lookups to standard objects). Each phase emits a row-count reconciliation report. We run a spot-check on 25-50 random records per object type, comparing field values against the Crust source. Any mapping corrections are made before the next phase begins.
Cutover and workflow handoff
We freeze Crust CRM writes during cutover, run a final delta migration of any records modified during the migration window, then mark Twenty as the system of record. We deliver the workflow inventory document to the customer's admin and developer teams. We support a five-day hypercare window where we resolve reconciliation issues. We do not rebuild Crust workflows as Twenty SDK code inside the migration scope; that is a separate engagement.
Platform deep dives
Crust CRM
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 Crust CRM 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
Crust CRM: Not enforced as a hard SaaS quota in the open-source distribution — limits depend on the deployment topology (Postgres sizing, container resources). Commercial Planet Crust deployments may add gateway-level throttling..
Data volume sensitivity
Crust CRM 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 Crust CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Crust CRM 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 Crust CRM
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.