CRM migration

Migrate from FieldFX to Twenty CRM

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

FieldFX logo

FieldFX

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

objects map 1:1 between FieldFX and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

FieldFX is a Salesforce managed package — every FieldFX record lives in a Salesforce object. The Account, Contact, Opportunity, and standard Activity objects map cleanly to Twenty's People and Companies structure. The challenge is FieldFX-specific objects like FX5__Ticket__c, FX5__Work_Order__c, FX5__Service_Appointment__c, FX5__Timecard__c, and their line-item children — Twenty has no native field-service equivalent, so these become custom objects that your team configures in Settings → Data Model before migration. FlitStack AI sequences the extraction to respect Salesforce foreign-key dependencies: Accounts first, then Contacts, then Opportunities, then custom parent objects, then child objects in strict dependency order. Workflow Rules, Status Workflows, and SFM (Salesforce Field Service) automations do not migrate — we export their definitions as a rebuild reference document for your Twenty admin. We use the Salesforce REST API with batch-size management to stay within org-wide limits, applying exponential backoff on 429 responses. The migration carries all standard fields, custom fields, timestamps, and owner assignments. Custom pick-list values on FieldFX objects require per-value translation against the target custom select fields. Integrations, page layouts, sharing rules, permission sets, and FieldFX mobile configurations require separate destination-side setup.

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

FieldFX logo

FieldFX

What's pushing teams away

  • Steep Salesforce admin and consultant requirement — organizations without dedicated Salesforce expertise struggle with custom field configuration, API limits, and package upgrades.
  • Quarterly push upgrades can introduce breaking changes to customizations, workflow rules, and field dependencies without warning.
  • API rate limits tied to Salesforce edition and per-user app limits can throttle sync-heavy operations during peak dispatch seasons.
  • Complex licensing model with per-module licenses (FX CPQ, FX EAM, FX Invoicing, etc.) adds up quickly as teams expand.
  • Mobile sync errors can cause data staleness for field crews in low-connectivity environments, with limited visibility into sync failure root causes.

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

Each row shows how a FieldFX 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.

FieldFX

Account

maps to

Twenty CRM

Company

1:1
Fully supported

Standard Salesforce Account maps directly to Twenty Company. Company.displayName takes the Account.Name value. Account billing/shipping addresses map to Twenty's standard address compound field. Parent Account relationships (ParentId) translate to a company self-relation in Twenty. Import Companies first — all other objects reference them via companyId foreign key.

FieldFX

Contact

maps to

Twenty CRM

Person

1:1
Fully supported

Standard Salesforce Contact maps directly to Twenty Person. firstName + lastName combine to Person.name. Email maps to Person.email. Phone, job title, department, and mailing address carry over as standard Person fields. Each Person record must have a companyId linking to its parent Company — Accounts must import first.

FieldFX

Opportunity

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Standard Salesforce Opportunity maps to Twenty Opportunity with close date, amount, and stage preserved. StageName pick-list values require a value-by-value map against Twenty's Opportunities.stage field. Probability values can be stored as a custom Number field if reporting continuity is required. OwnerId resolved by email match to Twenty Workspace Members.

FieldFX

Task

maps to

Twenty CRM

Task

1:1
Fully supported

Standard Salesforce Task migrates as Twenty Task with subject, status, priority, and due date preserved. Owner resolved by email match. Salesforce Task.WhatId (parent record type) translates to a relation field pointing to the migrated Company or Person — object type is flagged if WhatId references a non-migrated object.

FieldFX

Note

maps to

Twenty CRM

Note

1:1
Fully supported

Salesforce Notes (not legacy Note object) migrate to Twenty Note with title and body text. Rich-text formatting is preserved where Twenty's note rendering supports it. Parent record linking (Note.parentId) maps to the corresponding migrated Company or Person using the Source_System_ID__c reference.

FieldFX

FX5__Work_Order__c

maps to

Twenty CRM

Custom Object: Work Order

1:1
Fully supported

FieldFX Work Orders have no native Twenty equivalent. We create a Work Order custom object in Twenty via Settings → Data Model before migration. Standard Work Order fields (status, priority, scheduled date, account lookup) become custom fields on this object. Parent AccountId maps to companyId using the already-migrated Company.id. Salesforce FX5__Work_Order__c.ID stored as Source_System_ID__c for traceability.

