CRM migration

Migrate from Formaloo to Twenty CRM

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

Formaloo logo

Formaloo

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

45%

5 of 11

objects map 1:1 between Formaloo and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Formaloo logo

Formaloo

What's pushing teams away

  • Trustpilot reviewers report slow or unresponsive support, with some customers waiting days or weeks for answers after paying for a team subscription.
  • Early adopters were promised grandfathered workspace limits that were later changed, generating documented resentment and churn on review sites.
  • Email notification reliability is a recurring complaint — form submission alerts sometimes fail to arrive, affecting business-critical workflows.
  • Users on the free plan cannot collect signatures, which forces upgrades for any use case requiring legally binding form completion.
  • CSS-based form styling without a visual editor frustrates non-technical users who migrated from drag-and-drop form builders.

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

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

maps to

Twenty CRM

Person

1:1
Fully supported

Formaloo 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

maps to

Twenty CRM

Company

1:1
Fully supported

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

maps to

Twenty CRM

Opportunity

1:1
Fully supported

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

maps to

Twenty CRM

Custom Object or lookup relationship

1:many
Fully supported

Formaloo'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)

maps to

Twenty CRM

Custom field (formula) or text note

lossy
Fully supported

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

maps to

Twenty CRM

Attachment or custom field

1:1
Fully supported

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

maps to

Twenty CRM

ContentDocument via API

1:1
Fully supported

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

maps to

Twenty CRM

Custom field (select, multi-select)

lossy
Fully supported

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

maps to

Twenty CRM

Schema documentation

lossy
Fully supported

Formaloo 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

maps to

Twenty CRM

Tags and workspace organization

lossy
Fully supported

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

maps to

Twenty CRM

Integration documentation

lossy
Fully supported

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

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.

Formaloo logo

Formaloo gotchas

High

Old dashboard migration is a manual multi-step process

Medium

Excel import field types must match Formaloo's requirements

Low

Signature fields gated behind paid tiers

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

  • Formaloo form responses have no native CRM object schema

    Formaloo stores every piece of data as a Form Response with a field schema defined by the form builder, not as a structured CRM record. There is no Person object in Formaloo — a name field is just a text field. The migration requires mapping the form field names and types to Twenty CRM's Person, Company, and Opportunity field schemas, which means the field mapping is driven by the form definition, not a pre-defined object model. We audit every form's field schema during scoping and build a custom mapping matrix per form before any data moves. Skipping this step produces flat, unmapped records in Twenty with no Person-Company relationships and no field type enforcement.

  • Formaloo REST API does not expose a direct CRM export endpoint

    Formaloo's API exposes form definitions and response data but does not provide a dedicated CRM export format. We extract responses via the Formaloo REST API using paginated requests, transform each response from the field-value JSON format into a structured CRM record, and handle the fact that the API returns nested field objects that must be flattened before Twenty CRM import. The Excel export fallback is used when API access is rate-limited or when the customer is on a plan without API access. Both paths require field-level transformation that a generic CSV loader cannot perform automatically.

  • Relational Database cross-form lookups require two-pass resolution

    Formaloo Databases link Forms together via reference fields, creating N:1 and 1:N relationships that span forms. A single response in Form A may reference a response record in Form B via a Formaloo reference field. We capture these reference values during export, then resolve them to Twenty CRM record IDs during import by matching the referenced response's externalId. If Form B records are not yet loaded when Form A's import begins, we hold the unresolved lookups in a reconciliation queue and complete the resolution in a second pass. Circular reference chains across three or more forms require explicit disambiguation during scoping.

  • Formaloo's old and new dashboard can use different API endpoints

    Formaloo maintains an older dashboard and a newer dashboard, and the two versions may use different API endpoints or response schemas. During scoping, we confirm which dashboard the customer uses and whether any forms are still on the old dashboard requiring a manual transfer before API access. If forms are split across both dashboards, we run parallel exports from both endpoints and merge the response sets, deduplicating by response ID.

  • Logic rules and calculation fields cannot migrate as automation

    Formaloo's conditional logic, field visibility rules, and calculation formulas are UI-defined automation that does not export as structured data. A Formaloo calculation field like {Base Price} + {Shipping} * {Quantity} stores the result but not the formula itself. We document each calculation field's logic as a text note and migrate the calculated result as a static value on the target record. Conditional visibility rules are documented as text summaries for the customer's admin to review and recreate in Twenty CRM's custom field logic if needed.

Migration approach

Six steps for a successful Formaloo to Twenty CRM data migration

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

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

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

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

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

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

Context on both ends of the pair

Formaloo logo

Formaloo

Source

Strengths

  • Drag-and-drop form builder with over 200 templates for rapid deployment.
  • Built-in relational database connects forms without requiring code.
  • AI-powered form enhancement and Magic Import from existing URLs.
  • Self-hosted Enterprise option available for data residency requirements.
  • HIPAA-compliant tier with SSO included for regulated industries.

Weaknesses

  • CSS-based styling requires technical knowledge for custom form design.
  • No visual form editor for users without coding experience.
  • Email notification reliability issues reported across multiple review sources.
  • Support responsiveness inconsistent — some customers wait days for responses.
  • Calculation and logic rules do not export as structured automation.
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 Formaloo 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

    Formaloo: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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 consultation

Most migrations land between three and five weeks for up to 10 forms with fewer than 15,000 total responses and no relational cross-form links. Migrations with multiple relational Databases spanning three or more forms, large response histories exceeding 50,000 records, or customer-specific field naming that requires extensive transformation logic move to six to nine weeks because of the two-pass lookup resolution pass, custom object schema creation via the metadata API, and extended staging reconciliation.

Adjacent paths

Related migrations to explore

Ready when you are

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