Skip to content
Get a quote

Migrate to Twenty CRM

Twenty CRM is an open-source, modern CRM whose migration model rewards teams that pre-create custom fields, learn its metadata-driven data model, and choose between self-host and Twenty Cloud before the first CSV is uploaded.

Short answer

FlitStack AI migrates pipelines, contacts, and deals into Twenty CRM from 850+ CRMs. Every field is mapped to Twenty CRM's objects, history and associations come across, the Twenty CRM setup is configured alongside, and the whole migration stays reversible in one click.

By

From Your system
DestinationTwenty CRM
850+ sources mapped into Twenty CRM

What Twenty CRM supports, and where its import tools stop

  • 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.
REST onlyBearer token
Rate limits100 req/min (Pro), 200 req/min (Organization)
ObjectSupportNote
PeoplefullPeople is the core contact object storing individuals with fields for name, email, phone, job title, and a companyId relation. We migrate People records using email as the unique reference key and preserve company associations via the companyId foreign key. Soft-deleted People records still count toward uniqueness checks during import.
CompaniesfullCompanies stores business accounts with industry, size, location, and domain fields. Companies must be imported first because both People and Opportunities reference them via foreign keys. We use domain as the unique lookup when importing related records. Any deleted Company with the same domain will be restored on import.
OpportunitiesfullOpportunities tracks deals with stage, amount, close date, and links to both a Company and a Person (or multiple Persons). We map stage names explicitly to avoid silent mismatches when source and destination use different pipeline stage naming conventions. Opportunities must be imported after Companies and People exist.
TasksfullTasks store to-dos linked to People, Companies, Opportunities, or other records with fields for title, due date, assignee, and completion status. We preserve the record-to-task relations by importing parent records before Tasks and referencing them by their unique identifier or email.
NotesfullNotes are free-form text attachments that can be linked to any record. We migrate Notes by mapping their relational target to the corresponding record ID or email in the destination. Note body content transfers as-is; formatting fidelity depends on the source system exporting rich text or plain text.
Custom ObjectsmappedCustom Objects are user-defined entities created to hold business-specific data (e.g., Subscriptions, Events, Rockets). Unlimited on Organization tier, capped at 10 on Pro. We map Custom Object schemas field-by-field, handling field type differences between source and destination. Custom objects with relations to standard objects must be imported last.

The Twenty CRM migration guide

Why teams migrate to Twenty CRM

The four shapes a Twenty CRM migration takes, and what makes the platform easier — or harder — than the category average.

Twenty was founded by Charles Bochet and Félix Malfait, launched publicly through Y Combinator (S23), and ships under an AGPL-3.0 licence with a self-hostable codebase on GitHub112. The team positions Twenty as a modern, open-source alternative to Salesforce and HubSpot — built from a clean slate in TypeScript, NestJS, React and PostgreSQL.

The typical Twenty customer is a developer-led startup, a SaaS company, or a small-to-mid-market team — 5 to 100 users — that wants Salesforce-depth customisation without the licensing cost, or a team replacing Zoho or HubSpot to escape contact-tier billing and vendor lock-in. Compared with Salesforce, Twenty positions on no governor limits, no per-seat licence and a metadata-driven data model that lets you build custom objects the same way the platform builds standard ones.

The shapes of migration that actually land on Twenty tend to fall into four patterns. First, Salesforce or HubSpot exits, driven by total cost of ownership and a desire for data ownership — practitioners cite $9/user Cloud or $0 licensing for self-host versus $25–$165/user/month on legacy CRMs. Second, Zoho consolidations, where a small team has hit reliability or customisation limits and wants a cleaner data model28.

Third, homegrown or vibe-coded CRM replacements — teams that built something in Lovable, Airtable or Notion and have outgrown it, but still want full control over the schema29. Fourth, self-hosted CRM moves from EspoCRM, SuiteCRM or Dolibarr when a team wants a modern stack (React, Postgres) over PHP.

Each shape has a different difficulty profile: a Zoho migration usually has clean object parity but messy custom-field labels, while a Salesforce migration drags Apex, Flows and validation rules that do not move across at all.

What makes migrating to Twenty easier than the category average is its data model. Custom objects use the same treatment as standard ones — there is no Enterprise gate and no extra licence. Self-host gives you direct PostgreSQL access for power-user bulk imports, which is a path most managed CRMs simply do not offer38.

What makes it harder than the average is that Twenty is still an actively evolving project. The People and Companies standard objects ship with a narrower set of pre-built fields than HubSpot or Salesforce, which means every new workspace spends 30 to 60 minutes creating basic fields before the first import41.

The CSV import path was capped at 2,000 rows in early 2025 and was raised to 10,000 in later releases — the limit is moving, but it is still much tighter than the row caps you may be used to on HubSpot or Salesforce68.

Views, workflows and permissions do not import — they are rebuilt manually after the data lands12. Teams that scope for that rebuild work up front finish on time; teams that assume parity with Salesforce or HubSpot do not.

Twenty's open data model removes lock-in; what it does not remove is the rebuild work for views, workflows and sequences.

The Twenty CRM data model you need to map into

Standard objects, custom objects via metadata UI, junction relations, and the upsert keys you'll wire on every field — the destination schema decoded.

Twenty's CRM is built around a small set of standard objects plus an unrestricted custom-object layer driven from metadata tables36. Workspaces are the multi-tenant boundary — every object, field and record lives inside a workspace, and one Twenty deployment can host many.

Before you can map a field on the source side, you need to know exactly which destination object the row belongs on, what fields it requires, and which value will serve as its upsert key. The table below summarises the standard objects in a Twenty workspace and the additional ones you typically end up creating.

ObjectWhat it storesRequiredTier
PeopleIndividuals — contacts, leads, partnersName (first/last); email recommended as unique keyStandard, all deployments
CompaniesOrganisations associated with people and opportunitiesName; domain recommended as unique keyStandard, all deployments
OpportunitiesDeals in a sales pipelineName, stage, company or contact associationStandard, all deployments
NotesFree-form notes attached to people, companies, opportunitiesTitle or body, target record associationStandard, all deployments
TasksTo-dos and action items linked to recordsTitle, due date optional, assigneeStandard, all deployments
Workspace MembersUsers in the workspace; referenced as owners/assigneesEmail; must exist before import to bind ownershipStandard; provision before data
Custom ObjectsAnything else — Projects, Subscriptions, Volunteers, ListingsDefine in Settings → Data Model before importing recordsUnlimited; same treatment as standard
Junction ObjectsMany-to-many connectors between two objectsEnable Junction Relations in Settings → Updates → LabStandard, all deployments42

People can use email as the unique identifier — Workspace Members are also addressable by email, which is how you bind ownership during a CSV import3. Companies are most reliably matched on domain in the format https://acme.com (Twenty stores the full URL form and rejects acme.com or www.acme.com as not matching)3.