FieldFX

FX5__Work_Order_Line_Item__c

maps to

Twenty CRM

Custom Object: Work Order Line Item

1:1
Fully supported

Work Order Line Items are child records of FX5__Work_Order__c. They become a custom object in Twenty with a relation field back to the Work Order custom object. Each line item's FX5__Work_Order__c reference is mapped to the migrated Work Order's Source_System_ID__c using a lookup table built during the migration plan phase. Product and quantity fields become custom text and number fields.

FieldFX

FX5__Ticket__c

maps to

Twenty CRM

Custom Object: Ticket

1:1
Fully supported

FieldFX Tickets track service events separate from Work Orders. They migrate as a Ticket custom object in Twenty with status, priority, and resolution fields as custom fields. The FX5__Ticket__c.AccountId and FX5__Ticket__c.ContactId references map to the migrated Company and Person via the Source_System_ID__c cross-reference table. Ticket history or audit fields become custom datetime fields.

FieldFX

FX5__Service_Appointment__c

maps to

Twenty CRM

Custom Object: Service Appointment

1:1
Fully supported

FieldFX Service Appointments carry scheduling windows and technician assignments. They become a custom object with scheduled start/end datetime fields, status, and a relation to the migrated Contact (Person). FX5__FS_Dispatch__c technician assignments map to a free-text 'Assigned Technician' custom field or a Person relation if the technician is a Twenty user.

FieldFX

FX5__Dispatcher__c

maps to

Twenty CRM

Custom Object: Dispatcher Assignment

1:1
Fully supported

Dispatcher assignment records (which dispatcher was assigned to which work order or appointment) have no equivalent in Twenty's data model. These records are preserved as a custom Dispatcher Assignment object in Twenty with a free-text dispatcher reference and source system ID for historical audit purposes. The routing logic must be rebuilt in Twenty's workflow builder.

FieldFX

FX5__Timecard__c

maps to

Twenty CRM

Custom Object: Timecard

1:1
Fully supported

FieldFX Timecards (FX5 module) track technician labor hours. They migrate as a custom Timecard object in Twenty with date, hours worked, and status as custom fields. Relation to Person (technician) and Work Order (or Ticket) established via Source_System_ID__c lookup. Hourly rate or labor cost fields become custom currency fields.

FieldFX

ContentVersion / Attachment

maps to

Twenty CRM

Note / Attachment

1:1
Fully supported

Salesforce Files (ContentVersion) and Attachments linked to Account, Contact, or Work Order records migrate as Twenty Notes with the file content stored as a base64 blob or a URL reference to a re-uploaded storage location. Salesforce file size limits (25MB default) apply during extraction. Inline images in rich-text notes are downloaded and re-hosted.

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.

FieldFX logo

FieldFX gotchas

High

API rate limits vary by Salesforce edition and request type

Medium

Deprecated Attachments feature requires Files API migration

Medium

Workflow Rules retirement leaves automations without a migration path

Medium

Travel time calculations require appointment rescheduling post-migration

Low

