CRM migration

Migrate from Composity CRM to Twenty CRM

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 logo

Composity CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

83%

10 of 12

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

Complexity

CModerate

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Composity CRM logo

Composity CRM

What's pushing teams away

  • Small review base and limited international community make it hard to find support when issues arise, pushing teams toward globally-supported platforms
  • Lite tier's 1,000-account limit forces growing teams to upgrade or switch when they exceed the ceiling
  • Production module exists but lacks the depth of dedicated manufacturing ERPs, causing shops to migrate to specialized tools
  • Limited public API documentation and third-party integration ecosystem makes automation and migration projects difficult
  • Growth-focused teams eventually outgrow the platform's feature set and move to larger CRMs with more advanced automation capabilities

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 Composity CRM objects map to Twenty CRM

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

maps to

Twenty CRM

Company

1:1
Fully supported

Composity 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

maps to

Twenty CRM

Person

1:1
Fully supported

Composity 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

maps to

Twenty CRM

Person (unqualified) or Opportunity (qualified)

lossy
Fully supported

Composity 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

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Composity 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

maps to

Twenty CRM

Opportunity Stages

lossy
Fully supported

Composity'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

maps to

Twenty CRM

Custom Object: Invoice

1:1
Fully supported

Twenty 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

maps to

Twenty CRM

Custom Object: Product

1:1
Fully supported

Composity 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

maps to

Twenty CRM

Custom Object: Project

1:1
Mapping required

Composity 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

maps to

Twenty CRM

Custom Object: Production Order

1:1
Mapping required

Composity'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

maps to

Twenty CRM

Custom Object: Inventory Item

1:1
Mapping required

Composity 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

maps to

Twenty CRM

Attachments (linked to records)

1:1
Mapping required

Composity 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

maps to

Twenty CRM

Tasks and Notes

1:1
Mapping required

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

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.

Composity CRM logo

Composity CRM gotchas

High

Account count tier limits constrain migration scope

High

No publicly documented API for automated extraction

Medium

Production module has no CRM equivalent at most destinations

Medium

Module activation state affects what data exists

Low

Documents exported as individual files with no bulk download

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

  • Composity has no publicly documented API for automated extraction

    Research found no published API documentation, authentication method, or bulk export endpoint for Composity CRM. We cannot script automated record pulls and must rely on Composity's built-in export functionality or manual CSV downloads from the web interface. This constrains migration speed, increases manual effort, and creates a risk of partial exports if the export process times out or produces truncated files. We handle this by requesting all available exports during the discovery call, building a manual extraction checklist for the customer, and chunking any large CSV files into load-ready batches for Twenty's import.

  • Production and Projects modules have no native destination equivalent

    Composity's Production module (BOM, production orders) and Projects module exist as separate modules but have no equivalent standard object in Twenty CRM's default schema. We map these to Twenty custom objects (Production Order, Project) during migration, but this requires explicit schema design: the customer must approve the field mapping, the custom object definition, and the relationship structure before any data import begins. If the customer never activated the Production or Projects module in Composity, we skip this mapping and reduce migration scope accordingly.

  • Invoices require a custom object in Twenty with no standard equivalent

    Twenty CRM does not include a native Invoice object in its standard schema. Composity invoices (line items, tax codes, payment status, totals) must be mapped to a Twenty custom object named Invoice, which the customer creates before migration. Partially paid invoices in Composity require balance carry-forward logic that adds transformation complexity. We flag invoice migration as a non-standard scope item during scoping and confirm the customer's acceptance of the custom Invoice object design before proceeding.

  • Document export is one file at a time with no bulk download

    Composity's Document Storage exports files individually with no bulk download or ZIP archive option. If the customer has hundreds of documents, each must be manually downloaded and reattached. We handle this by building a file inventory during discovery, downloading files in parallel where possible, and matching them to migrated records by filename or metadata. Large document volumes extend the migration timeline significantly and are scoped as a separate line item if the count exceeds 500 files.

  • Module activation state determines what data exists to migrate

    Composity's modules (CRM, Production, Projects, Accounting) are activated per-tenant. A customer who never enabled the Production module has no production records to migrate. We audit which modules are active during discovery to avoid building mapping logic for empty schemas and to produce an accurate migration scope. If a module is active but contains no records (never used), we exclude it from the migration at no extra cost.

Migration approach

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

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

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

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

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

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

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

Context on both ends of the pair

Composity CRM logo

Composity CRM

Source

Strengths

  • Unified all-in-one platform combining CRM, inventory, accounting, and production without requiring multiple vendor subscriptions
  • Module-based architecture allows selective deployment, reducing upfront cost for small teams
  • User-friendly interface validated by small review base showing high satisfaction scores (5.0 on SoftwareAdvice)
  • Integrated sales stack covering quotes, orders, invoices, and payments in a single workflow
  • Production module available for SMEs that need light manufacturing or job management alongside CRM

Weaknesses

  • Extremely limited public review presence (3 verified reviews) makes independent evaluation difficult
  • No publicly documented API limits, authentication methods, or bulk export endpoints found in available research
  • Lite tier's 1,000-account limit is a hard ceiling that requires immediate upgrade or migration as teams grow
  • Bulgarian-origin platform with limited English-language documentation and smaller community compared to global CRMs
  • Production and inventory modules exist but lack the depth of dedicated ERP systems, causing mid-market teams to outgrow them
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?

Moderate CRM migration. 4 of 8 objects need a mapping; the rest are 1:1.

C

Overall complexity

Moderate migration

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

  • Object compatibility

    C

    4 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

    Composity CRM: Not publicly documented..

  • Data volume sensitivity

    B

    Composity CRM doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Composity 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 Composity CRM to Twenty CRM data migrations

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

Can't find your answer?

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 consultation

Most migrations land between three and five weeks for accounts with fewer than 5,000 Contacts, no Production or Projects module data, and a straightforward custom field schema. Migrations with active Production or Projects modules, large inventory record sets, complex BOM relationships, or a document library exceeding 500 files extend to eight to twelve weeks because of the schema design work for custom objects and the manual document extraction from Composity's interface.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Composity 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