CRM migration

Migrate from Forms On Fire to Twenty CRM

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

Forms On Fire logo

Forms On Fire

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

91%

10 of 11

objects map 1:1 between Forms On Fire and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Forms On Fire is a no-code field-data-collection platform centered on form submissions, not a traditional CRM with built-in contact and opportunity management. Its data model holds Forms (definition), Submissions (records), Data Sources (reference data), and metadata fields like GPS, photos, and timestamps. Twenty CRM is a modern open-source CRM built on PostgreSQL with standard objects for People, Companies, Opportunities, Tasks, and Notes, plus unlimited custom objects and fields accessible via REST and GraphQL APIs at 100 requests per minute. The migration carries every Forms On Fire submission into Twenty as People, Companies, or custom object records depending on form structure. We map contact fields directly to Twenty's People object, company data to the Companies object, and Forms On Fire field metadata (submission ID, entry timestamp, assigned user, location data) into custom fields. Forms On Fire workflows, process-step definitions, and form logic do not migrate — they must be rebuilt in Twenty's workflow builder. We execute the migration via CSV export from Forms On Fire and batch import into Twenty using the REST API, respecting Twenty's 20,000-record-per-export limit and sequencing related objects in dependency order.

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

Forms On Fire logo

Forms On Fire

What's pushing teams away

  • Steeper-than-expected learning curve for complex form logic, dynamic filtering, and multi-step workflows requiring conditional field visibility.
  • Managing connected data between forms and Data Sources is difficult, with limited UI for tracing and debugging data relationships.
  • Entry volume limits on Standard tier (1,500 per user per month) force organizations to upgrade or delete historical records as they scale.
  • Complex workflows and advanced features require custom configurations that typically need technical expertise, negating the no-code promise for sophisticated use cases.
  • Some organizations report the platform becomes difficult to navigate as the number of apps and forms grows across the organization.

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 Forms On Fire objects map to Twenty CRM

Each row shows how a Forms On Fire 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.

Forms On Fire

Form Submission (contact-type forms)

maps to

Twenty CRM

People

1:1
Fully supported

Forms On Fire submissions containing name, email, phone, and job title map to Twenty's People object. Each submission becomes one People record. The original submission ID is stored in Source_Form_Submission_ID__c for traceability. If a form captures multiple contacts in a single submission, each contact generates a separate People record.

Forms On Fire

Form Submission (company-type forms)

maps to

Twenty CRM

Companies

1:1
Fully supported

Submissions capturing company name, domain, industry, and address fields map to Twenty Companies. We extract the first company mentioned and create a Companies record; additional company references in the same submission are captured as a custom field for manual resolution.

Forms On Fire

Submission Metadata (submitter, timestamp, status)

maps to

Twenty CRM

People / Custom Fields

1:1
Fully supported

Forms On Fire stores submission metadata: assigned user, submission date, completion status. These map as direct fields on People — Submission_Date__c (datetime), Assigned_User_Email__c (text), and Submission_Status__c (select). Original create and update timestamps are preserved as custom datetime fields, enabling time‑based reporting and audit trails that reflect the original entry chronology.

Forms On Fire

Location Field (GPS coordinates)

maps to

Twenty CRM

People / Custom Field

1:1
Fully supported

Forms On Fire Location fields capture latitude and longitude as separate properties. We combine them into a text field (Location_Coordinates__c) formatted as 'latitude, longitude' for display in Twenty. If your team used location for route planning, the coordinate pair is preserved for reference even though Twenty has no native map view on the free/Pro tiers.

Forms On Fire

Data Source (reference tables)

maps to

Twenty CRM

Custom Object or Select Field

1:many
Fully supported

Forms On Fire Data Sources provide lookup rows for Choices and Data fields — think product catalogs, service lists, or region codes. Each Data Source with fewer than 50 rows maps to a Select or Multi-Select field on the target Twenty object. Data Sources with complex row counts or relationships become a custom object in Twenty with Name, Code, and Description fields, then linked via a relation field on the primary record.

Forms On Fire

Form Attachment / File

maps to

Twenty CRM

Twenty File Attachments

1:1
Fully supported

