CRM migration
Field-level mapping, validation, and rollback between Atomic CRM and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Atomic CRM
Source
Twenty CRM
Destination
Compatibility
8 of 10
objects map 1:1 between Atomic CRM and Twenty CRM.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Atomic CRM and Twenty CRM are both MIT/AGPL-licensed open-source CRMs, but they differ fundamentally in how they expose configuration. Atomic CRM stores custom fields as Postgres columns via Supabase Studio and defines deal pipeline stages and task type enumerations as TypeScript props in the CRM root component — not in the database. Twenty CRM uses a Settings-based data model where pipeline stages and picklist values are created in the UI before data import. We audit the Supabase schema to discover every custom column, request the App.tsx configuration file to capture deal category and task type enums, then replicate those values in Twenty before importing records. We migrate Companies first to satisfy foreign-key lookups, then People, then Opportunities with stage values mapped to Twenty picklists, then Tasks and Notes with their parent record references preserved. Workflows and automations do not migrate; we deliver a written inventory of any Supabase-edge-function-based automation that requires rebuilding in Twenty.
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 Atomic 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.
Atomic CRM
Company
Twenty CRM
Company
1:1Atomic CRM Company records map to Twenty CRM Company. The company sector (defined in Atomic CRM's Settings page or Supabase column) maps to Twenty's industry or a custom single-select picklist we create during schema setup. We extract all custom columns on the companies table during the Supabase schema audit and replicate them as custom fields in Twenty before import. Website, size, and phone fields map directly.
Atomic CRM
Contact
Twenty CRM
People
1:1Atomic CRM Contact records map to Twenty CRM People. We preserve the link to the parent Company by resolving the Supabase foreign key to the Twenty Company UUID at migration time. Email, name, phone, and any custom columns migrate directly. The contact-to-company relationship requires Companies to be imported first, which we enforce in the migration sequence.
Atomic CRM
Deal
Twenty CRM
Opportunity
1:1Atomic CRM Deal records map to Twenty CRM Opportunity. The deal stage (e.g. eCommerce, SaaS, Consulting categories) is sourced from the App.tsx props enumeration, not from the database, so we request the customer share their App.tsx during scoping to capture the exact stage labels. We create matching stage picklist values in Twenty's Opportunity settings before importing. Deal value, close date, and company association migrate directly.
Atomic CRM
Note
Twenty CRM
Note
1:1Atomic CRM Notes linked to Contacts or Deals migrate to Twenty Notes with the parent record reference preserved. We resolve the polymorphic or foreign-key relationship from the Supabase schema audit to point the Note to the correct Twenty People or Opportunity UUID after import. Note body migrates as plain text.
Atomic CRM
Task
Twenty CRM
Task
1:1Atomic CRM Task records migrate to Twenty Tasks. Task type classification (Call, Email, Meeting) comes from the App.tsx props enumeration, not from a database column, so we enumerate the type values from the shared App.tsx during scoping and replicate them as Twenty Task type options before migration. Task status, assignee, and due date migrate directly. Assignee resolution uses email match against Twenty workspace members.
Atomic CRM
Custom Fields (Supabase columns)
Twenty CRM
Custom Fields
lossyCustom fields in Atomic CRM are Postgres columns added via Supabase Studio — they are not UI-configured properties. We run a pre-migration schema diff against a reference export to discover every column on the contacts, companies, deals, notes, and tasks tables. Each discovered column is replicated as a custom field in Twenty's Settings → Data Model before data import begins. Column type mapping: Supabase varchar/text maps to Twenty text, integer/numeric maps to number, boolean maps to boolean, date maps to date.
Atomic CRM
App.tsx prop enumeration
Twenty CRM
Opportunity Stage + Task Type picklists
lossyAtomic CRM defines deal categories and task types as TypeScript props passed to the CRM root component in App.tsx, not stored in the database. We cannot read these from the Postgres schema. We ask the customer to share their App.tsx (or equivalent configuration file) during scoping so we capture the exact enum values for pipeline stages and task types. These values are then created as picklist options in Twenty's Opportunity settings and Task type settings before any record import begins.
Atomic CRM
Supabase Auth users
Twenty CRM
Twenty workspace Members
1:1Atomic CRM user management relies on Supabase Auth — owner and assignee references on Deals and Tasks use auth UUIDs. We do not migrate Supabase Auth user records directly. Instead, we extract every distinct owner or assignee email from Deals, Tasks, and Notes, then match against the Twenty workspace Members list by email. The customer provisions Twenty workspace members before migration. Any owner without a matching Twenty member goes to a reconciliation queue for admin provisioning before record import.
Atomic CRM
Supabase Storage attachments
Twenty CRM
File attachments (Twenty)
1:1Atomic CRM stores file attachments in Supabase Storage buckets when that option is configured. If attachments are present, we export the Supabase Storage bucket contents alongside the database records and attach them to the corresponding Twenty People or Opportunity records. Files stored outside Supabase (e.g. a custom S3 bucket) require separate coordination with the customer. Attachment metadata in Supabase does not migrate — only the binary files and their reference to the parent record.
Atomic CRM
Tags
Twenty CRM
Tags
1:1Atomic CRM supports tags on contacts, companies, and deals as of the March 2026 update. Tags migrate to Twenty's tag model. We preserve the tag names and the record associations (contact-tag, company-tag, deal-tag) and recreate them in Twenty during the data import phase. Tags used for categorization also inform whether a custom single-select or multi-select field should be created instead of a flat tag list.
| Atomic CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Company | Company1:1 | Fully supported | |
| Contact | People1:1 | Fully supported | |
| Deal | Opportunity1:1 | Fully supported | |
| Note | Note1:1 | Fully supported | |
| Task | Task1:1 | Fully supported | |
| Custom Fields (Supabase columns) | Custom Fieldslossy | Fully supported | |
| App.tsx prop enumeration | Opportunity Stage + Task Type picklistslossy | Fully supported | |
| Supabase Auth users | Twenty workspace Members1:1 | Fully supported | |
| Supabase Storage attachments | File attachments (Twenty)1:1 | Fully supported | |
| Tags | Tags1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Atomic CRM gotchas
No hosted SaaS version — migration target is a Postgres database
Custom fields are schema changes, not UI-configured properties
CRM component props define business logic that lives in code, not data
No native file attachment export — storage backend varies by deployment
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
Supabase schema audit and App.tsx collection
We request read access to the customer's Supabase project (service role key or scoped anon key with elevated permissions) and run a schema diff across the contacts, companies, deals, notes, and tasks tables. We document every column, its Postgres type, and its nullable/default status. We also request the customer's App.tsx (or equivalent) configuration file to enumerate the TypeScript props for deal categories and task types. We cross-reference the Supabase auth.users table to extract all distinct owner and assignee emails for the Twenty user reconciliation step.
Twenty workspace setup and custom field creation
We provision the Twenty workspace or verify the existing self-hosted instance is accessible via the Twenty API. We create all custom fields discovered in the Supabase schema audit as Twenty custom fields in Settings → Data Model before any data import. We create all deal stage picklist values (sourced from App.tsx or inferred from dealstage column) in Twenty Opportunity settings. We create all task type options in Twenty Task settings. This phase must complete before CSV import begins because Twenty's import does not create fields.
Twenty workspace member provisioning
We extract every distinct owner and assignee email from Deals, Tasks, and Notes in the Supabase data and produce a member provisioning list. The customer's admin invites all required users to the Twenty workspace and confirms acceptance before we proceed to record import. Any owner without a matching Twenty member is placed in a reconciliation queue. Migration cannot safely proceed past this step because OwnerId references on Opportunities and Tasks require a valid Twenty User record.
Supabase Storage file export (if applicable)
If the Supabase project uses Supabase Storage for file attachments, we export the storage bucket contents and map each file to its parent record (People or Opportunity) by filename or record ID pattern. Files stored outside Supabase (e.g. custom S3 buckets) are flagged for separate customer-side coordination. We do not migrate binary blob storage unless explicit file-hosting credentials are provided.
Migration in dependency order
We run the migration in strict record-dependency order: Companies (no dependencies), then People (with Company UUID resolved from the Company mapping), then Opportunities (with stage values mapped to Twenty picklists and Company UUID resolved), then Tasks (with assignee resolved to Twenty User by email), then Notes (with parent record reference resolved to People or Opportunity UUID). Each phase emits a row-count reconciliation report. Supabase Storage attachments are imported last, after their parent records exist in Twenty.
Cutover, delta sync, and automation inventory handoff
We freeze writes to the Atomic CRM Supabase instance during cutover, run a final delta migration of any records created or modified during the migration window, then mark Twenty as the system of record. We deliver a written inventory of any Supabase edge-function-based automations that existed in the source, with a description of each trigger and action and a recommendation for rebuilding equivalent logic in Twenty's workflow builder. We do not rebuild automations as code inside the migration scope. Post-migration validation includes matching record counts, spot-checking 25-50 records against the source, and a one-week reconciliation window for the customer's team to report issues.
Platform deep dives
Atomic CRM
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 2 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Atomic CRM and Twenty CRM.
Object compatibility
2 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
Atomic CRM: Per Supabase rate limits applicable to your project tier.
Data volume sensitivity
Atomic CRM exposes a bulk API — large-volume migrations stream efficiently.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Atomic CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Atomic 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 Atomic 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.