Custom field API name length causes browser errors on mobile

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

  • Import order is mandatory — Companies must exist before People can reference them

    Twenty's CSV import system enforces referential integrity at import time. The import sequence documented by Twenty is strict: Companies first, then People (linked via companyId), then Opportunities (linked to Companies and People), then custom objects with their own relations. FieldFX data lives in Salesforce objects with the same dependency chain — Account is the parent of Contact, which is the parent of many Work Order and Ticket records. If you import Contacts before their parent Accounts, Twenty rejects the companyId reference. FlitStack AI generates a migration sequence map before any data moves and executes the import in that order, with foreign-key resolution via the Source_System_ID__c cross-reference table built from the Salesforce IDs.

  • FieldFX field-service objects have no native Twenty equivalent — they must be created as custom objects before import

    Twenty ships with People, Companies, Opportunities, Tasks, and Notes as its standard objects. FieldFX's FX5__Work_Order__c, FX5__Ticket__c, FX5__Service_Appointment__c, FX5__Timecard__c, and FX5__Dispatcher__c records have no corresponding standard object in Twenty — they are not mentioned anywhere in Twenty's documentation. The migration plan must include a custom-object creation phase where your Twenty workspace admin creates these objects in Settings → Data Model before the migration runs. Custom fields on these objects (status, priority, scheduled date, account lookup) also need to be pre-created. FlitStack AI provides a custom-object schema specification as part of the migration plan deliverable, including field names, types, and pick-list values to set up in Twenty before data lands.

  • FieldFX Status Workflows and Salesforce Flows do not migrate — automation logic must be rebuilt

    FieldFX Status Workflows define the allowed state transitions for Ticket and Work Order records (e.g., which status a record can move to from 'New' or 'In Progress'). Salesforce Flow (the successor to deprecated Workflow Rules and Process Builder) automates record creation, field updates, and approvals. Neither of these automation constructs has a migration path to Twenty's workflow builder. Twenty's workflow builder (available on Pro and Organization plans) supports trigger-based automations but uses a different event-and-action model. FlitStack AI exports your FieldFX workflow definitions and Salesforce Flow JSON as a rebuild reference package — this does not auto-migrate but gives your Twenty admin a documented starting point. Workflow rebuild is always a manual, post-migration configuration step.

  • Salesforce API rate limits constrain extraction throughput — large FieldFX orgs need batch sequencing

    FieldFX data is extracted from Salesforce via the REST API and Bulk API. Salesforce enforces org-wide daily REST API limits (the 24-hour rolling limit varies by Salesforce edition) and per-user, per-app Batch API limits for FieldFX Mobile sync. A FieldFX org with high data volumes during migration can exhaust these limits mid-extraction, causing incomplete record pulls. FlitStack AI manages batch sizes and throttle rates during extraction, implements exponential backoff on 429 responses, and queues failed payloads for replay. For orgs with more than 200,000 total records, we coordinate extraction windows with your Salesforce admin to avoid peak business hours and API limit reset cycles.

  • Twenty CSV import has a 20,000-record per-export ceiling — large objects require multiple export passes

    Twenty's built-in CSV import caps exports at 20,000 records per export operation. FieldFX orgs with more than 20,000 Contacts, 20,000 Work Orders, or 20,000 Tickets require segmented export passes using cursor-based pagination. FlitStack AI handles this segmentation automatically during the migration run — it splits large Salesforce queries into pages, exports each page, and imports each segment into Twenty sequentially. The Source_System_ID__c field on every record ensures cross-segment de-duplication. This constraint applies to all Twenty import methods including CSV and the GraphQL API import endpoint.

Migration approach

