CRM migration
Field-level mapping, validation, and rollback between folk and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
folk
Source
Twenty CRM
Destination
Compatibility
7 of 10
objects map 1:1 between folk and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from folk to Twenty CRM is a migration from a contact-centric CRM with per-group field fragmentation to an open-source CRM with a per-workspace schema that supports custom fields on any object. Folk has no public bulk API, so we extract via CSV from each Group, enumerate every group-specific field schema during discovery, and map Contacts 1:1 into Twenty's Person object with the subtype preserved as a custom field. Companies in folk (a contact subtype) map to Twenty's Company object, and folk Groups map to either Twenty's Workspace Tags or custom Pipeline stages depending on the customer's workflow preference. Magic Fields, enrichment credits, and email campaign history do not exist as persistent exportable data and are not migrated. Workflows and sequences similarly do not migrate; we deliver a written inventory for the customer's admin to rebuild using Twenty's workflow engine.
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 folk 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.
folk
Contact (person subtype)
Twenty CRM
Person
1:1folk Contacts of subtype person migrate to Twenty Person records. We map standard properties (name, email, phone, social handles) directly to Twenty's Person fields. The original contact subtype is preserved in a custom field original_contact_subtype__c for audit. folk contact-level custom fields migrate to Twenty Person custom fields if the same field name exists across source Groups or is explicitly mapped in the per-Group field enumeration during discovery.
folk
Contact (company subtype)
Twenty CRM
Company
1:1folk Contacts of subtype company migrate to Twenty Company records. Company name, domain, industry, size, and address properties map directly. The original contact ID is preserved as original_folk_id__c for relationship reconstruction. folk's company-type contact custom fields migrate to Twenty Company custom fields during the field enumeration phase.
folk
Group
Twenty CRM
Tag or Pipeline Stage
lossyfolk Groups are organizational containers without a direct Twenty CRM equivalent. During scoping, the customer chooses one of two strategies: (1) Tags strategy — each Group becomes a Twenty Tag applied to Person records, preserving group membership as a label. (2) Pipeline strategy — Groups with pipeline views become Twenty Pipeline stages under a single Opportunity object, with Group membership preserved as a custom picklist field on Person. The customer selects the strategy before migration begins; mixed strategies are not supported.
folk
Custom Fields (per-Group)
Twenty CRM
Custom Fields (per object)
lossyfolk custom fields are defined per-Group, not globally. During discovery we enumerate every Group's field schema, identify fields that exist across multiple Groups with the same name and type (which map to a single Twenty field), and flag fields that exist in only one Group (which require a decision: add to global Twenty schema, store as a JSON blob in a custom field, or drop). We resolve this decision with the customer before field creation in Twenty.
folk
Note
Twenty CRM
Comment
1:1folk Notes attached to Contacts migrate to Twenty Comment records linked to the corresponding Person or Company. Note text, author attribution, and creation timestamp migrate directly. Note attachments (file URLs in the CSV) migrate as attachment links if Twenty's attachment model supports URL-based linking; file re-upload is attempted where the destination configuration allows.
folk
Reminder
Twenty CRM
Task
1:1folk Reminders migrate to Twenty Task records. Reminder text becomes Task title, due date becomes the due date, and assignee resolves via email match to a Twenty User. Unassigned reminders (no owner in folk) are imported with no assignee and flagged for manual assignment post-migration.
folk
Tag
Twenty CRM
Tag
1:1folk tags migrate as string values stored in Twenty's Tag model. Multiple tags per Contact become multiple Tag records linked to the Person via the personTag junction object. We deduplicate tag names during import to avoid duplicate Tag records in Twenty.
folk
Pipeline View
Twenty CRM
Pipeline + Stage
lossyfolk pipeline views exist per-Group. We map each pipeline view to a Twenty Pipeline object, with each folk pipeline stage mapped to a Twenty Pipeline Stage. The mapping is 1:1 for stage names. Closed-won and closed-lost stage behavior requires manual configuration in Twenty after import because Twenty's pipeline stage probability settings are UI-configured, not data-level.
folk
Activity (emails, meetings, calls from timeline)
Twenty CRM
TimelineEvent or Task
1:1folk activity history (emails sent, meetings logged, calls) appears partially in the CSV export. We extract what is present and map to Twenty's TimelineEvent or Task object. Activity timeline completeness is limited by what folk exposes in CSV; we flag gaps in the migration report and note that email content from sent emails may not be fully captured.
folk
Attachment (file URL)
Twenty CRM
Attachment or link
1:1folk attachments stored as URLs in the CSV export are attempted for re-upload to Twenty where the destination supports it. File size limits, hosting restrictions, and URL validity are checked during import. Attachments without valid URLs (stored as folk internal references) cannot be migrated. We flag any attachment that fails migration in the reconciliation report.
| folk | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact (person subtype) | Person1:1 | Fully supported | |
| Contact (company subtype) | Company1:1 | Fully supported | |
| Group | Tag or Pipeline Stagelossy | Fully supported | |
| Custom Fields (per-Group) | Custom Fields (per object)lossy | Fully supported | |
| Note | Comment1:1 | Fully supported | |
| Reminder | Task1:1 | Fully supported | |
| Tag | Tag1:1 | Fully supported | |
| Pipeline View | Pipeline + Stagelossy | Fully supported | |
| Activity (emails, meetings, calls from timeline) | TimelineEvent or Task1:1 | Fully supported | |
| Attachment (file URL) | Attachment or link1: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.
folk gotchas
No public bulk API for automated migration
Per-group custom fields create schema fragmentation
Workspace-wide AI credit limits affect all seats
Contact–company linking is not automatic
Email campaign history not exported
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
Discovery and field schema enumeration
We audit every Group in the folk workspace, extract the full field schema per Group, and identify overlap (fields with the same name and type across Groups) and divergence (fields unique to one Group). We also extract sample CSV exports to verify which fields are populated, which are empty, and which relationship fields exist. This phase produces a written Field Enumeration Report and a consolidation plan that the customer approves before Twenty schema creation begins.
Twenty schema design and field creation
We create the destination schema in Twenty based on the consolidation plan. This includes creating Company and Person custom fields (mapped from folk contact subtypes), creating Tags for the tag migration, creating Pipeline and Stage records for the pipeline migration, and creating any custom fields that hold per-Group-only data as JSON or picklist values. Schema is validated in a staging Twenty workspace before production configuration. Owner (user) records are mapped by email match against the Twenty workspace User table.
CSV extraction and data cleaning
We extract full CSV exports from each folk Group covering all Contacts (person and company subtypes), Notes, Reminders, Tags, and any available attachment URLs. We clean field values for encoding issues, standardize phone number formats, resolve duplicate email addresses (first record wins, others flagged), and map relationship field values to the target Person or Company record ID in Twenty. The cleaning output is a set of import-ready CSV files per object.
Twenty REST API ingestion
We ingest cleaned records into Twenty using the REST API with rate-limit handling and exponential backoff. We ingest in dependency order: Company records first (because Person records may reference them), then Person records with resolved Company lookups, then Tags, then Tasks, then Comments. Each phase emits a row-count reconciliation report. Attachments are ingested last with URL validation; any that fail are flagged in the report.
Group membership mapping
We apply Group membership mapping according to the customer's chosen strategy (Tags or Pipeline stages). For the Tags strategy, we apply the relevant Tag to each migrated Person record. For the Pipeline strategy, we create Opportunity records linked to the relevant Person and set the Pipeline Stage based on the source Group. We validate that the total count of migrated Group memberships matches the original Group membership counts in folk.
Cutover, validation, and automation inventory handoff
We freeze writes in folk during cutover, run a final delta migration of any records modified during the migration window, then enable Twenty as the system of record. We deliver the Field Enumeration Report, the Automation and Sequence Inventory (for manual rebuild), and the Migration Reconciliation Report showing record counts per object, any unmigrated records, and any attachment failures. We support a three-day hypercare window for data quality issues. Workflow and sequence rebuild is outside scope.
Platform deep dives
folk
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 3 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 folk and Twenty CRM.
Object compatibility
3 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
folk: Not publicly documented.
Data volume sensitivity
folk doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during folk to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your folk 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 folk
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.