CRM migration

Migrate from Crust CRM to Twenty CRM

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 logo

Crust CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

73%

8 of 11

objects map 1:1 between Crust CRM and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Crust CRM logo

Crust CRM

What's pushing teams away

  • Self-hosting requires operational investment — Docker, Postgres, monitoring, and upgrade discipline — which small teams without DevOps capacity find difficult versus turnkey SaaS.
  • Native marketplace of pre-built integrations is smaller than commercial CRMs, so customization work is often required to connect to common SaaS tools.
  • User interface and feature velocity lag commercial CRMs (HubSpot, Salesforce) because the project is community- and partner-driven rather than venture-funded.
  • Limited public review presence on G2 and Capterra makes it harder for prospects to validate before commitment compared to mainstream CRMs.
  • Workflow automation, BI dashboards, and AI features must be built on the low-code platform rather than coming out of the box, increasing implementation time for organizations that want everything turnkey.

Choosing

Twenty CRM logo

Twenty CRM

What's pulling them in

  • Top open-source CRM on GitHub with 40.6K stars, giving teams full source code access and infrastructure ownership without per-feature licensing surprises.
  • Free self-hosting under AGPL-3.0 means unlimited users and custom objects for the cost of cloud infrastructure alone, typically $20–100/month.
  • Pricing page explicitly mocks competitors for charging add-on fees for API access, webhooks, and workflows — transparency that resonates with RevOps teams burned by Salesforce.
  • Unlimited custom objects and fields with no price impact, letting teams shape the data model to their business rather than forcing business into rigid schemas.
  • Modern TypeScript/React/PostgreSQL stack means developer-led teams can extend, self-host, or integrate without fighting legacy architecture.

Object mapping

How Crust CRM objects map to Twenty CRM

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

maps to

Twenty CRM

Person (People)

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Company

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Pipeline + Stage

lossy
Fully supported

Crust 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

maps to

Twenty CRM

Person (People)

1:many
Fully supported

Where 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)

maps to

Twenty CRM

Task, Event, Note

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Crust 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

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Attachment (via File storage)

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Tag

1:1
Fully supported

Crust 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

maps to

Twenty CRM

Note (documentation only)

lossy
Fully supported

Crust 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.

Gotchas + challenges

What specifically takes care here

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 logo

Crust CRM gotchas

Medium

No free trial limits pre-migration evaluation

Medium

Self-hosting shifts infrastructure responsibility to the customer

Medium

Custom object schemas require explicit discovery before migration

Twenty CRM logo

Twenty CRM gotchas

High

Import order is enforced and critical

High

Export limited to 20,000 records and visible columns only

Medium

Soft-deleted records count toward uniqueness and trigger restores

Medium

API rate limits cap at 200 req/min on Organization tier

Low

No native email sequences — follow-up cadences require external tools

Pair-specific challenges

  • Custom object schema discovery is required before migration can begin

    Crust CRM's configurable module architecture means every organization may have unique custom objects, field types, and module-to-module lookup dependencies that are not present in a standard install. We run a mandatory pre-migration schema audit against the Crust instance to enumerate all custom modules, their field types, and any inter-module relationships. Without this audit, we cannot produce an accurate object mapping or a complete price estimate. Self-hosted Crust instances require database or SSH access for the audit; cloud-hosted instances use the REST API.

  • Crust automated workflows do not migrate to Twenty

    Crust CRM's built-in automated workflow engine (used for sequencing follow-ups, stage transitions, and CRM actions) has no equivalent in Twenty CRM's current feature set. Twenty v2.0 provides an SDK for building custom automation logic in code, but there is no visual workflow builder or property-triggered automation native to the platform. We do not migrate Crust workflows as code. We deliver a written inventory of every active Crust workflow with its trigger, conditions, actions, and a recommended Twenty implementation approach for the customer's developer or admin to rebuild post-migration.

  • Twenty's People object requires manual standard field configuration

    Twenty's People (Person) and Company standard objects have a smaller set of out-of-the-box fields compared to CRMs like Salesforce or HubSpot. GitHub Issue #13953 documents that users must often spend 30-60 minutes creating basic fields (industry, job title, department, website, social profiles) before importing data or setting up integrations. We flag this during scoping: if the customer's Crust data uses custom fields that Twenty does not include by default, we document which fields need to be created in Twenty Settings Data Model before the import phase begins.

  • Self-hosted access method determines export approach

    Crust CRM deployments vary between self-hosted (customer infrastructure) and cloud-hosted (Planet Crust managed). Self-hosted instances require SSH credentials or direct database access for export; cloud-hosted instances use the REST API. We determine the access method during scoping. If the customer is self-hosted and no technical contact is available, we coordinate with Planet Crust support to obtain a data export, which may add scope to the project timeline.

Migration approach

Six steps for a successful Crust CRM to Twenty CRM data migration

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

Context on both ends of the pair

Crust CRM logo

Crust CRM

Source

Strengths

  • Self-hosted deployment gives organizations complete data sovereignty and no vendor lock-in
  • Open-source platform with no per-seat pricing model for the community edition
  • Configurable modules allow organizations to model their exact sales process
  • Built-in automated workflow engine for sequencing follow-ups and stage transitions
  • Integrated enterprise messaging reduces the need for separate collaboration tools

Weaknesses

  • No free trial makes it difficult to evaluate the platform before committing
  • Small review sample on G2 limits third-party validation of real-world performance
  • No publicly documented API rate limits for self-hosted deployments
  • Self-hosting responsibility falls on the customer for infrastructure, backups, and uptime
  • Smaller community compared to established CRM platforms affects third-party integrations
Twenty CRM logo

Twenty CRM

Destination

Strengths

  • AGPL-3.0 open-source license with full source code on GitHub — no vendor lock-in, no sunset risk.
  • Unlimited users and unlimited custom objects on self-hosted, with no feature gating based on headcount.
  • REST and GraphQL APIs available on all paid tiers, not locked behind an enterprise add-on fee.
  • MCP server and webhooks shipped as standard features, not premium upgrades.
  • Modern PostgreSQL-backed data model that developer teams can query, extend, and self-host.

Weaknesses

  • Recent v1.0 release means limited production hardening compared to CRMs with multi-year operational track records.
  • No native email sequencing or sales engagement tools — follow-up cadences require a separate platform.
  • No native two-way email sync or inbox integration, requiring third-party connectors for full activity logging.
  • Self-hosting 'free' pricing hides real infrastructure and DevOps costs that stack up over time.
  • Workflow automation is functional but lacks the complexity needed for sophisticated multi-step sales motions.

Complexity grading

How hard is this migration?

Standard CRM migration. 3 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Crust CRM and Twenty CRM.

  • Object compatibility

    B

    3 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    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

    A

    Crust CRM exposes a bulk API — large-volume migrations stream efficiently.

Estimator

Estimate your Crust CRM to Twenty CRM migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Crust CRM to Twenty CRM data migrations

Answers to the questions buyers ask most during Crust CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.

Can't find your answer?

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 consultation

Most migrations land between three and five weeks for accounts under 15,000 People, 3,000 Companies, and 2,000 Opportunities with no complex custom module schemas. Migrations with multiple Crust custom modules (interdependent lookup relationships), large engagement histories (over 200,000 activity records), or organizations with over 20 Crust workflows requiring documented rebuild inventories move to seven to twelve weeks because of schema audit time, custom object provisioning via the metadata API, and workflow translation work.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Crust CRM.
Land in Twenty CRM, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day