CRM migration

Migrate from The Customer Factor to Twenty CRM

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

The Customer Factor logo

The Customer Factor

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

11 of 11

objects map 1:1 between The Customer Factor and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

The Customer Factor organizes service-business data around contacts, companies, deals, estimates, invoices, and activities — with custom fields embedded in each object. Twenty CRM uses a relational model: People linked to Companies via companyId, Opportunities linked to both via companyId and personId, with Stages as separate objects referenced by stageId. The migration maps The Customer Factor contacts to Twenty People (with address and job-title fields preserved), companies directly to Twenty Companies, and deals to Opportunities with TCF deal status values mapped to Twenty Stage records that your admin creates in Settings → Data Model. TCF estimates and invoices require custom objects in Twenty — we flag these for custom-object creation before import runs. TCF attachments re-upload to Twenty Files. TCF users match to Twenty Workspace Members by email before records land. FlitStack AI sequences the migration so parent records (Companies) exist before child records (People) reference them, preventing orphaned lookups. The migration uses scoped read access on The Customer Factor — your team keeps working in TCF during cutover. A 24–48 hour delta window captures in-flight changes. Workflows, automations, invoice templates, and custom permissions do not migrate and require manual rebuild in Twenty.

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

The Customer Factor logo

The Customer Factor

What's pushing teams away

  • The single-user-per-account model becomes a hard ceiling for growing teams; multi-technician operations report being forced to a platform that supports multiple concurrent users.
  • The inability to cancel or export account data through standard self-service channels creates friction and prompts churn, with at least one customer reporting an unresponsive cancellation request via email.
  • Customization depth lags behind competitors like Housecall Pro; businesses that need custom forms, flexible workflows, or deeper field service routing features migrate away.
  • The 50-client cap on all tiers including paid plans means businesses with more than 50 active customers must upgrade or leave, with no clear upgrade path visible in the pricing structure.
  • Texting functionality depends on a third-party integration rather than being built into the platform, which frustrates users expecting an all-in-one communication hub.

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 The Customer Factor objects map to Twenty CRM

Each row shows how a The Customer Factor 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.

The Customer Factor

Contact

maps to

Twenty CRM

People

1:1
Fully supported

TCF contacts map directly to Twenty People. TCF stores name, email, phone, address, and job title fields — all map to corresponding Twenty People fields. TCF contacts without a primary company link to a default placeholder company in Twenty or are flagged for manual review.

The Customer Factor

Company

maps to

Twenty CRM

Companies

1:1
Fully supported

TCF companies map to Twenty Companies preserving business name, domain, industry, employee count, and address fields. TCF parent-child company hierarchies map to Twenty Companies with the parent company stored on the child record via the parent CompanyId field. We verify that parent companies migrate before child records so the lookup relationship resolves correctly during import.

The Customer Factor

Deal

maps to

Twenty CRM

Opportunity

1:1
Fully supported

TCF deals map to Twenty Opportunities with amount, name, and close date transferring directly. TCF deal status (Open, Won, Lost) requires a custom mapping to Twenty Stage records that your admin creates in Settings → Data Model before migration runs. Probability percentages from TCF map to Stage probability values.

The Customer Factor

Estimate

maps to

Twenty CRM

Custom Object (Estimate)

1:1
Fully supported

TCF estimates have no native equivalent in Twenty CRM. We create a custom Estimate object with fields for estimate number, line items (product, quantity, unit price), tax, discount, status, and linked People and Companies records. Multi-line items denormalize into a text or JSON field since Twenty custom objects don't support native line-item sub-objects.

The Customer Factor

Invoice

maps to

Twenty CRM

Custom Object (Invoice)

1:1
Fully supported

TCF invoices require a custom Invoice object in Twenty with fields for invoice number, amount, status (Draft, Sent, Paid, Overdue), payment date, and linked People and Companies records. TCF payment history and line items store as custom fields or a denormalized text field.

The Customer Factor

Activity (Call/Email)

maps to

Twenty CRM

Task

1:1
Fully supported

TCF call logs and email records map to Twenty Tasks with subject, type (Call, Email), body content, completion status, and original timestamp preserved. Tasks link to the parent People or Companies record by record ID. Task type is set from TCF's activity type field.

The Customer Factor

Activity (Meeting)

maps to

Twenty CRM

Event

1:1
Fully supported

