CRM migration

Migrate from folk to Twenty CRM

Field-level mapping, validation, and rollback between folk and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.

folk logo

folk

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

70%

7 of 10

objects map 1:1 between folk and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

folk logo

folk

What's pushing teams away

  • Internal automation between contact and company fields requires manual field mapping — contacts and companies do not auto-link in folk, causing data duplication for teams with strong account-based motions.
  • Reporting is limited compared to Pipedrive or HubSpot — deal dashboards and pipeline analytics shipped recently but still lag behind pipeline-first CRMs on forecasting and cohort analysis.
  • Workspace-wide AI credit limits mean one heavy automator can exhaust Magic Field credits for the entire team, causing unexpected feature lockouts mid-month.
  • No public bulk API documented for programmatic export — teams with thousands of records rely on multi-step CSV extraction, which breaks for attachments and relationship graphs.
  • Some users report bugs with document attachments and slower performance when contacts exceed 5,000 records in a single group.

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

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)

maps to

Twenty CRM

Person

1:1
Fully supported

folk 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)

maps to

Twenty CRM

Company

1:1
Fully supported

folk 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

maps to

Twenty CRM

Tag or Pipeline Stage

lossy
Fully supported

folk 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)

maps to

Twenty CRM

Custom Fields (per object)

lossy
Fully supported

folk 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

maps to

Twenty CRM

Comment

1:1
Fully supported

folk 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

maps to

Twenty CRM

Task

1:1
Fully supported

folk 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

maps to

Twenty CRM

Tag

1:1
Fully supported

folk 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

maps to

Twenty CRM

Pipeline + Stage

lossy
Fully supported

folk 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)

maps to

Twenty CRM

TimelineEvent or Task

1:1
Fully supported

folk 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)

maps to

Twenty CRM

Attachment or link

1:1
Fully supported

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

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.

folk logo

folk gotchas

High

No public bulk API for automated migration

Medium

Per-group custom fields create schema fragmentation

Medium

Workspace-wide AI credit limits affect all seats

Low

Contact–company linking is not automatic

Low

Email campaign history not exported

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

  • folk CSV export drops relationship graph and attachments

    folk has no public bulk API for programmatic extraction. We export via CSV from each Group, which captures Contact fields and Group membership but does not export the relationship graph (which Contacts are linked to which companies), email campaign performance data, Magic Field-generated values, or enrichment data. Attachments appear as URLs in the CSV if they were uploaded to folk's hosting; internal file references cannot be extracted. We request full CSV exports from all Groups during discovery and warn customers about data that will not appear in Twenty post-migration.

  • Per-group field schemas require manual consolidation in Twenty

    folk's per-group custom field model means the same Contact record type can have different fields depending on which Group it belongs to. We enumerate every Group's field schema during discovery and present a consolidation plan: fields present in multiple Groups become global Twenty custom fields; fields present in only one Group require a decision to add globally, store as JSON in a catchall field, or drop. Migrations that skip this step end up with data loss or silent field drops when contacts move between Twenty views.

  • Twenty's workflow engine does not import from folk

    folk sequences and basic automations do not migrate to Twenty's workflow engine because the automation models are structurally different. We do not migrate sequences or automations as code. We deliver a written inventory of every active folk sequence and automation with its trigger, conditions, and action steps for the customer's admin to rebuild in Twenty using the workflow builder or the v2.0 SDK. This inventory is a deliverable, not a rebuild service.

  • Contact-company relationships require explicit migration

    folk Contacts of subtype company are stored as separate records from person-type contacts. Manual links between person and company contacts in folk are not automatically exported in the relationship graph. We reconstruct any manually established person-to-company links by reading relationship field values in the CSV. Links that were not explicitly recorded in a relationship field cannot be inferred and are not migrated. We flag unlinked companies in the reconciliation report for manual review.

  • Twenty's per-workspace schema requires configuration before import

    Unlike folk where fields are created per-group, Twenty requires global field creation in Settings > Data Model before any records are imported. We create all resolved custom fields in Twenty before running any record import. Field creation order matters for lookup dependencies (Company must exist before Person import if Person has a Company link). We build the full schema in a staging Twenty workspace first, validate field types and picklist options, then sync the schema to production before migration.

Migration approach

Six steps for a successful folk to Twenty CRM data migration

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

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

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

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

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

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

Context on both ends of the pair

folk logo

folk

Source

Strengths

  • One-click LinkedIn profile capture directly into a contact record with social handles and company data pre-filled.
  • Per-group custom fields allow different taxonomies per team or workflow without requiring schema-level admin access.
  • Clean, opinionated UI with a low learning curve — most teams reach proficiency within a single onboarding session.
  • Built-in email campaigns and sequences on Standard, with Gmail sender and email tracking available on both Standard and Premium.
  • Workspace-wide AI Magic Field credits included on all paid tiers, with a simpler credit model than Attio.

Weaknesses

  • No permanent free tier — only a 14-day trial with no free-forever option, which limits evaluation before commitment.
  • AI credit limits (2,000–5,000 Magic Field calls/month workspace-wide) constrain active outbound teams, especially on Standard.
  • No documented public API for bulk export — large-scale data extraction relies on CSV round-tripping, which drops attachments and relationship metadata.
  • Automation between contacts and companies is manual; account-based workflows require careful field setup to avoid duplication.
  • Reporting and analytics remain behind pipeline-first CRMs like Pipedrive on deal forecasting and cohort breakdowns.
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?

Standard CRM migration. 3 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

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

  • Object compatibility

    B

    3 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

    folk: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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 consultation

Migrations under 10,000 contacts across 3-5 Groups with straightforward field maps land in three to five weeks. Migrations with 10+ Groups with divergent field schemas, high attachment volumes, or complex relationship graphs move to six to ten weeks because of multi-pass CSV processing, per-Group field enumeration, and duplicate-resolution work. Twenty's self-hosted deployment also adds time for infrastructure setup if the customer chooses that path.

Adjacent paths

Related migrations to explore

Ready when you are

Move from folk.
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