CRM migration
Field-level mapping, validation, and rollback between Composity CRM and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Composity CRM
Source
Twenty CRM
Destination
Compatibility
10 of 12
objects map 1:1 between Composity CRM and Twenty CRM.
Complexity
CModerate
Timeline
3-5 weeks
Overview
Moving from Composity CRM to Twenty CRM is a migration from a regional all-in-one ERP/CRM toward a modern open-source CRM with a flexible data model and strong self-hosting option. Composity's lack of a publicly documented API means we rely on its built-in CSV exports for data extraction, which constrains migration speed and requires careful manual extraction sequencing. We map Composity's Accounts and Contacts directly to Twenty's People and Companies objects, resolve the Leads and Opportunities pipeline stages against Twenty's Opportunity stage configuration, and map Composity's Production and Projects modules to Twenty custom objects since no native equivalent exists. Activity records, custom fields, and document attachments migrate with filename-based lookup resolution. Composity's module activation state is audited during discovery because teams that never enabled the Production or Projects module have no corresponding records to migrate.
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 Composity 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.
Composity CRM
Account
Twenty CRM
Company
1:1Composity Accounts map directly to Twenty Companies. Composity's Account name, address fields (street, city, country, postal code), industry, status (active/inactive), and domain URL map to Twenty's standard Company fields. Composity's custom Account fields from the Custom Data module map to Twenty custom fields on the Company object. Company is created first so that the People-Company relation is satisfied at Contact import time. Composity's Lite tier limit (1,000 accounts) is checked during discovery to flag whether the migration scope is constrained by plan ceiling before any extraction begins.
Composity CRM
Contact
Twenty CRM
Person
1:1Composity Contacts map to Twenty People. Composity's Contact name, email, phone, job title, and role map to Twenty's standard Person fields. The Account-Contact relationship resolves to a Company-People link in Twenty using domain or name matching. Composity's custom Contact fields (defined in the Custom Data module) map to Twenty custom fields on People. Activity associations on Contact records (calls, emails, meetings, notes) link to the migrated Person via the People-Activity relation in Twenty.
Composity CRM
Lead
Twenty CRM
Person (unqualified) or Opportunity (qualified)
lossyComposity Leads with status 'new' or 'contacted' and no associated opportunity map to Twenty People records without a Company link (indicating an unqualified prospect). Composity Leads that have been progressed and have an associated opportunity value map to Twenty People linked to an Opportunity, preserving the Composity lead source, qualification status, and score as custom fields on both the Person and the Opportunity. We define the split rule during scoping based on the customer's Composity lead stage matrix.
Composity CRM
Opportunity
Twenty CRM
Opportunity
1:1Composity Opportunities map to Twenty Opportunities. Deal name, value (amount), stage, expected close date, and probability map to Twenty's standard Opportunity fields. Composity's custom pipeline stage names require explicit mapping to Twenty's Opportunity stage configuration, which we design during schema scoping. Closed-won and closed-lost reasons from Composity custom fields become Twenty custom fields on the Opportunity. Owner assignments resolve via the User mapping (by email) and are preserved as Opportunity owner references.
Composity CRM
Pipeline Stages
Twenty CRM
Opportunity Stages
lossyComposity's user-defined pipeline stages (name, order, win/loss flags) are exported from the CRM settings module and recreated in Twenty's Opportunity stage configuration. Each stage's probability percentage maps to Twenty's stage probability. Composity's custom stage names that do not map to Twenty defaults are added as new stage values. The stage order is preserved so that pipeline visualization in Twenty's kanban view matches the original Composity pipeline.
Composity CRM
Invoice
Twenty CRM
Custom Object: Invoice
1:1Twenty does not include a native Invoice object in its standard CRM schema. We map Composity invoices (line items, tax codes, payment status, totals, and due dates) to a Twenty custom object named Invoice. Composity's partially paid invoices require balance carry-forward logic; we preserve the paid amount, outstanding balance, and payment history as custom fields on the Invoice record. Invoice PDFs are exported from Composity as individual files and reattached to the corresponding Invoice record in Twenty using filename matching.
Composity CRM
Product
Twenty CRM
Custom Object: Product
1:1Composity Products (name, SKU, price, description, and custom pricing rules) map to a Twenty custom object named Product. SKU maps to a text field, price to a currency field, and description to a text field. Custom pricing rules defined in Composity are preserved as JSON or multi-select fields depending on complexity. Product associations to quotes and invoices are preserved via lookup fields pointing to the Invoice custom object.
Composity CRM
Projects
Twenty CRM
Custom Object: Project
1:1Composity Projects (available in Growth and above) map to a Twenty custom object named Project. Project name, status (active/completed/on-hold), start and end dates, assigned resources (user references), and custom project fields migrate to the custom object. Composity project milestone definitions migrate as a related custom object or as JSON within a milestones field, depending on milestone count and complexity. Projects without an assigned user are flagged for admin review during cutover.
Composity CRM
Production Orders
Twenty CRM
Custom Object: Production Order
1:1Composity's Production module records (BOM references, production order status, quantities, and bill of materials) have no native equivalent in Twenty's standard schema. We map them to a Twenty custom object named Production Order, preserving BOM line items as a related sub-object or as structured JSON in a custom field. Composity's production order statuses (planned, in-progress, completed) map to a select field on the custom object. This mapping requires explicit schema design during scoping because BOM relationships must be resolved before production order records are imported.
Composity CRM
Inventory Items
Twenty CRM
Custom Object: Inventory Item
1:1Composity Inventory records (SKU, quantity, warehouse location, reorder level, and quantity discrepancies) map to a Twenty custom object named Inventory Item. We flag any inventory records with negative stock or quantity discrepancies during extraction so that the customer can review before migration. Warehouse location maps to a text or select field depending on the number of unique locations. Inventory quantity adjustments and history do not migrate as separate activity records but are preserved as a snapshot at migration time.
Composity CRM
Documents
Twenty CRM
Attachments (linked to records)
1:1Composity Document Storage exports files one at a time with no bulk download option. We build a file inventory during discovery by requesting exports through Composity's interface, download each file, and reattach it to the corresponding migrated record in Twenty using filename or metadata matching. Files without a resolvable parent record are flagged in a separate queue for manual assignment. File upload dates and metadata (size, type) are preserved as custom fields on the Twenty attachment or the parent record.
Composity CRM
Activities
Twenty CRM
Tasks and Notes
1:1Composity Activity tracking (calls, emails, meetings, notes) against Contacts and Accounts maps to Twenty Tasks and Notes. Composity's activity type field determines the Task subtype (call, email, meeting). Activity date, description, and duration migrate to Twenty's Task fields. The linked Contact or Account resolves to a Twenty Person or Company via the migration's lookup table. Activities without a resolvable parent record are held in a reconciliation queue for admin review.
| Composity CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Account | Company1:1 | Fully supported | |
| Contact | Person1:1 | Fully supported | |
| Lead | Person (unqualified) or Opportunity (qualified)lossy | Fully supported | |
| Opportunity | Opportunity1:1 | Fully supported | |
| Pipeline Stages | Opportunity Stageslossy | Fully supported | |
| Invoice | Custom Object: Invoice1:1 | Fully supported | |
| Product | Custom Object: Product1:1 | Fully supported | |
| Projects | Custom Object: Project1:1 | Mapping required | |
| Production Orders | Custom Object: Production Order1:1 | Mapping required | |
| Inventory Items | Custom Object: Inventory Item1:1 | Mapping required | |
| Documents | Attachments (linked to records)1:1 | Mapping required | |
| Activities | Tasks and Notes1:1 | Mapping required |
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.
Composity CRM gotchas
Account count tier limits constrain migration scope
No publicly documented API for automated extraction
Production module has no CRM equivalent at most destinations
Module activation state affects what data exists
Documents exported as individual files with no bulk download
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 extraction audit
We audit the source Composity tenant across modules (which are active), account and contact counts (cross-referenced against the Composity tier limit), pipeline stage definitions, custom field schemas per object, document inventory, and any active Production or Projects module data. We also request access to Composity's built-in export functionality and identify which modules support CSV export versus manual one-by-one download. The discovery output is a written migration scope, a Composity extraction checklist for the customer, and a Twenty schema design brief for any required custom objects.
Twenty workspace preparation and custom object schema design
We configure the destination Twenty workspace. This includes designing any required custom objects (Invoice, Product, Project, Production Order, Inventory Item) with the field types that match Composity's schema, configuring Opportunity pipeline stages to match Composity's stage names and probabilities, and setting up Company-People relations. If the customer uses Twenty's self-hosted option, we coordinate with their infrastructure team on the instance URL and API access. Schema is validated in a staging environment before any production migration begins.
Composity data extraction and transformation
We guide the customer through Composity's built-in export process, extracting CSV files for Accounts, Contacts, Leads, Opportunities, Products, Invoices, and any active Projects or Production module records. Custom field data is included by extending the export scope to all available columns. We transform the CSV data into Twenty-compatible import format, apply the field type mappings, resolve the Lead-to-Person split rules, and build the lookup tables (Account name to Company ID, Contact email to Person ID) that will maintain referential integrity during import.
Document file extraction and attachment preparation
We build the document inventory by listing all files in Composity's Document Storage, downloading each file, and mapping it to the corresponding migrated record by filename or associated Contact/Account metadata. Files without a resolvable parent record are held in a separate queue. Upload dates and file sizes are recorded as custom fields for audit. We batch files into Twenty's attachment upload process in groups of 50 to avoid timeout errors on hosted instances.
Migration in dependency order with reconciliation
We run production migration in strict record-dependency order: custom object schemas first (so the objects exist before data arrives), then Companies (from Accounts), then People (from Contacts and Leads with split applied), then Opportunities (with Company and Owner lookups resolved), then custom objects (Invoice, Product, Project, Production Order, Inventory Item), then Tasks and Notes (Activities), and finally attachments. Each phase emits a row-count reconciliation report showing records imported versus records expected. Discrepancies are investigated before the next phase begins.
Cutover, delta migration, and admin handoff
We freeze Composity writes during cutover, run a final delta migration of any records created or modified during the migration window, then enable Twenty as the system of record. We deliver the custom object schema documentation, the mapping inventory, and the document file manifest to the customer's admin. We support a one-week hypercare window for reconciliation issues raised by the team. We do not rebuild Composity's Production module workflows, Projects automations, or accounting configurations inside the migration scope; these are documented for the admin to redesign in Twenty's system.
Platform deep dives
Composity CRM
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Moderate CRM migration. 4 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Moderate migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Composity CRM and Twenty CRM.
Object compatibility
4 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
Composity CRM: Not publicly documented..
Data volume sensitivity
Composity CRM doesn't expose a bulk API — REST + parallelization used for high-volume runs.
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 Composity CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Composity 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 Composity 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.