TCF meeting records map to Twenty Events with subject, start time, end time, and body content preserved. Original timestamp and meeting organizer link to the parent People or Companies record. TCF meeting attendees stored as custom fields or linked via a custom Attendees object.

The Customer Factor

Note

maps to

Twenty CRM

Note

1:1
Fully supported

TCF notes map directly to Twenty Notes with body content, creator, and create timestamp preserved. Notes attach to the parent record (People, Companies, or Opportunity) via Twenty's attachment model. Rich-text formatting in TCF notes is preserved where supported. The migration maintains the chronological sequence of notes tied to each parent entity for audit continuity.

The Customer Factor

User/Owner

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

TCF users resolve to Twenty Workspace Members by email match. TCF user name and avatar data map to Twenty member profile fields. TCF role-based permissions do not migrate — these must be manually configured in Twenty Settings → Members with the same access structure recreated.

The Customer Factor

Attachment

maps to

Twenty CRM

File

1:1
Fully supported

TCF file attachments re-upload to Twenty Files. Each file attaches to its parent record (People, Companies, or Opportunity) in Twenty. Original file metadata (create date, size) is not preserved by Twenty's import mechanism and stores as a custom field for reference.

The Customer Factor

Custom Field

maps to

Twenty CRM

Custom Object or Custom Field

1:1
Fully supported

TCF embeds custom fields within contact, company, and deal objects. In Twenty, custom fields that don't fit existing objects require a custom object to be created first in Settings → Data Model before fields can be added. TCF custom field types (text, number, date, pick-list) map to corresponding Twenty field types.

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.

The Customer Factor logo

The Customer Factor gotchas

High

Client cap applies to all tiers including paid plans

High

No public API — export is manual CSV only

Medium

Automated follow-up sequences do not migrate

Medium

Cancellation requires email to support with no self-service option

Low

Texting requires third-party integration

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

  • TCF has no documented public API — exports require manual UI downloads

    The Customer Factor exposes no REST or GraphQL API for programmatic data access. Export happens through a dropdown menu under each tab in the TCF UI. For large datasets, this means manual per-object downloads, potential file-size truncation on large exports, and no way to automate delta syncs or incremental exports. FlitStack AI handles the manual export process by guiding your team through the UI export steps for each object, then ingesting the downloaded files. This adds a manual step to the migration planning phase that API-based sources don't require.

  • TCF custom fields require Twenty custom-object creation before import can run

    TCF embeds custom fields within contact, company, and deal objects. Twenty's import mechanism requires custom objects to be created first in Settings → Data Model before fields can be added and before CSV data can reference them. The migration plan must include a custom-object creation phase for each TCF custom field group. If custom objects don't exist when the CSV import runs, Twenty rejects records that reference them. FlitStack AI delivers a custom-object creation checklist as part of the migration plan so your Twenty admin creates the schema before data lands.

  • TCF deal status requires Twenty Stage creation before Opportunity migration

    TCF deals track status as a pick-list value (Open, Won, Lost) with probability percentages stored as separate fields. Twenty separates Opportunities from Stages — your admin must create Stage records in Settings → Data Model → Pipeline before any Opportunity records can reference a stageId. TCF's probability values must map to Twenty Stage probability fields during Stage creation. If Stages don't exist when the Opportunity CSV uploads, Twenty leaves stageId blank and the pipeline view won't display correctly. We surface this dependency in the pre-migration schema checklist.

  • TCF estimates and invoices have no native Twenty equivalent — custom objects required

    The Customer Factor's estimate and invoice objects contain multi-line items, tax calculations, discount fields, and payment status tracking that don't map to any standard Twenty object. Twenty has no built-in estimate or invoice entity. FlitStack AI migrates estimate and invoice data as custom objects — but this requires your Twenty admin to create the custom Estimate and custom Invoice objects in Settings → Data Model before migration, define the fields (estimate number, line items as text, tax, status, payment date), and configure pick-list values. Invoice line items denormalize into a text field since Twenty custom objects don't support nested line-item sub-objects natively.

  • TCF file attachments lose original create timestamps when re-uploaded to Twenty

    TCF stores file attachments linked to records with original upload timestamps. Twenty treats Files as first-class objects but sets createdAt at upload time — there is no mechanism to preserve the original TCF attachment create date during re-upload. FlitStack AI re-uploads TCF file attachments to Twenty Files, linking each to its parent record (People, Companies, or Opportunity) by ID. Original create timestamps are stored as a custom field on the Twenty File record for reference, but Twenty's native file list will show the re-upload date rather than the original TCF create date.

