CRM migration
Field-level mapping, validation, and rollback between Formaloo and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Formaloo
Source
Twenty CRM
Destination
Compatibility
5 of 11
objects map 1:1 between Formaloo and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Formaloo to Twenty CRM is a shape-shifting migration. Formaloo organizes data as Forms with Responses — a form-builder-first model that teams adopted as an informal CRM when form submissions replaced spreadsheets. Twenty CRM is a purpose-built CRM with Person, Company, and Opportunity as first-class objects, custom objects via the /metadata API, and a full GraphQL interface for data retrieval. The migration requires extracting Formaloo Form Responses as structured records, mapping each form's field schema to a typed Twenty CRM object (Person fields map to Person, Company fields to Company, and relational fields between forms become Twenty lookup relationships), and resolving the workspace and folder hierarchy into Twenty workspace tags. Logic rules and calculation fields do not migrate as automation — we document them as text notes. The migration scope does not include Workflows, Sequences, or Automations since neither Formaloo nor Twenty exposes these as transferable code.
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 Formaloo 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.
Formaloo
Form Response
Twenty CRM
Person
1:1Formaloo form responses that contain individual contact fields (name, email, phone, address, job title) map to Twenty CRM Person records. We extract the submitter metadata (email, name) and field-type-specific values from each response, then map them to Person fields using Twenty's standard field schema. The email field on Person becomes the dedupe key. Any submitter metadata with a company affiliation maps to a Company lookup on the Person record. Responses from forms that do not contain individual contact fields (e.g., survey aggregates or product feedback forms) are evaluated for custom object placement during scoping.
Formaloo
Form Response
Twenty CRM
Company
1:1Formaloo form responses that contain organizational data (company name, domain, industry, employee count, address) map to Twenty CRM Company records. If a Formaloo form captures both individual contact fields and company fields in the same response, we split the response into a Person record and a Company record and create the Person-Company link via the workInformation relationship on the Person object.
Formaloo
Form Response (lead intake form)
Twenty CRM
Opportunity
1:1If a Formaloo form was used as a lead capture or deal registration form with deal-value fields, stage fields, or expected-close-date fields, those responses map to Twenty CRM Opportunity records. Pipeline stage values from Formaloo choice fields map to Opportunity.stageName, and deal value fields map to Opportunity.amount. The Opportunity.Company map-link connects each Opportunity to a resolved Company record.
Formaloo
Database (relational cross-form links)
Twenty CRM
Custom Object or lookup relationship
1:manyFormaloo's relational database layer links multiple Forms via reference fields. We export the Database structure as a set of related tables, identify which cross-form references represent parent-child relationships (1:N) and which represent N:N associations, then create Twenty CRM custom objects or lookup relationships accordingly. Reference field IDs from Formaloo are preserved as externalId values on the target records so that the lookup can be resolved during import rather than requiring a two-pass load.
Formaloo
Form Field (calculation, formula)
Twenty CRM
Custom field (formula) or text note
lossyFormaloo calculation fields and formula fields do not export as structured automation. We document each calculation field's formula logic as a text note and, where Twenty CRM supports formula fields on standard or custom objects, we recommend recreating it as a Twenty formula field with equivalent logic. The original Formaloo calculation value migrates as a static numeric or text field on the target record for historical accuracy.
Formaloo
Form Field (signature)
Twenty CRM
Attachment or custom field
1:1Formaloo signature fields store e-signature image data or signature log records. We export the signature as a file attachment linked to the target Person or Company record in Twenty CRM via ContentDocument and ContentDocumentLink. The source Formaloo plan must include signature fields — we confirm this during scoping to avoid attempting to migrate a feature unavailable on the customer's current plan.
Formaloo
Form Field (file upload)
Twenty CRM
ContentDocument via API
1:1Formaloo file upload fields store uploaded documents as attachments on form responses. We export the file metadata (filename, size, content type, download URL if available via API) and the file content itself, then attach each file to the target Person, Company, or Opportunity record in Twenty CRM via the ContentDocumentLink table. Large file handling uses chunked upload to respect API size limits.
Formaloo
Form Field (rating, choice, multi-select)
Twenty CRM
Custom field (select, multi-select)
lossyFormaloo choice fields, rating fields, and multi-select fields map to Twenty CRM custom fields with the corresponding field type (select for single-choice, multi-select for multi-choice, number for rating). We extract the Formaloo choice option labels and create matching picklist values in Twenty's custom field schema before import begins. Rating scales from Formaloo (1-5, 1-10) are mapped to numeric custom fields in Twenty.
Formaloo
Form (definition and structure)
Twenty CRM
Schema documentation
lossyFormaloo form definitions (field names, field types, field order, conditional logic visibility rules) are documented as a written schema inventory rather than migrated as executable configuration. The form structure informs the field mapping above. Conditional field visibility rules are documented as text notes for the customer's admin to implement in Twenty CRM after migration.
Formaloo
Workspace and Folder structure
Twenty CRM
Tags and workspace organization
lossyFormaloo Workspaces act as organizational containers for forms and responses. We map Workspace membership to Twenty CRM workspace tags and capture folder path hierarchies as a tag prefix convention (e.g., Sales / Leads / Q1) so that the organizational context from Formaloo is recoverable in Twenty's tag system. This is a structural mapping, not a 1:1 object import.
Formaloo
Form Integrations (Google Sheets, webhooks)
Twenty CRM
Integration documentation
lossyFormaloo integrations with Google Sheets, Wix, Pabbly, and webhooks are platform-specific and do not transfer to Twenty CRM. We document each active integration (connection type, trigger event, destination URL or sheet ID) as a written handoff inventory so the customer's admin can reconfigure equivalent integrations in Twenty CRM after migration.
| Formaloo | Twenty CRM | Compatibility | |
|---|---|---|---|
| Form Response | Person1:1 | Fully supported | |
| Form Response | Company1:1 | Fully supported | |
| Form Response (lead intake form) | Opportunity1:1 | Fully supported | |
| Database (relational cross-form links) | Custom Object or lookup relationship1:many | Fully supported | |
| Form Field (calculation, formula) | Custom field (formula) or text notelossy | Fully supported | |
| Form Field (signature) | Attachment or custom field1:1 | Fully supported | |
| Form Field (file upload) | ContentDocument via API1:1 | Fully supported | |
| Form Field (rating, choice, multi-select) | Custom field (select, multi-select)lossy | Fully supported | |
| Form (definition and structure) | Schema documentationlossy | Fully supported | |
| Workspace and Folder structure | Tags and workspace organizationlossy | Fully supported | |
| Form Integrations (Google Sheets, webhooks) | Integration documentationlossy | 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.
Formaloo gotchas
Old dashboard migration is a manual multi-step process
Excel import field types must match Formaloo's requirements
Signature fields gated behind paid tiers
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
Form audit and scoping
We audit every Formaloo form in the customer's workspace: form name, field list (field name, field type, required flag, conditional logic), response count, and any relational Database connections to other forms. We confirm whether the customer is on the old or new Formaloo dashboard, whether signature and file upload fields are present, and whether any forms are HIPAA-gated on an Enterprise plan. The scoping output is a per-form migration matrix that assigns each form to a target Twenty CRM object (Person, Company, Opportunity, or custom object), lists the field-level mappings, and flags any relational Database links requiring cross-form lookup resolution.
Twenty CRM workspace provisioning
We provision the Twenty CRM workspace, configure standard objects (Person, Company, Opportunity), and create any custom objects via the /metadata API before data import begins. This includes defining custom fields with the correct field types (text, number, date, select, multi-select, currency, email, phone, url), setting field-level visibility, and configuring lookup relationships between objects. The Twenty workspace is stood up in a staging environment first so that schema validation happens before production data loads.
Response extraction and field transformation
We extract all form responses from Formaloo via the REST API using paginated requests with rate-limit handling, or via Excel export when API access is unavailable. Each response is transformed from Formaloo's field-value JSON structure into a Twenty CRM-ready record format: field names are mapped to Twenty field API names, field types are converted to the target field type, and cross-form reference values are preserved as externalId strings for later lookup resolution. Responses are chunked into batches of 200-500 records to manage API call volume and allow retry on partial failures.
Relational lookup resolution
We run a two-pass load for cross-form relational data. The first pass loads all target records (Persons, Companies, Opportunities) without resolving reference fields, storing Formaloo reference IDs as externalId strings on each record. The second pass queries Twenty CRM for records matching those externalId values, retrieves the Twenty record IDs, and updates the lookup fields on the dependent records. Circular or multi-hop reference chains are resolved in topological order to avoid missing parent references. Any reference that cannot be resolved is flagged in a reconciliation report for the customer's admin to resolve manually.
Staging validation and reconciliation
We load a representative sample (typically 10% of total response volume or a minimum of 100 records) into the Twenty CRM staging workspace and run a reconciliation pass: record counts per object, spot-check of field values against the Formaloo source (at least 25 records per form), lookup chain verification (Person linked to Company, Opportunity linked to Company), and timestamp preservation. The customer's admin reviews the staging output and signs off on field mapping and object placement before the full production migration begins.
Production migration and cutover
We run the full production migration in dependency order: Company records first, then Person records (with CompanyId lookup resolved), then Opportunity records (with CompanyId and PersonId lookups resolved), then custom object records. Each phase emits a row-count reconciliation report. We freeze Formaloo write access during the final cutover window, run a delta migration of any records added during the window, then hand off to the customer as the system of record. We deliver the form schema inventory, the logic rule documentation, and the integration handoff document as written artifacts for the customer's admin to act on post-migration.
Platform deep dives
Formaloo
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 1 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 Formaloo and Twenty CRM.
Object compatibility
1 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
Formaloo: Not publicly documented.
Data volume sensitivity
Formaloo 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 Formaloo to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Formaloo 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 Formaloo
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.