CRM migration

Migrate from Constructor to Twenty CRM

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

Constructor logo

Constructor

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

objects map 1:1 between Constructor and Twenty CRM.

Complexity

BStandard

Timeline

24–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Constructor CRM stores contacts, companies, and deals in a standard relational model with owner assignments and custom field support. Twenty CRM exposes these as People, Companies, and Opportunities objects built on a TypeScript/NestJS backend with a PostgreSQL database and a GraphQL API. FlitStack AI sequences the migration to respect Twenty's import-order constraint: Companies first (the 'one' side of relationships), then People (linked via companyId), then Opportunities (linked to both), and custom objects last. We preserve original create dates as custom fields since Twenty sets CreatedAt at import time. Owner resolution happens by email match against Twenty workspace members — your team must exist in Twenty before records referencing them can link correctly. Constructor workflows, automation rules, and sequence configurations do not migrate; we export them as JSON重建 references for your Twenty admin. Attachments export from Constructor and re-upload to Twenty's file storage. Delta-pickup captures any records modified during the cutover window.

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

Constructor logo

Constructor

What's pushing teams away

  • G2 reviewers report uptime falling below 90% during some periods, which is below the threshold most modern SaaS customers tolerate.
  • Reporting is consistently called out as weak — reviewers note reports are not always available and filters are 'tough to administer and utilize'.
  • Filter management is described as difficult to manage and use effectively, slowing down ad-hoc data analysis and list-building.
  • Customers seeking strong native integrations beyond the listed Salesforce / ClickHomes / OCR / ELO connectors hit gaps and have to commission custom API work.
  • Builders that expand outside ANZ outgrow the platform's regional focus, since progress-claim conventions and tax treatments are tuned for Australian and New Zealand construction practice.

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

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

Constructor

Contact / Person

maps to

Twenty CRM

People

1:1
Fully supported

Constructor contacts migrate as Twenty People records. First name, last name, email, phone, job title, and address fields map directly. The People object links to Companies via the companyId field — Constructor contacts without a primary company receive a 'Unassigned' placeholder or remain standalone until a company link is established during the Companies import phase.

Constructor

Account / Organization

maps to

Twenty CRM

Companies

1:1
Fully supported

Constructor accounts map to Twenty Companies. The Companies object in Twenty stores displayName, domain (website), industry, size, and location fields. Constructor parent-child account hierarchies translate to Twenty's company-to-company relationships via a parentCompanyId field if your Constructor setup uses organizational hierarchies.

Constructor

Deal / Opportunity

maps to

Twenty CRM

Opportunities

1:1
Fully supported

Constructor deals migrate as Twenty Opportunities with the same deal name, amount, stage, and expected close date. Twenty Opportunities link to Companies (accountId) and can link to People (point of contact). Stage names map value-by-value if Constructor uses a pick-list for stages — we preserve the original stage labels as Opportunity stage values in Twenty.

Constructor

Note / Annotation

maps to

Twenty CRM

Notes

1:1
Fully supported

Constructor notes attach to contacts, companies, or deals. In Twenty, Notes are standalone objects that link to People, Companies, Opportunities, or other records via the NoteTargets relation. We preserve the original note body, author, and create timestamp. Rich-text formatting converts to Twenty's supported note format.

Constructor

Task / To-Do

maps to

Twenty CRM

Tasks

1:1
Fully supported

Constructor tasks migrate as Twenty Tasks with the task title, due date, assignee, completion status, and body preserved. Tasks link to the parent record (People, Company, or Opportunity) via taskId. Completed versus open status carries over as a boolean completed field in Twenty.

Constructor

Activity / Engagement (Call, Email, Meeting)

maps to

Twenty CRM

Tasks / Events

1:1
Fully supported

Constructor activity logs (call logs, email threads, meeting records) split based on type. Call and email activities become Tasks with Type='Call' or Type='Email' in Twenty. Meeting records with start/end times convert to Twenty Tasks with a scheduled datetime if Twenty's event model is not available in your version. Original activity timestamps and owners (resolved by email) are preserved.

Constructor

Custom Object

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Constructor custom objects migrate 1:1 to Twenty custom objects. Your Twenty workspace must have the custom object schema created (via Settings → Data Model → Create new object) before migration runs. We export the custom object definition from Constructor and use Twenty's Metadata API to create matching objects with the same field types — text, number, date, select, multi-select, or relation.

Constructor

Custom Field (on standard objects)

maps to

Twenty CRM

Custom Field (on People, Companies, Opportunities)