Migration approach

Six steps for a successful The Customer Factor to Twenty CRM data migration

  1. Guide TCF data export via UI dropdown

    FlitStack AI walks your team through The Customer Factor's UI export process. Because TCF has no API, each object (contacts, companies, deals, estimates, invoices, activities, attachments) requires a separate manual export from the Import/Export dropdown under each tab. We provide a step-by-step export checklist, record the export date for each object, and verify file sizes before ingestion begins. Large exports that hit TCF UI limits are flagged and split into multiple files.

  2. Audit TCF data quality and volume

    We profile each exported TCF file for record counts, duplicate rates, incomplete fields, and data format issues. This audit identifies contacts without email addresses, deals with missing stage values, and estimates with line items that may require special handling. The audit output drives the custom-object creation checklist for Twenty and determines which TCF custom fields require mapping to Twenty custom objects versus standard fields.

  3. Create Twenty custom objects and fields

    Before any CSV import runs, your Twenty admin (or our team) creates the custom objects required for TCF data that has no native Twenty equivalent — primarily the Estimate and Invoice custom objects. For each custom object, fields are added with correct types (text, number, currency, date, pick-list). Stage records are created in Settings → Data Model → Pipeline, mapping TCF deal status values to Twenty Stage names and probabilities. This step must complete before the CSV import phase.

  4. Build field mapping and resolve TCF users to Twenty members

    We document the field-level mapping from every TCF column to its Twenty equivalent. Standard fields (name, email, phone, address) map directly. TCF custom fields map to Twenty custom fields on the appropriate object. TCF users are matched by email to existing Twenty Workspace Members — your team must invite all TCF users to Twenty before this step so the email match resolves. Unmatched owners are flagged for manual assignment before migration runs.

  5. Run sample migration with field-level diff

    A representative slice — typically 100–500 records spanning contacts, companies, deals, estimates, and a few activities — migrates first. We generate a field-level diff showing the source TCF value and the destination Twenty value for every mapped field. You verify that TCF deal status values landed in the correct Twenty Stages, that TCF custom fields populated the custom objects, and that owner resolution by email matched correctly. Sample results inform any mapping adjustments before the full run commits.

  6. Execute full migration with delta-pickup window

    Full migration runs against Twenty. A 24–48 hour delta-pickup window captures any records created or modified in TCF during the cutover period. Audit logs document every operation — record counts per object, error rows, and skipped records. One-click rollback is available if reconciliation fails. After delta-pickup closes, TCF becomes read-only archive and Twenty is the system of record. Your team can continue working in TCF during cutover while FlitStack AI processes the migration, with delta records synchronized before final go-live.

Platform deep dives

Context on both ends of the pair

The Customer Factor logo

The Customer Factor

Source

Strengths

  • Free tier available for up to 50 clients with no credit card required to start.
  • All-in-one dashboard shows due contacts, pending estimates, and follow-up tasks in one view.
  • Estimate-to-job conversion with one click reduces administrative steps for field service workflows.
  • Five invoice format templates with logo, font, and custom field customization included.
  • Mobile access available across all pricing tiers.

Weaknesses

  • Hard 50-client limit applies to all tiers, including paid plans, with no published client count tiers above that level.
  • Single-user architecture prevents multi-technician access to the same account simultaneously.
  • No public API documented; data export is limited to manual CSV download from the UI.
  • Automated follow-up sequences and callback schedules do not export and must be rebuilt at the destination.
  • Account cancellation requires direct email contact with support rather than self-service control.
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. 2 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 The Customer Factor and Twenty CRM.

  • Object compatibility

    B

    2 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

    The Customer Factor: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

Estimate your The Customer Factor 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 The Customer Factor to Twenty CRM data migrations

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

Can't find your answer?

Walk through your The Customer Factor to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most The Customer Factor to Twenty CRM migrations complete in 48–72 hours of clock time for under 10,000 records. Larger datasets with extensive custom field usage, multiple TCF user accounts requiring Twenty Workspace Member matching, or estimate and invoice data requiring custom object setup extend to 5–7 days. The custom-object creation phase in Twenty Settings is the longest planning step before data can import.

Adjacent paths

Related migrations to explore

Ready when you are

Move from The Customer Factor.
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