Photos, PDFs, and signatures attached to Forms On Fire submissions are downloaded and re-uploaded to Twenty's file storage. Each file is linked to the corresponding People, Company, or custom object record. File size limits from Forms On Fire are respected during export; large photo sets are compressed before import to stay within Twenty's storage constraints.

Forms On Fire

Form Submission (project or task-type forms)

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Forms On Fire forms used to capture field inspection results, safety audits, or job checklists have no direct Twenty CRM equivalent. We create a custom object — for example, Field_Inspection__c — with custom fields mirroring the form's data fields. The People record of the submitting user is linked via a relation field. Form-specific field types (barcode scan, photo, signature) are preserved as text or attachment fields.

Forms On Fire

Forms On Fire User / Team Member

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

Forms On Fire users who created or were assigned to submissions are resolved by email match against Twenty WorkspaceMembers. Unmatched users are flagged before migration — your admin can invite them to Twenty first or assign their records to a fallback WorkspaceMember.

Forms On Fire

Form Definitions (form layouts, field configurations)

maps to

Twenty CRM

No Equivalent

1:1
Fully supported

Forms On Fire form layout settings, conditional visibility rules, and field validation logic do not export from the platform. These must be recreated manually in Twenty's Settings → Data Model as custom field configurations and visibility rules. We deliver a field-mapping document that maps each Forms On Fire data name to its Twenty field API name so your admin can reconfigure layouts efficiently.

Forms On Fire

Forms On Fire Workflow / Process Step

maps to

Twenty CRM

No Equivalent

1:1
Fully supported

Forms On Fire Workflows and Process Steps automate routing between users, apply approval logic, and trigger notifications within the platform. These automation definitions cannot be exported and have no direct Twenty CRM equivalent. We export the workflow definitions as a JSON reference document that your Twenty admin can use to rebuild equivalent automations in Twenty's workflow builder.

Forms On Fire

Forms On Fire SSO / User Permissions

maps to

Twenty CRM

WorkspaceMember Roles

1:1
Fully supported

Forms On Fire Enterprise SSO configuration maps to Twenty's Organization tier SSO settings (SAML/OIDC available on Organization cloud tier and self-hosted). User-level permissions from Forms On Fire do not translate directly — they must be reconfigured in Twenty's workspace permissions model after migration.

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.

Forms On Fire logo

Forms On Fire gotchas

High

Standard tier entry limits silently gate historical data

Medium

dotx template linkage breaks Word document generation

Medium

Data Source auto-select behavior can silently alter form state

Low

Enterprise requires 25+ users minimum

Low

Non-Office document generation not supported

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

  • Forms On Fire form logic has no migration path to Twenty CRM

    Forms On Fire conditional visibility rules, dynamic data source filters, and field validation logic are stored as platform-specific form configuration. These are not accessible via export and have no equivalent in Twenty's data model. A form field that conditionally shows based on another field's value must be recreated manually in Twenty — the data type and options transfer via the field mapping document, but the conditional logic does not. Teams frequently underestimate this rebuild effort when planning a migration timeline.

  • Forms On Fire Data Sources require manual schema design in Twenty

    Forms On Fire Data Sources act as foreign tables for Choices and Data fields, supporting dynamic row filtering via formulas. When migrating to Twenty, these reference tables must be converted to either Select/Multi-Select field options (for small, static lists) or custom relation objects (for large or frequently changing reference data). If the Data Source uses a formula referencing another form field, there is no equivalent in Twenty's schema — the reference must be flattened into a static pick-list or handled as a post-migration data cleanup task.

  • Twenty's unique-field constraint restores soft-deleted records on re-import

    Twenty's CSV import enforces uniqueness on any field marked unique — including soft-deleted records still present in the database. If a Forms On Fire submission ID maps to a Twenty field marked unique, importing a record that shares an ID with a previously deleted Twenty record will restore that deleted record rather than create a new one. We flag all unique-constraint fields before migration and recommend disabling uniqueness checks during the initial import run, re-enabling them after validation.

  • Forms On Fire per-export record cap of 20,000 requires batch splitting

    Forms On Fire caps CSV exports at 20,000 records per operation. Teams with more than 20,000 submissions must split the export by form or by date range and run multiple export operations. Each batch must be imported separately into Twenty, and the overall migration plan must account for the sequencing so that related objects (submissions and their linked companies) land in the correct dependency order. Batch splits that cut across related records can orphan foreign-key references if the company batch runs after the people batch.

  • Forms On Fire Workflow and Process Step definitions do not export

    Forms On Fire Workflows route submissions between users, apply approval chains, and trigger downstream actions — these automation definitions exist only within the Forms On Fire platform and cannot be extracted via export or API. When migrating to Twenty, every workflow must be rebuilt from scratch in Twenty's workflow builder. The migration delivers a JSON export of your workflow definitions as a reference document listing each step, assignee rule, and condition — but the automation logic itself must be manually reconstructed, and this rebuild work falls outside the data migration scope.