Opportunities, custom objects and any other object without a natural key should use Twenty's internal id (UUID) as the upsert key. You can either let Twenty assign IDs and store them back in the source, or generate UUIDs in the source and pass them in. Re-importing a CSV with previously defined IDs is supported but has known edge cases when columns are omitted33. Plan the unique-key strategy on day one.

Once you import, Twenty validates each row against the field schema before committing — errors highlight in yellow in the UI and you can fix them inline before the import is confirmed22. Custom field types determine validation and storage; the catalogue below covers what you can model and the limits you need to plan around.

Field typeLimitNotes
Text / Long TextPostgres text (effectively unbounded)Long Text used for multi-line; no native rich-text yet33
NumberInteger or decimalCurrency is a separate type carrying a currency code
Date / Date & TimeISO-8601Date & Time required for activity timestamps
Select (single)User-defined optionsImports must use internal option names, not display labels322
Multi-SelectUser-defined optionsMultiple values per cell; round-trip caveat on overwrite14
Email / Phone / Domain / LinksComposite types — primary + additionalUse Email for People; Domain for Companies
RelationMany-to-one or one-to-manyReference parent by id or unique field (email/domain)3
JSONPostgres JSONBStructured data store; not formula-aware
Rating / Boolean / Currency1–5 / true-false / decimal+codeBoolean must import as TRUE/FALSE uppercase3
Computed / FormulaNot yet supportedOpen feature request — rebuild as workflow or app-side logic11

Relationships in Twenty are modelled as relation fields on the object. Many-to-many is supported via a junction object pattern — you create an intermediate object (for example, Project Assignment) with two many-to-one relations, then enable the Junction Relations lab toggle to render linked records directly instead of the intermediate row42.

There is no native master-detail cascade-delete: deleting a parent does not automatically delete children. If your source platform relied on cascade semantics, reproduce them in a Twenty workflow on the parent's Deleted event, or rely on the underlying Postgres foreign-key behaviour when self-hosting with a custom schema.

Pre-migration prep — the work before you touch Twenty CRM

What must be true on the source, the destination, and across the team before the first row hits the import wizard.

The single best predictor of a clean Twenty migration is how much work you do on the source side before the first import button is pressed. Twenty's own documentation frames migration as 'an opportunity for a fresh start — don't bring over clutter'12, and the import wizard is unforgiving about fields that do not yet exist on the destination object.

Fields must exist before import. Uploading a CSV creates records but does not create fields.

Twenty Documentation

Treat the source export as raw material that needs to be shaped to Twenty's expected formats — email lowercased, phone normalised to E.164 with country codes, domains rewritten to the https://acme.com form, select values converted to internal option names, dates rewritten to ISO-8601, booleans uppercased to TRUE/FALSE3.

Source-side prep

  • Audit and dedup the source database before export. Twenty does not ship pre-built dedup tooling outside of a manual Merge Records action introduced in 1.3.0, so duplicates landing during import become a manual cleanup task.
  • Decide what to leave behind — outdated contacts with no activity in 2+ years, unused custom fields, test data, opt-outs. Twenty's docs explicitly recommend pruning before migration12.
  • Normalise emails to lowercase and trim whitespace. Email is the natural unique key for People and Workspace Members.
  • Rewrite domains to the canonical https://domain.com form. Twenty stores domains with the URL prefix and will not match domain.com or www.domain.com3.
  • Convert select-field display labels to internal option names for every dropdown — pipeline stages, status fields, custom enumerations. Enable Advanced Mode in Twenty Settings to see the internal name for each option2226.
  • Generate or preserve a stable external ID — either keep the source platform's primary key in a custom field, or pre-allocate UUIDs that will become Twenty's id on import.

Destination-side prep

  • Decide self-host vs. Twenty Cloud before you provision. Self-host runs on Docker Compose with PostgreSQL and Redis, needs at least 2 vCPU and 4 GB RAM, and gives you direct database access. Cloud (app.twenty.com) bills at $9/user/month and removes the infrastructure burden.
  • Stand up a test workspace as a sandbox. Twenty's free tier and self-host model make this trivial: spin up a parallel instance, dry-run the import, validate, then re-run against the production workspace.
  • Invite users before importing data. Twenty's docs are emphatic — if your import references owners or assignees by email, those users must exist in the workspace first, otherwise relations cannot be mapped83.
  • Pre-create every custom object and custom field under Settings → Data Model. The CSV import creates records, never fields — uploading a column for a non-existent field returns an unmapped column error38.
  • Configure select-field options with the internal option names you plan to use in your source-side transformation, not the human display labels.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours — and communicate it to every department that touches the CRM. Train sales reps on Twenty's table and Kanban views, the Command Menu (the ⋮ icon used to trigger imports), and the workflow rebuild plan.

A typical small-team Twenty migration runs one to two business days end-to-end; a 50,000-record consolidation with custom objects and historical activities runs one to two weeks of elapsed time. Build the human runway accordingly.

Import mechanisms: CSV wizard and direct database access

Two paths in, each with different limits and shapes. Picking the wrong one is how a Twenty migration stalls at scale.

Twenty exposes load paths whose right choice depends on dataset size, object mix, and whether you need to re-run idempotently. The CSV import wizard covers most one-shot migrations under 50,000 records. Direct PostgreSQL access on self-host adds a path for power users prepared to bypass the application layer entirely38.

CSV import wizard

The native import lives in the Command Menu — open the object's table view, click the ⋮ icon top right, then Import records18. Supported formats are CSV (recommended), XLSX and the legacy XLS13. Each file must contain only one object type — People in one file, Companies in another, Opportunities in a third18.

Steps: download the template to confirm column names, upload the CSV, map columns to Twenty fields, review errors highlighted in yellow and fix them inline in the UI, then confirm the import22. Pre-import validation runs before the records are written, so you can correct a malformed boolean or an unrecognised select value without polluting the workspace22.

Limits: 10,000 records per file in current releases, up from the original 2,000-row cap68. Twenty's documentation recommends splitting 10,000–50,000-record loads into multiple files38151.

Direct PostgreSQL (self-host only)

Self-hosted Twenty exposes its underlying Postgres database. For power-user bulk imports — hundreds of thousands of records, custom-object loads with complex relations, or migrations where you want SQL-level transactional control — connecting directly to the database and writing rows is the fastest path38. The trade-off: you bypass Twenty's validation layer, the Metadata schema mapping, and the application-side change events, so workflows will not fire for inserts done this way.

Mapping your data into Twenty CRM

The longest section — because field mapping is where almost every Twenty migration that fails actually breaks.

Mapping is where every migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether Kanban views work on day two, whether workflows fire correctly on day five, and whether your team trusts the data on day thirty.