1:1
Fully supported

Constructor custom fields on contacts, accounts, or deals require pre-creation in Twenty's data model before CSV import. We document all custom fields in the mapping plan, flag which Twenty object each custom field belongs to, and include the field type from Constructor. Your admin creates these in Settings → Data Model first — FlitStack cannot create fields, only data.

Constructor

User / Owner

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

Constructor users and deal owners resolve by email match against Twenty workspace members. The Twenty import documentation explicitly requires that users exist before importing records that reference them — we flag unmatched owners before migration and either invite them to Twenty first or assign their records to a fallback workspace member.

Constructor

Attachment / File

maps to

Twenty CRM

File

1:1
Fully supported

Constructor file attachments on contacts, companies, or deals export from Constructor's storage and re-upload to Twenty's file storage. We preserve the original file name, mime type, and upload timestamp. Files attach to the parent record in Twenty using the file associations API. Size limits from Constructor's export apply.

Constructor

Workflow / Automation

maps to

Twenty CRM

Workflow (Twenty)

1:1
Fully supported

Constructor workflows and automation rules do not migrate to Twenty. Twenty's workflow builder operates differently from Constructor's automation engine. We export your Constructor workflow definitions as a JSON reference file so your Twenty admin can rebuild them in Settings → Workflows. This is a manual step that requires process review.

Constructor

Sequence / Cadence

maps to

Twenty CRM

N/A

1:1
Fully supported

Constructor sequences and outreach cadences do not transfer. Reddit discussions about Twenty note that it 'lacks native sequencing' as of v1.0. Sequences must be rebuilt manually in Twenty or via a third-party sales engagement tool. We export sequence definitions as reference documentation.

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.

Constructor logo

Constructor gotchas

High

Reporting and filter limitations make pre-migration data inventory harder

High

Estimating templates and take-offs carry business logic, not just data

Medium

KeyPay payroll data lives in a connected but separate system

Medium

Uptime variability requires staged migration windows

Low

Custom integrations (Salesforce, ClickHomes, OCR, ELO) need separate scoping

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

  • Twenty requires fields to exist before CSV import — custom fields must be pre-created

    Constructor custom fields on People, Companies, or Opportunities need to be created in Twenty's data model before the migration CSV lands. Twenty's documentation explicitly warns: 'Fields must exist before import. The CSV import creates records, not fields.' We cannot create fields through the import process — your Twenty admin must create them in Settings → Data Model first, specifying field type (text, number, date, select, multi-select, relation). We include a complete field creation checklist in the migration plan so nothing is missed before data loads.

  • Twenty import order is strict — Companies before People before Opportunities

    Twenty's CSV import requires loading objects in a specific sequence because foreign key relationships must resolve at import time. The Twenty documentation states: 'When importing related objects, upload files in this order: Companies first, People second (linked to companies via companyId), Opportunities third (linked to companies/people), Custom objects with relations last.' Constructor data that references accounts in contact records or opportunities will fail import if the referenced Company does not yet exist. We sequence the migration to satisfy these constraints and flag any orphaned references before each phase runs.

  • Users must exist in Twenty before records referencing them can be imported

    Constructor owner and assignee fields contain user references that map to Twenty workspaceMemberId. Twenty's documentation warns: 'If your data includes user references (Account Owner, Assignee, etc.), those users must exist in Twenty before import. Otherwise, those relations cannot be mapped.' We run an owner-resolution step before migration — matching Constructor owner emails to Twenty workspace members by email. Unmatched owners are flagged for you to either invite to Twenty first or reassign their records to a fallback member. No record with an unresolved owner commits during the migration run.

  • Constructor workflows and sequences do not transfer to Twenty

    Constructor automation rules, workflow triggers, and outreach sequences have no equivalent in Twenty's migration path. Reddit discussions about Twenty note that the platform 'lacks native sequencing' as of v1.0, and Twenty's own migration documentation states: 'Views, workflows, and permissions must be recreated manually after migration.' We export your Constructor workflow definitions as JSON and provide a rebuild reference for your Twenty admin. This is a manual process that requires reviewing each automation's trigger conditions and rebuilding in Twenty's workflow builder or via the GraphQL API.

  • Twenty lacks a native marketing-contact billing distinction

    If Constructor distinguishes between marketing-qualified contacts and sales contacts for billing or reporting purposes, this flag has no native equivalent in Twenty. Twenty's People object does not have a built-in marketing-contact designation — the distinction would need to migrate as a custom select field (e.g., Contact_Type__c with values like 'Marketing', 'Sales'). We surface this in the mapping plan and your admin decides whether to recreate the distinction as a custom field or consolidate under a single contact type.