Migration approach

Six steps for a successful Forms On Fire to Twenty CRM data migration

  1. Audit Forms On Fire forms and design Twenty schema

    FlitStack AI inventories every form definition, Data Source, and submission type in your Forms On Fire workspace. We classify each form as contact-capture, company-capture, checklist, or custom — then deliver a Twenty schema plan specifying which custom objects to create, which standard Twenty objects to use, and which fields to mark as required or unique. This schema plan is reviewed and approved before any data moves.

  2. Export submissions and resolve user assignments by email

    We run Forms On Fire CSV exports in batches of up to 20,000 records per export operation, splitting multi-form datasets by form type and date range. User assignments in Forms On Fire are resolved by email match against Twenty WorkspaceMembers. Any Forms On Fire user without a corresponding Twenty account is flagged for your admin to invite or assign to a fallback WorkspaceMember before migration runs — no record lands without a valid Twenty owner.

  3. Import objects in dependency order: Companies → People → Opportunities → Custom Objects

    Twenty requires the one-side of relationships to exist before linking. We import Companies first, then People with companyId relations, then any custom objects with cross-relations last. Files and attachments are batch-uploaded separately and linked back to their parent records using the Source_Form_Submission_ID__c reference. Data Source reference tables are loaded as custom Twenty objects or pick-list options before their dependent submission batches run.

  4. Run a sample migration with field-level diff before full commit

    A representative slice — typically 200–500 records spanning the main form types — migrates first. We generate a field-level diff report showing source values against destination field values so you can verify that pick-list value mapping, coordinate formatting, and user resolution are correct before the full run commits. You approve the sample before we proceed to the full migration, and any discrepancies trigger an adjustment in the field mapping configuration.

  5. Cut over with delta-pickup window and one-click rollback

    The full migration runs against Twenty CRM. A 24–48 hour delta-pickup window captures any Forms On Fire submissions created or modified during the cutover window. FlitStack AI audit log records every operation including record counts, error rows, and transformation applied. If reconciliation identifies missing or duplicate records, one-click rollback reverts the Twenty workspace to its pre-migration state so your team can investigate and re-run.

Platform deep dives

Context on both ends of the pair

Forms On Fire logo

Forms On Fire

Source

Strengths

  • Generous free trial (7 days) with no credit card required for initial evaluation.
  • Offline-first architecture ensures field data collection continues without internet connectivity.
  • AI-powered form generation from speech, text, or PDF reduces initial build time significantly.
  • Multi-platform deployment (iOS, Android, web) from a single form definition.
  • Full Open API available on all paid tiers enabling programmatic data access and integration.

Weaknesses

  • Entry limits on Standard tier (1,500/user/month) penalize organizations with high field data volume.
  • Complex data relationships between forms and Data Sources are difficult to manage and debug.
  • Billing model is per-seat regardless of usage, meaning inactive users still cost money.
  • Enterprise pricing requires 25+ users minimum, making it inaccessible for smaller teams that outgrow Standard.
  • Limited transparency on rate limits and bulk API capabilities in public documentation.
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. 1 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 Forms On Fire and Twenty CRM.

  • Object compatibility

    B

    1 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

    Forms On Fire: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

Estimate your Forms On Fire 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 Forms On Fire to Twenty CRM data migrations

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Forms On Fire to Twenty CRM migrations complete in 48–72 hours of clock time for under 50,000 submission records. Larger datasets with 500,000+ records or many form types requiring custom object creation extend to 5–7 days. The longest planning step is designing the Twenty custom object schema to match your Forms On Fire form structures — this happens before any data moves.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Forms On Fire.
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