Work object by object, top to bottom of the import order specified in Twenty's own documentation: Companies first (no dependencies), then People (depend on Companies), then Opportunities (depend on Companies and People), then Notes and Tasks (depend on the records they attach to), then Custom Objects83151.

Companies

Common source → Twenty Company mapping
SourceDestinationNote
account_name / company_namenameRequired
website / domaindomainNameFormat strictly as https://acme.com — not acme.com or www.acme.com3
industryindustry (or custom Select field)Map source labels to Twenty internal option names; create the field first
annual_revenueannualRecurringRevenue (Currency)Strip currency symbols; provide value plus currencyCode (USD/EUR)
employeesemployees (Number)Integer; strip commas
owner / account_owneraccountOwnerId (relation to Workspace Members)Map by user email; the user must exist in Twenty first83

People

Common source → Twenty People mapping
SourceDestinationNote
first_name / last_namename.firstName / name.lastNameComposite Name field; supply both sub-keys
emailemails.primaryEmailLowercased; recommended unique key
phonephones.primaryPhoneNumber + primaryPhoneCountryCodeNormalise to E.164 before import
job_titlejobTitleSingle-line text
company / organisationcompanyId (relation)Use companyDomain cross-reference (https://acme.com) on the People CSV83
linkedin / twitter URLslinkedinLink / xLink (Links)Composite type — primary URL plus optional label
ownercreatedBy / pointOfContact relationUse user email; pre-provision users83

Opportunities and pipelines

Recreate every pipeline-equivalent stage in Twenty before importing Opportunities. Twenty currently models pipeline as the stage Select field on the Opportunity object — Kanban view groups records by stage153. Multiple pipelines on one object (record types in Salesforce parlance) are an open community request, not native today153, so teams consolidating multiple source pipelines typically either: (a) keep them as separate Select options on a single Opportunity object, or (b) create one custom object per pipeline for full isolation.

Common source → Twenty Opportunity mapping
SourceDestinationNote
opportunity_name / deal_namenameRequired
stage / pipeline_stagestage (Select)Use internal option name, not display label; create option first22
amountamount (Currency)Provide amountMicros + currencyCode (USD, EUR)
close_datecloseDateISO-8601 date
primary_contactpointOfContactId (relation to People)Cross-reference by email or id
account / companycompanyId (relation to Companies)Cross-reference by domainName (https://acme.com) or id
ownerWorkspace Member relationMap by user email; pre-provision

Custom-field mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only the custom fields used by an active process, view or report in the last 12 months. Twenty's documentation explicitly endorses this: 'don't bring over clutter — what to leave behind: outdated contacts, duplicate records, test data, unused custom fields'12.

For Select fields whose source values do not match the destination, either: (1) extend the destination Select with the missing internal option names, (2) collapse adjacent values during transform, or (3) introduce a parallel Text field that holds the legacy value verbatim.

Formula and rollup fields do not import and are not yet supported as a Twenty field type11 — rebuild the calculation in a workflow that fires on record-write, or compute it in the source layer and store the result in a static Number field.

Historical activities — notes, tasks, emails, calls

Twenty has Notes and Tasks as first-class standard objects32. Historical free-form notes from a source CRM should be transformed into Notes records, each with a body, a createdAt timestamp, and a relation to the target record (Person, Company or Opportunity). Source activities of type Task become Twenty Tasks with dueAt, assigneeId and the same target-record relation.

Historical emails and calendar events are handled differently. Twenty's email and calendar sync (Google or Microsoft, with SMTP/CalDAV for others) is configured per-workspace-member under Settings → Accounts and runs forward-looking102. There is no bulk historical-email importer in the way HubSpot ships one; if you need to preserve old email threads as activities, the working pattern is to transform each email into a Note record attached to the matching person, with the email body as the Note body.

Rich-text formatting in source notes is currently lossy — Twenty has an open request for a rich-text field type and the existing Long Text type renders as plain text103. Convert HTML email bodies to plain text or Markdown before import.

Files and attachments

Attachments do not import via the CSV path. Twenty supports attachments on People, Companies, Notes and Tasks (the Attachments feature on Opportunity standard object is an open issue121) — files are uploaded through the UI, then linked to the parent record.

For large attachment estates the working pattern is the same as Twenty itself recommends for most file storage: keep originals in S3, Google Drive or your storage provider, write a deep link into a custom Links field on the Twenty record, and only inline-upload the most recent or most-referenced subset. Self-hosted Twenty uses local volume storage by default (STORAGE_LOCAL_PATH=/data/twenty) with S3 configurable as an alternative100.

Audit trail, ownership and original timestamps

Standard createdAt, updatedAt, createdBy and the internal id UUID are Twenty-managed system fields. The CSV path stamps createdAt to import time; if you need to preserve the original audit trail, the pattern is to create two custom Date & Time fields per object — Legacy Created At and Legacy Updated At — and populate them from the source export.

Owner assignment during import works only if the Workspace Member email exists at the moment of import; rows whose owner cannot be resolved import without an owner relation set, which silently breaks downstream owner-based workflows83.

Audit-trail granularity has historically been a community concern — earlier releases lacked a built-in action history visible to admins132. Newer releases ship a per-record activity log, but for compliance-grade audit trails on a self-host deployment, the durable answer is Postgres-level logging or a downstream warehouse stream rather than reliance on the application UI alone.

CRM-specific: lead scoring, sequences, email/calendar sync

Lead scoring as a first-class feature does not exist in Twenty — there is no scoring rule builder analogous to HubSpot Score or Salesforce Einstein Lead Scoring. The working pattern is a custom Number field (leadScore) updated by a Twenty workflow on record events.

Sequences and cadences are not native. Practitioners migrating from Outreach, Salesloft, HubSpot Sequences or Pipedrive Smart Docs need a different model — the workflow builder can chain wait-steps and task creations but lacks the cadence ergonomics of dedicated tools30. For teams that depend on sequences, plan to pair Twenty with an external cadence tool, or wait on the workflow roadmap.

Email and calendar sync for ongoing forward-looking activity is configured per Workspace Member under Settings → Accounts with Google, Microsoft, or SMTP/CalDAV102. Do not enable sync during the import window or you will get a flood of duplicate Notes as the connector backfills against the same people you are loading.

The pitfalls that derail Twenty CRM migrations

Failure modes ranked by impact, each tied to the exact Twenty mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between the import finishing and users being allowed in. Practitioners recommend a three-stage validation for Twenty: a test load of 10 percent of records with stakeholder spot-checks, the full load with real-time monitoring of record counts and relation integrity, and a 30-day post-migration audit. The most reliable signal is having department reps verify their own records — they know what right looks like better than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before users get login access.

  • Total People imported vs source — minus deliberately excluded rows (role-based emails, opt-outs, stale 2+ year contacts).
  • Total Companies imported vs source — checking that domain-based dedup did not under- or over-merge.
  • Total Opportunities per pipeline stage vs source, plus sum of amount — a non-trivial dollar variance usually signals a stage-mapping error or a Currency precision drop (Twenty stores amounts in micros).
  • Total Notes and Tasks per parent record type imported vs source — and a date-bucketed comparison to confirm the legacy createdAt round-tripped into the custom Date field.
  • Relations per object type — count People→Company, Opportunity→Company and Opportunity→Person relations and compare against the source-derived expected counts.
  • Owner distribution — group by accountOwner and confirm no record landed unowned that should not have. Cross-check that every distinct owner in the source resolved to a Workspace Member.
  • Unique-identifier integrity — count distinct emails on People and distinct domainName values on Companies; duplicates indicate the dedup transform missed cases.

On top of reconciliation, run a manual spot-check protocol: pick 30 random records across objects via the table view filter, open each one, and verify every field against the source UI. Pick five high-value Opportunities and trace the full relation graph — point of contact, company, notes, tasks, attachments. If a non-trivial discrepancy shows up in three or more of the 30, halt the load, fix the root cause, and re-import the affected rows by id.

Rollback in Twenty is not a single button. Twenty 1.3.0 added a Merge Records action that lets you collapse duplicates after the fact, but there is no bulk-undo of an entire import.

The working rollback strategy is: export everything before the import starts (via the table view's export action, or SELECT * FROM against the workspace schema on self-host), stamp every imported row with an Import Batch ID custom Text field, and if catastrophe strikes, filter by that batch ID and bulk-delete from the table view, then re-import from the cleaned source.

On self-host, the strongest rollback option is a Postgres pg_dump immediately before cutover — restoring from that snapshot is the closest thing to an atomic undo Twenty offers. Twenty Cloud customers should request a workspace snapshot from Twenty support before the import if rollback is critical.

Cutover sequencing runs in seven steps. (1) Source goes read-only and the team is notified. (2) Final delta export captures everything that changed during the test-import window. (3) Delta is imported in the same Companies → People → Opportunities → Notes/Tasks → Custom Objects order83.

(4) Reconciliation runs. (5) Views, workflows and permissions are rebuilt. (6) Users get login access and a 48-hour hyper-care window with the migration lead on call. (7) Source decommission is scheduled for 30 to 90 days out, never the same day.

Migration partners and tools

Implementation partners, iPaaS vendors, and specialist migration shops — what each is good for and how to choose.

Twenty maintains an Implementation Partners programme listed inside the documentation; partners are referenced by Twenty's own docs as the people to call for very large datasets38. Certified Twenty partners typically run fixed-scope migration packages — Salesforce-to-Twenty, HubSpot-to-Twenty, custom workflow rebuilds — alongside ongoing managed services that cover schema evolution and version upgrades after cutover.

Managed-deployment providers are a separate but adjacent ecosystem: several PaaS vendors ship one-click Twenty deployments starting around $14/month for small teams, and open-source self-host orchestrators offer documented Twenty configurations in their community discussions100. These are infrastructure providers, not migration consultancies — they get the server running but the data move is still on you.

On the ETL and iPaaS side, Fivetran, Airbyte, Workato and Stitch can all be used to stage source data into a warehouse, transform it with SQL, then write into Twenty. As of mid-2026 the prebuilt Twenty connectors on these platforms are thin — most teams write a small Node.js or Python script rather than waiting for a managed connector.

Managed-migration cost ranges vary widely. A clean HubSpot- or Pipedrive-to-Twenty move of under 25,000 contacts with no historical activities and standard objects only often lands in the $500–$3,000 range from specialist migration vendors, with 48-hour turnaround. A Salesforce-to-Twenty project with custom objects, historical activities and workflow rebuild typically runs $5,000–$25,000+, with the upper end driven by record count, custom-object complexity, historical-data depth and the number of integrations that need re-pointed.

Self-service is genuinely viable for small teams: Twenty Cloud at $9/user/month plus a weekend of CSV preparation is enough for a 5,000-record consolidation. The cost case for outsourcing rises sharply with custom-object count, historical-activity depth, and Salesforce-Apex-style logic that needs to be rebuilt as Twenty workflows.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Twenty CRM migrations and handles the field mapping, Select option-name conversion, historical-data preservation, custom-object schema setup, and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on record count and source platform, with separate line items for custom objects, historical activity depth, and self-host vs. Twenty Cloud delivery so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want a certified Twenty partner, a self-service approach, an iPaaS-backed pipeline, or a specialist migration vendor. [Explore FlitStack →](/contact)

Twenty CRM migration checklist

A phased punch list for migrating People, Companies, Opportunities, custom objects, notes, tasks, and attachments into Twenty CRM via CSV import. Typical timeline: 4–12 weeks.

0. Decide & Plan10 tasks
  • Choose deployment model: Twenty Cloud or self-hosted. Twenty Cloud is the managed SaaS at $9/user/month. Self-hosted uses Docker Compose with PostgreSQL and Redis on infrastructure you operate. The choice affects backup, upgrade cadence, and direct database access.If skipped: Switching deployment models mid-project rebuilds the workspace from scratch and discards all configuration.
  • Define migration scope by Twenty object. Confirm in writing which standard objects ship: Companies, People, Opportunities, Notes, Tasks. List any custom objects you will create. Mark each as in-scope or out-of-scope.If skipped: Unlisted custom objects surface at import and force the schema build to restart inside the cutover window.
  • Decide historical-activity scope and cutoff date. Pick a hard horizon for notes, tasks, and synced emails/calendar events (for example: last 24 months). Twenty syncs Gmail/Outlook forward from connection time; pre-connection history will not appear via the sync path.If skipped: Assuming Gmail/Outlook sync backfills years of email history leaves a silent gap that only surfaces post-cutover.
  • Confirm Twenty version and release cadence. Record the exact Twenty version (e.g., 1.3.0, 1.4.0, 2.0). Note that Merge Records, Junction Relations, and other features land in specific releases. Active development means breaking changes between versions.If skipped: Building against an older version then upgrading mid-project can break custom-object metadata and require schema rework.
  • Document gaps versus the source CRM in writing. Twenty does not ship native lead scoring, email sequences, formula/computed fields, a Rich Text field type, or attachments on Opportunities. List every source feature that has no Twenty equivalent and decide rebuild vs. drop.If skipped: Discovering a missing native feature after cutover forces an emergency rebuild outside the platform.
  • Identify GDPR data-residency requirements. If you operate self-hosted, the data sits wherever you run Postgres. Confirm region. If you use Twenty Cloud, verify the hosting region of the workspace meets contractual obligations.If skipped: Provisioning in the wrong region forces a second migration after cutover.
  • Capture AGPL-3.0 license implications with legal. Twenty's core is AGPL-3.0. If you plan to modify the codebase and expose it as a network service, AGPL obligations apply. Document any modifications planned.
  • Assign a single accountable migration owner (DRI). One named person owns scope decisions, cutover go/no-go, and post-migration sign-off. Document their backup.
  • Set cutover date, freeze window, and rollback decision point. Pick the source-system freeze date, the cutover window, and the hour by which a no-go call must be made if validation fails.If skipped: Without a pre-agreed rollback gate, teams push through partial loads and create reconciliation work that takes weeks.
  • Document explicit out-of-scope items. Write down what is NOT migrating (stale records over 2 years old, deprecated custom fields, test data, archived activities). Get sponsor sign-off.If skipped: Unwritten out-of-scope items resurface as urgent during cutover.
1. Pre-Migration Prep21 tasks
  • Export baseline record counts per source object. Capture a snapshot of contact, company, deal, activity, note, and attachment counts on a fixed date. This is the reconciliation anchor for Phase 6.If skipped: Without a baseline, post-migration delta investigation has nothing to compare against.
  • Run dedup analysis on source contacts using email as match key. Lowercase all emails and trim whitespace before matching. Resolve duplicates in the source first — do not push the problem into Twenty.If skipped: Duplicate source records collapse on import and activities attach to the wrong record.
  • Run dedup on source companies using a normalized domain key. Twenty treats `https://acme.com` as the canonical Company domain format. Normalize source domains to that exact form before matching.If skipped: Mixed `acme.com`, `www.acme.com`, and `https://acme.com` formats create three Company records on import.
  • Identify and resolve records missing required identifiers. Flag People without email, Companies without domain, Opportunities without amount or close date. Decide per record: backfill, merge, or drop.
  • Standardize phone numbers to E.164 format with country code. Twenty's Phone field stores country code separately. Pre-format to `+<country><number>` so the import parser splits correctly.If skipped: Phone numbers without country codes default to the workspace country and silently mislabel international contacts.
  • Standardize email casing and trim whitespace. Lowercase all email addresses across People, owners, and assignees. Trim leading/trailing whitespace that breaks user-email matching.
  • Delete or archive source records older than the historical cutoff. Follow the Phase 0 cutoff. Do not bring stale contacts (no activity in 2+ years), test data, or deprecated custom fields into a fresh workspace.
  • Provision a sandbox workspace separate from production. On Twenty Cloud, create a second workspace under your account. Self-hosted: stand up a parallel Docker Compose stack with its own Postgres database.If skipped: Testing imports directly in production pollutes the workspace and forces a full Postgres reset to recover.
  • Configure workspace currency, timezone, and locale. Set these in Settings before importing — currency fields convert on the basis of workspace currency. Changing afterward does not retro-convert existing values.If skipped: Importing USD deals into a workspace set to EUR mislabels every Opportunity amount.
  • Invite all workspace members before importing data. Go to Settings → Members. Users referenced as Account Owner or Assignee in the source data must exist as Twenty workspace members with matching email before import. Otherwise those relations cannot be mapped.If skipped: Owner and assignee columns silently drop on import when the user email does not exist in the workspace.
  • Create all custom objects in Settings → Data Model. Use the metadata UI: Settings → Data Model → + New object. Set singular and plural names, icon, description. No code required.If skipped: Importing into an object that does not yet exist returns an error and stalls the run.
  • Create all custom fields on standard and custom objects. Fields must exist before import — CSV import creates records, not fields. Add fields under Settings → Data Model → [Object] → + Add Field.If skipped: Columns without a matching destination field are silently skipped on import.
  • Enable Advanced mode to surface field internal names. Toggle Advanced mode at the bottom right of the Settings sidebar. CSV column headers should map to internal field names, not display labels.If skipped: Mapping by label instead of internal name produces silent column drops for fields whose label differs from the internal name.
  • Configure Select and Multi-Select options with their internal names. For every Select field, add all option values from the source. Capture the internal name (lowercase, snake-cased) — that is what CSVs must contain.If skipped: CSV values that match the display label but not the internal name fail validation row-by-row.
  • Set uniqueness constraints on identifier fields. Mark email on People, domain on Companies, and any external-ID custom fields as unique to enable upsert-by-key.
  • Enable Junction Relations in Settings → Updates → Lab. Required to model many-to-many relationships via a junction object. Combine with Advanced mode to expose junction toggles.If skipped: Without junction relations enabled, many-to-many associations cannot be modeled and flatten to one-to-many.
  • Confirm storage backend for attachments. Self-hosted defaults to local volume storage (STORAGE_TYPE=local). For larger volumes or shared deployments, configure S3-compatible storage before importing attachments.If skipped: Local storage fills the container volume on large attachment imports and crashes the worker.
  • Disable workflows during import. Pause any active workflows under Settings → Workflows before bulk loads.If skipped: Live workflows fire on every imported record, spamming Slack/email and creating spurious follow-on records.
  • Announce the source-system freeze window to all users. Send the freeze date and time at least two weeks ahead. Confirm receipt from each team lead.If skipped: Users writing to the source after the freeze create a sync delta that never gets reconciled.
  • Schedule end-user training on Twenty basics. Cover Command Menu (⋮), Kanban vs Table views, Notes and Tasks creation, and Filters. Target one session per role.
  • Designate first-responders for the first 48 hours post-cutover. Name two people who triage user-reported issues, one per timezone if relevant.
2. Source Export11 tasks
  • Export Companies as CSV with all standard and custom fields. Include name, domain, address, industry, employee count, owner email, created/updated timestamps, and every custom field. UTF-8 encoded.If skipped: Missing custom fields at export time means a second export and second transform pass.
  • Export People as CSV with all standard and custom fields. Include first name, last name, emails (primary + additional), phone, job title, LinkedIn URL, company linkage key, owner email, and all custom fields.
  • Export Opportunities as CSV with all stage and amount details. Include name, amount, currency, stage, close date, probability, primary contact key, company linkage key, owner email, and any custom fields. Stage values matter — record exact labels.If skipped: Importing amounts without currency context produces zero or mislabeled values in Twenty's Currency field.
  • Export Notes with parent-record linkage. Capture body text, created date, author email, and the unique key of the parent (Company domain, Person email, or Opportunity name).
  • Export Tasks with assignee, due date, and parent linkage. Capture title, body, status, due date, assignee email, and parent record key.
  • Export custom-object records to their own CSVs. One file per custom object. Include the relation column(s) keyed to parent object identifiers.
  • Export attachments with metadata and binaries. Pull the binary files plus a manifest CSV mapping each file to its parent record key. Note: Twenty does not yet support attachments on Opportunity (issue #3799) — plan to attach those to the related Company or Person instead.If skipped: Opportunity attachments dropped at import without warning if the destination object does not support them.
  • Export the user roster with email and role. This becomes the workspace member invitation list and the owner-mapping reference for Phase 3.
  • Export pipeline stage definitions from the source. Capture the exact label and order of each stage. These become Twenty Opportunity Stage Select options.
  • Capture screenshots and JSON exports of source automations and reports. Twenty workflows, views, dashboards, and permissions must be rebuilt manually. There is no migration path for these.If skipped: Source automation logic lost forever once the source is decommissioned.
  • Record the exact timestamp of every export. Stamp each file with the export time in ISO-8601 UTC. The delta between this timestamp and the cutover is what the Phase 5 final export must cover.
3. Transform & Map27 tasks
  • Build a master field mapping spreadsheet. Columns: source object, source field, source type, Twenty object, Twenty internal name, Twenty type, transformation rule, required-on-import, dedup key.If skipped: Without one canonical mapping, every transform script diverges and validation becomes impossible.
  • Map source Account/Organization fields to Twenty Company fields. Twenty's standard Company object covers name, domain, address, industry, employee count, annual revenue. Anything else needs a custom field.
  • Map source Contact/Person fields to Twenty People fields. Standard People object covers name, emails, phone, job title, city. Github/LinkedIn handles fit existing Links fields.
  • Map source Deal/Opportunity fields to Twenty Opportunity fields. Standard Opportunity has name, amount, stage, close date, probability. Map source pipeline stage labels to Twenty Stage Select internal names.If skipped: Mismatched stage labels (source 'Closed-Won' vs Twenty 'won') fail validation row-by-row.
  • Decide handling for source fields with no Twenty equivalent. Per field: drop, concatenate into an existing Long Text field, or add a custom field. Document each decision in the mapping sheet.
  • Decide an upsert key per object. People: email. Companies: domain. Opportunities: name + close date or a custom external-ID field. Custom objects: an external-ID custom field marked unique.If skipped: Without an upsert key, re-runs duplicate every record.
  • Re-encode all CSVs as UTF-8. Source exports in CP1252 or Latin-1 corrupt accented characters into ASCII codes on import.If skipped: Non-UTF-8 encoding silently mangles names and addresses.
  • Convert dates to ISO-8601 format. Use `YYYY-MM-DD` for Date fields and `YYYY-MM-DDTHH:MM:SSZ` for Date & Time. Resolve ambiguous DD/MM vs MM/DD before transform.If skipped: Ambiguous date formats interpret 03/04 as March 4 or April 3 depending on parser locale.
  • Normalize Company domain values to `https://domain.com`. Twenty's canonical Company domain format is `https://acme.com` — not `acme.com`, not `www.acme.com`. This format also prevents duplicates when email/calendar sync runs.If skipped: Domain format mismatch creates duplicate Companies the first time Gmail sync sees an email from that domain.
  • Format Boolean values as uppercase TRUE/FALSE. Twenty's CSV import expects `TRUE` or `FALSE` (uppercase). Lowercase or 0/1 values fail validation.
  • Convert Select field values to their internal names, not display labels. Enable Advanced mode in Settings to see internal names. Map every source picklist value to the exact Twenty option internal name.If skipped: Labels-only CSVs fail row-by-row with 'invalid option' errors.
  • Truncate text fields that exceed Twenty's column limits. Confirm per field. Twenty validates length on import — over-length values fail the row.
  • Escape commas, quotes, and newlines inside CSV values. Wrap any value containing `,` `"` or newline in double quotes and double any internal quotes. Most CSV writers do this; verify a manual sample.
  • Split source files into chunks of at most 10,000 rows for CSV import. Twenty's CSV importer caps at 10,000 records per file (raised from 2,000 via issues #11372 and #11980).If skipped: Files over 10,000 rows are rejected by the importer and force a re-split mid-cutover.
  • Decide the strategy for original created/updated timestamps. Twenty does not support overriding `createdAt` via the standard import path. Decide: re-stamp to today (accept loss) or store the original timestamp in a custom Date & Time field named `legacyCreatedAt`.If skipped: Re-stamping silently destroys the audit timeline that finance, sales ops, or compliance may need later.
  • Decide the strategy for record ownership. Best-match by owner email to invited workspace members. For records whose owner left the company, assign to a single 'data-migration' user and tag the original owner in a custom field.
  • Decide the strategy for attachments. Re-upload binaries to Twenty's storage backend, or preserve as external links in a Links custom field. Note the Opportunity attachment limitation and re-anchor those files to a Company or Person.
  • Add relation columns using the parent's unique identifier. Example: People CSV includes a `companyDomain` column with values like `https://acme.com` to link each person to a Company. Twenty resolves relations by unique field, not by internal ID.If skipped: Relations referencing non-unique fields fail to resolve and the join silently drops.
  • Pre-create user records so owner/assignee email matching works. Owner and assignee columns must contain a workspace-member email that already exists. Verify every owner email maps to an invited member.
  • Map source pipeline stage labels to Twenty Opportunity Stage internal names. Twenty ships a single Opportunity object with a Stage Select field. If your source uses multiple pipelines per deal type, either consolidate to one shared stage list or model deal-type as a custom Select field and document the stage-by-type matrix.If skipped: Multiple-pipeline source data flattened into one stage list loses the pipeline distinction permanently.
  • Decide handling for source lead-scoring fields. Twenty does not ship native lead scoring. Either store the source score as a Number custom field (snapshot only) or drop it and rebuild scoring externally.
  • Decide handling for source email-sequence and cadence state. Twenty has no native sequencing engine. Cadence status, current step, and next-send timestamp do not map. Capture as a final snapshot in custom fields or drop.If skipped: Live cadences silently lose their next-step trigger and stop firing.
  • Decide handling for source rich-text/HTML notes. Twenty does not yet expose a Rich Text field type (tracked in issues #16564 and core-team-issues #816). Convert HTML notes to plain text or Markdown stored in a Long Text field. Preserve attachments separately.If skipped: HTML stored as-is renders as escaped tags in the Twenty UI.
  • Plan junction-object many-to-many relations explicitly. For source data with true many-to-many (e.g., People ↔ Projects), create a junction custom object (e.g., 'Project Assignment') with a many-to-one to each side and toggle the junction relation in Settings.If skipped: Without a junction object, many-to-many collapses to one-to-many and association data is lost.
  • Map source Activity records to either Twenty Tasks or Notes. Per Twenty's data-migration docs, source Activity collapses into Task (action with due date/assignee) or Note (free-form record). Decide per activity-type which target to use.
  • Plan Views and Workflows as a manual rebuild post-import. Twenty's docs state Views, Workflows, and Permissions must be recreated manually after migration. Catalog every source view, workflow, and permission rule for Phase 7 rebuild.If skipped: Skipping the rebuild catalog leaves users without the saved filters and automations they depended on.
  • Decide handling for source formula/computed fields. Twenty does not ship formula fields (tracked as proposal #19092). Snapshot the computed value as a static custom field, or rebuild the calculation via Workflows once live.
4. Sandbox Test Migration12 tasks
  • Load a 1–5% representative sample of each object into the sandbox workspace. Use the Command Menu (⋮ icon top right of any table view) → Import records. Choose the CSV, map columns to fields, review errors highlighted in yellow, fix inline, then confirm.If skipped: Skipping a sample run hides issues that only surface on full-volume load.
  • Validate field-by-field on 10 random sandbox records per object. Open each record in the UI and compare every field against the source export. Look especially at Select values, dates, currency, phone country code, and relations.
  • Test long strings, special characters, and accented values. Include sample rows with em-dashes, smart quotes, non-Latin characters, and 500+ character text blobs. Confirm UTF-8 survives end-to-end.
  • Test NULL and empty-string handling per field type. Confirm whether each field interprets blank as null, empty string, or rejects the row. Document the per-field behavior.
  • Test date/time imports including timezone edge cases. Include UTC, local, and ambiguous near-midnight values. Confirm the workspace timezone setting affects display, not stored value.
  • Test parent/child relation resolution. Confirm `companyDomain` on a People CSV resolves to the correct Company. Confirm Opportunity-to-Company and Opportunity-to-primary-contact links resolve.If skipped: Relation resolution failures look like 'silent drops' — the row imports but the link is blank.
  • Test junction-object many-to-many import. Upload the junction CSV and confirm both sides appear in the linked-records view of each parent record.
  • Test re-importing the same file to confirm upsert behavior. Run the same CSV twice. Confirm the second run updates records rather than duplicating. Note: re-importing with previously defined IDs has historical issues (#13195) — use the unique field, not the id.If skipped: Non-idempotent re-runs duplicate every record and force a Postgres-level cleanup.
  • Test attachment upload via the chosen path. Upload a sample binary and confirm it attaches to the right parent record and renders correctly.
  • Time each sandbox load and extrapolate to production volume. Multiply by the production row count and confirm the result fits inside the cutover window with margin.If skipped: Cutover windows planned without a measured throughput baseline routinely overrun by 2-5x.
  • Have a domain expert spot-check 20 random sandbox records. A sales ops or RevOps reviewer who knows the source data confirms records look right end-to-end in the Twenty UI.
  • Get written sign-off on the sandbox results before proceeding. DRI plus one domain reviewer sign off in writing that the sandbox is acceptable.If skipped: Production cutover without sandbox sign-off has no rollback gate.
5. Production Cutover12 tasks
  • Confirm source-system freeze is in effect. Verify no writes in the last hour. Lock the source to read-only if possible.If skipped: Late writes create a delta that never gets reconciled.
  • Take the final delta export from the source. Re-run the Phase 2 exports as of the freeze timestamp. Diff against the Phase 2 baseline to identify changed rows.
  • Confirm workflows are disabled in Twenty. Re-verify Settings → Workflows before loading.If skipped: A workflow left on fires on every imported record.
  • Load workspace members and confirm owner-email coverage. Every owner/assignee email in the import data must already exist as an invited member.
  • Load Companies first. Companies have no upstream dependency. Per Twenty's docs, always import Companies before People before Opportunities.If skipped: Loading People before Companies leaves company links unresolved.
  • Load People with `companyDomain` relation column. Use the unique Company domain (formatted as `https://acme.com`) to wire each person to their employer.
  • Load Opportunities with company and primary-contact relation columns. Resolve via Company domain and Person email respectively.
  • Load custom-object records. After standard objects exist. Use external-ID custom fields as the relation key.
  • Load Notes and Tasks with parent linkage columns. Reference the parent by Company domain, Person email, or Opportunity unique key.
  • Load attachments last. Upload binaries and link to the parent record. Re-anchor Opportunity attachments to Company or Person per Phase 3 decision.
  • Capture import job results, row counts, and error logs at every step. Save the per-step row count and any error CSV. This is the audit trail for Phase 6 reconciliation.If skipped: Without per-step counts, mid-load failures cannot be diagnosed.
  • Re-enable workflows only after all loads complete. Re-enable in the reverse order they were disabled. Confirm no spurious fires by watching the audit log.
6. Validate17 tasks
  • Compare per-object record counts: source baseline vs Twenty. Run a count query in Twenty (or, for self-hosted, direct Postgres SELECT COUNT(*)) and compare against the source baseline. Investigate any delta.If skipped: Unexplained deltas hide silent drops that surface as user complaints weeks later.
  • Compare aggregate Opportunity pipeline value: source vs Twenty. Sum amount by stage and by owner. Match against source totals. Use the workspace currency to normalize.If skipped: Pipeline-value mismatch indicates currency, amount, or stage-mapping errors at scale.
  • Cross-check 50 randomly selected records field-by-field. 25 People, 15 Companies, 10 Opportunities. Compare every field against the source export.
  • Verify all custom field values arrived intact on a 30-record sample. Especially check Select/Multi-Select internal name resolution, Date timezone, and Currency precision.
  • Run direct Postgres COUNT queries on self-hosted deployments. Self-hosted gives direct database access. Validate that row counts in Postgres match the UI counts (they should — if they don't, the metadata cache is stale).
  • Verify People-to-Company associations on a 25-record sample. Open each person and confirm the linked Company is correct.
  • Verify Opportunity-to-Company and Opportunity-to-primary-contact links. On a 15-Opportunity sample, confirm both links match source.
  • Verify junction-object many-to-many links. Pick 5 junction records and confirm both sides appear in the linked-records panel of each parent.
  • Verify Notes and Tasks attach to the correct parent records. Sample 20 notes/tasks and confirm the parent linkage.
  • Verify attachments are accessible and linked to the right records. Click through to 10 attachments and confirm download works.
  • Verify the original-timestamp strategy from Phase 3 worked. If you stored original `createdAt` in a custom field, confirm the values populated. If you re-stamped, confirm everyone knows the audit trail starts at cutover.If skipped: Discovering original timestamps were dropped after users start working in Twenty makes recovery impossible.
  • Run a GDPR data-residency confirmation. For self-hosted, confirm the Postgres host region. For Twenty Cloud, confirm the workspace region.
  • Run a Merge Records pass on any duplicates surfaced during validation. Twenty 1.3.0+ ships a Merge Records action. Use it to resolve duplicates that slipped through dedup in Phase 1.
  • Have 5 power users run their day-to-day workflows in Twenty. Examples: filter Opportunities by stage, log a Task on a People record, send a Note, find a Company by domain. Document every friction point.
  • Confirm Gmail/Outlook sync connects without breaking imported People records. Connect a test account in Settings → Accounts. Confirm contacts auto-create rules behave as expected.If skipped: Auto-creation set to 'For messages sent & received' floods the workspace with low-value contacts.
  • Document every UAT-surfaced issue with severity and owner. Triage: blocker vs P1 vs nice-to-have. Blockers get fixed before go-live.
  • Get written sign-off from the migration sponsor before opening Twenty to all users. Sponsor signs off based on the reconciliation report, the relationship sample report, and the UAT report.If skipped: Opening access without sign-off makes rollback far harder.
7. Post-Migration Cleanup13 tasks
  • Communicate go-live to all end users with login URL and help contact. Include the Twenty workspace URL, login mechanism (Google/Microsoft SSO or password), and the first-responder contact for issues.
  • Run role-segmented training sessions on Twenty basics. Sales reps, sales ops, RevOps, and admins each get a session tailored to their daily tasks.
  • Rebuild Views, filters, and Kanban boards. Twenty's docs are explicit: Views must be recreated manually after migration. Catalog the source views and rebuild one per role.If skipped: Without saved views, users default to flat tables and adoption drops.
  • Rebuild Workflows in Settings → Workflows. Twenty's workflow engine is still maturing. Start with the most critical automations. Test each in a sandbox workspace before enabling in production.
  • Rebuild Permissions and Roles. Configure object-, record-, and field-level permissions per role. Permissions do not transfer from the source.If skipped: Default permissions may expose sensitive fields to all members.
  • Connect Gmail/Outlook sync per user. Settings → Accounts → Add account. Each user authorizes their own mailbox. Configure auto-creation and message visibility per user.
  • Reconfigure integrations to other systems. Slack, Notion, calendar sync, BI tools, etc. Each integration must be reconfigured against the Twenty workspace and tested.
  • Set the source system to read-only. Announce the read-only date. Disable all user write paths. Keep read access for the retention window.
  • Archive source-system exports to long-term storage. Keep the Phase 2 and Phase 5 export bundles encrypted in long-term storage for any future forensic need.If skipped: Source data lost from local disk before the retention window expires is unrecoverable.
  • Schedule a 30-day post-migration retrospective. Capture what went well, what didn't, and what to change for the next migration. Document the lessons in the project record.
  • Decide and document the source-system decommission date. Typically 90 days after cutover, after the final retention window. Get sign-off from finance, legal, and IT.
  • Plan and schedule a Twenty version upgrade cadence. Twenty is actively developed with frequent releases. Pin a quarterly upgrade review, test each version in a sandbox workspace, and check release notes for breaking changes.If skipped: Skipping upgrades for a year compounds breaking changes and makes the next upgrade a multi-week project.
  • Close out the migration project formally. Final status report, lessons learned, project closure with sponsor sign-off.

Questions, answered

Migrating to Twenty CRM: questions

How long does migration to Twenty CRM take?

A small-team migration with under 5,000 records and standard objects runs one to two business days end-to-end. A mid-size project with custom objects, historical Notes and Tasks, and workflow rebuild runs one to two weeks of elapsed time, including a sandbox dry run, validation, training and a 48-hour hyper-care window.

Can I migrate from Salesforce to Twenty CRM?

Yes — Salesforce is one of the most common Twenty migration sources. Standard objects map cleanly via CSV, but Apex code, Flows, Process Builder, validation rules and formula fields do not transfer. Plan for Select option-name conversion, user-email-to-Workspace-Member mapping and a workflow rebuild after the data lands.

Can I migrate from HubSpot to Twenty CRM?

Yes, and HubSpot-to-Twenty is a common shape — usually driven by contact-tier billing or data-ownership concerns. Contacts, Companies, Deals, Notes and Tasks map to People, Companies, Opportunities, Notes and Tasks. Watch Select option names, the `https://domain.com` Company format, and the manual rebuild of workflows and sequences.

Does Twenty CRM preserve original timestamps on import?

Partially. System fields like `createdAt` and `updatedAt` are stamped to import time and cannot be overridden via CSV. The working pattern is to create custom Date & Time fields — Legacy Created At and Legacy Updated At — and populate them from the source export to keep the original audit trail.

Can I migrate custom objects to Twenty CRM?

Yes — custom objects in Twenty get the same treatment and tooling as standard objects, with no Enterprise tier gate. Define the custom object and its fields in Settings → Data Model first, then load records via CSV using the same Workspace import order.

What happens to pipeline stages and deal history during migration?

Create every Select-field stage option in Twenty before importing Opportunities — rows with unrecognised stage values either fail validation or land in the wrong group. Stage transition history is not auto-preserved; if you need it for reporting, export source stage timestamps and store them in custom Date & Time fields.

Is there an undo or rollback for Twenty CRM imports?

There is no native bulk-undo. Twenty 1.3.0 added a Merge Records action for duplicates, but rollback relies on: exporting before import, stamping every row with an Import Batch ID custom field, and bulk-deleting by that batch ID if needed. Self-host adds the option of a Postgres pg_dump snapshot.

Sources

  1. Launch HN: Twenty.com (YC S23) — Open-source CRM
  2. Migrating from Other CRMs — Twenty Documentation
  3. Allow bigger imports than 2000 lines — twentyhq/twenty Issue
  4. Data Migration — Twenty Documentation
  5. Proposal: Computed Fields System — twentyhq/twenty Issue
  6. Migrating from Other CRMs — Step-by-step audit + plan (Twenty Docs)
  7. Supported File Formats — Twenty Documentation
  8. Bulk updating records — Twenty CRM (multi-select round-trip)
  9. Data Migration — CSV Import Basics (Twenty Docs)
  10. Error Handling & Validation — Twenty Documentation
  11. Create Custom Fields — Twenty Documentation
  12. Zoho CRM is eating my time alive — r/smallbusiness
  13. Twenty CRM — Sequence Follow-Ups (r/CRM)
  14. Twenty CRM — Sequencing workaround discussion
  15. Data Model — Twenty Documentation
  16. Re-importing data with previously defined id fails — twentyhq/twenty Issue
  17. Custom Objects (Metadata) — Twenty Documentation
  18. Data Migration — Recommendations + Implementation Partners
  19. Feature Request: Expand Standard Fields for People and Companies — twentyhq/twenty
  20. Twenty Documentation
  21. Migrating from Other CRMs — Create custom fields first warning
  22. Migrating from Other CRMs — Invite users + import order warnings
  23. Twenty self-hosted — concurrent-user concerns (r/selfhosted)
  24. Twenty (CRM) on Coolify — environment + storage configuration
  25. Calendar & Emails — Twenty Documentation
  26. Add rich text field type — twentyhq/twenty Issue
  27. Enable Attachments feature on Opportunity standard object — twentyhq/twenty
  28. Twenty self-hosted — audit-trail concerns (r/selfhosted)
  29. Migrating from Other CRMs — Large Migrations (50,000+) guide
  30. Support for Multiple Pipelines on One Object (Record Types) — twentyhq/twenty

Get a quote

Moving to Twenty CRM?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Twenty CRM setup with you, then send a quote.

Get a quote