Six steps for a successful FieldFX to Twenty CRM data migration

  1. Audit FieldFX Salesforce org and generate migration sequence map

    FlitStack AI connects to your Salesforce org via scoped read credentials and inventories every object — standard (Account, Contact, Opportunity) and FieldFX package objects (FX5__Work_Order__c, FX5__Ticket__c, FX5__Service_Appointment__c, FX5__Timecard__c, FX5__Dispatcher__c, and their children). We capture record counts, custom field definitions (including namespace prefixes), pick-list values, and foreign-key relationships. From this inventory we generate the migration sequence map: a strict ordering that respects parent-before-child dependencies (Accounts → Contacts → Opportunities → custom objects). This map is delivered as a planning document for your review before any data moves.

  2. Create Twenty custom objects and fields before migration

    Before migration data lands in Twenty, your team (or our team with admin credentials) creates the custom objects required for FieldFX field-service data: Work Order, Work Order Line Item, Ticket, Service Appointment, Dispatcher Assignment, and Timecard. For each object we deliver a schema specification listing every custom field to create in Settings → Data Model, including field type, pick-list values, and whether the field should be required. This step is a prerequisite — Twenty's import will reject records referencing an object or field that does not yet exist. We coordinate this phase so it runs in parallel with data extraction planning.

  3. Extract Salesforce data via REST/Bulk API with batch management

    FlitStack AI extracts data from your Salesforce org using the REST API for standard objects and the Bulk API for objects with more than 10,000 records. Batch sizes are managed to stay within your org's daily REST API limit and the per-user Batch API limit used by FieldFX Mobile. We export records in migration-sequence order: Accounts, then Contacts, then Opportunities, then each FieldFX package object in parent-before-child order. Salesforce Owner IDs are captured for email-based user resolution. All timestamps, custom field values, and pick-list values are included in the export. On 429 (rate limit) responses, we apply exponential backoff and retry.

  4. Resolve owners by email and build Source_System_ID cross-reference table

    Salesforce User records (OwnerId on every object) are matched against Twenty Workspace Members by email address. This creates the Owner-to-Workspace-Member mapping that allows opportunity and task ownership to transfer correctly. Unmatched owners are flagged in a pre-flight report — your team either invites them to Twenty first or assigns their records to a fallback owner. Simultaneously, we build the Source_System_ID cross-reference table that maps every Salesforce record ID to its migrated Twenty id. This table is the backbone of child-record linking: Work Order Line Items use it to find their parent Work Order; Tickets use it to find their parent Account and Contact.

  5. Run sample migration with field-level diff and verification

    A representative sample — typically 200–500 records spanning Accounts, Contacts, Opportunities, and at least one FieldFX custom object — is migrated first. We generate a field-level diff report comparing source Salesforce values against the Twenty destination values for every mapped field. This report surfaces pick-list mismatches, date-format discrepancies, truncated text fields, and foreign-key resolution failures before the full migration commits. You review the diff, approve the mapping, and FlitStack AI proceeds to the full run. For FieldFX Work Orders and Tickets, the sample diff verifies that the custom object and field setup in Twenty was done correctly.

  6. Execute full migration with delta-pickup window and post-migration audit

    The full migration runs against Twenty using the verified mapping from the sample phase. A delta-pickup window (24–48 hours after the main run completes) captures any records created or modified in Salesforce during the cutover period — typically records your team is still working on in FieldFX while the migration runs. FlitStack AI generates a post-migration audit log listing every record migrated, every record skipped (with reason), and every owner that required fallback assignment. Record counts are reconciled against the source org. One-click rollback is available within the delta window if reconciliation reveals data integrity issues. After rollback eligibility expires, your team begins the workflow-rebuild phase using the exported FieldFX workflow definitions.

Platform deep dives

Context on both ends of the pair

FieldFX logo

FieldFX

Source

Strengths

  • Built on Salesforce — inherits the full Salesforce object model, security, and API ecosystem.
  • Modular architecture lets organizations adopt E-Ticketing, Invoicing, Timecards, and Dispatch independently.
  • Offline-first FieldFX Mobile with Sync Engine reconciliation for field crews in low-connectivity areas.
  • DataGuide enables compliance-ready digital forms with version control, validation, and PDF output.
  • Customer Self-Service portal extends ticket visibility to end customers without additional back-office user licenses.

Weaknesses

  • Requires active Salesforce administration to manage licenses, custom fields, and quarterly package upgrades.
  • Deprecated Attachments feature in favor of Files API creates a migration compatibility issue for long-standing orgs.
  • API limits are tied to Salesforce edition — larger field operations can hit throttling during heavy sync windows.
  • Workflow Rules retirement forces organizations to rebuild automations in Flow or lose functionality silently.
  • Sync Engine v4 changes require testing against existing mobile device fleets before production deployment.
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 FieldFX 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

    FieldFX: Org-wide 24-hour rolling REST API limit varies by Salesforce edition; per-user per-app per-hour Batch API limit; 25 requests per minute for FX Reports API.

  • Data volume sensitivity

    A

    FieldFX exposes a bulk API — large-volume migrations stream efficiently.

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most FieldFX-to-Twenty migrations complete within 48–72 hours for under 25,000 total records. The migration-sequence planning phase (creating custom objects in Twenty and mapping foreign-key dependencies) adds 3–5 days before the run. FieldFX setups with heavy package-object usage (Work Orders, Tickets, Service Appointments) and more than 100,000 records extend to 7–14 days because each FieldFX custom object requires a separate migration pass in parent-before-child order. The delta-pickup window (24–48 hours) runs concurrently with go-live preparation.

Adjacent paths

Related migrations to explore

Ready when you are

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