Migration approach

Six steps for a successful Constructor to Twenty CRM data migration

  1. Audit Constructor data model and export all objects

    We connect to Constructor via API or CSV export to inventory all objects: People, Companies, Opportunities, Notes, Tasks, custom objects, and attachments. We document field types, pick-list values, relationship cardinalities, and owner distribution. This audit identifies data quality issues (duplicate emails, missing required fields), custom field counts, and any non-standard objects that need custom object creation in Twenty before migration. The output is a detailed data map and a cleanup checklist delivered before any migration work begins.

  2. Create Twenty schema — custom fields and custom objects first

    Your Twenty admin (or our team with admin credentials) creates all custom fields in Settings → Data Model before we touch any data. We deliver a field creation checklist mapped from the Constructor audit: object name, field label, field type, and pick-list options for select fields. Custom objects get created with their schema via Twenty's Metadata API. We verify all fields exist in Twenty before proceeding to export — Twenty's import will reject CSV rows referencing fields that do not yet exist.

  3. Resolve owners and invite users to Twenty workspace

    We match Constructor owner email addresses against Twenty workspace members by email. Records with unmatched owners are listed with their Constructor owner name and email so you can decide: invite that person to Twenty first, or reassign their records to a fallback workspace member. This step gates the migration — no record with an unresolved workspaceMemberId reference can import cleanly. We require written confirmation that all owner references are resolved before the migration run commits.

  4. Run sequenced migration — Companies, then People, then Opportunities

    Following Twenty's import-order constraint, we migrate in three sequenced phases. First: Companies CSV with displayName, domain, industry, employees, annualRevenue, and parentCompanyId for hierarchy. Second: People CSV with firstName, lastName, email, phone, jobTitle, and companyId linking each contact to its parent Company. Third: Opportunities CSV with name, amount, stage, expectedCloseDate, probability, companyId, and personId for primary contact. Each phase validates row counts and relationship resolution before the next phase begins.

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

    A representative sample (typically 100–500 records spanning People, Companies, and Opportunities) migrates first into your Twenty workspace. We generate a field-level diff report comparing source Constructor values to the resulting Twenty fields, highlighting any truncation, format changes, or dropped values. You review the diff and confirm mapping accuracy before the full migration run commits. This prevents bulk data issues from reaching production in Twenty.

  6. Execute full migration with delta-pickup window and rollback plan

    Full migration runs against Twenty with a delta-pickup window (24–48 hours) capturing any records created or modified in Constructor during cutover. Audit logs record every operation. We provide a one-click rollback procedure if reconciliation fails — the pre-migration backup remains intact until you confirm the migrated data is accurate. Post-migration, we deliver a final reconciliation report comparing Constructor record counts to Twenty record counts per object, plus any records that failed import with error reasons for manual resolution.

Platform deep dives

Context on both ends of the pair

Constructor logo

Constructor

Source

Strengths

  • Tightly integrated Sales, Estimating, Accounting, Scheduling, and Payroll modules under one platform.
  • Visual take-off tools and template-driven estimating tailored to residential building workflows.
  • KeyPay-powered payroll with STP Phase 2 compliance for Australian statutory reporting.
  • Cost-plus and progress-claim billing native to the platform — no separate accounting bolt-on needed.
  • Australian-owned with development team in Australia, tuned to ANZ residential-building practice.

Weaknesses

  • Reporting and filter UX is widely cited as weak by G2 reviewers.
  • Uptime has been reported under 90% during some periods.
  • Limited native integration catalog — most connections (Salesforce, ClickHomes, OCR, ELO) require custom build.
  • Regional focus on ANZ residential construction limits fit for builders outside that geography.
  • Public API documentation is thin; integration partners typically engage the vendor for credentials and specs.
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. 3 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 Constructor and Twenty CRM.

  • Object compatibility

    B

    3 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

    Constructor: Not publicly documented — no published rate limits. Typical SaaS limits assumed and confirmed during scoping..

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Constructor-to-Twenty migrations complete in 48–72 hours of clock time for under 50,000 total records. Larger datasets with 500k+ records or multiple custom objects extend to 5–10 days. The longest planning step is pre-creating custom fields in Twenty's data model before CSV import — Twenty requires all fields to exist before records can land. We include a field creation checklist to keep this phase parallel to other work.

Adjacent paths

Related migrations to explore

Ready when you are

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