CRM migration
Field-level mapping, validation, and rollback between Corteza CRM and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Corteza CRM
Source
Twenty CRM
Destination
Compatibility
6 of 11
objects map 1:1 between Corteza CRM and Twenty CRM.
Complexity
BStandard
Timeline
2-4 weeks
Overview
Moving from Corteza CRM to Twenty CRM is a platform migration that also involves a schema redesign. Corteza organizes data around named modules (Leads, Accounts, Contacts, Opportunities, Campaigns, Cases, Contracts, Events) with a namespace export path that has documented edge cases around orphaned page references. Twenty uses a simpler object model with Company and Person as standard objects, Opportunities, and a custom object system via the /metadata API. We audit the Corteza namespace for broken page-module links before export, translate each module to its Twenty equivalent, and handle custom Corteza modules by pre-creating the destination schema via Twenty's metadata API. Workflow definitions, automations, and namespace configuration do not migrate; we deliver a written inventory of these for the customer's admin to rebuild in Twenty's workflow builder. File attachments are not included in CSV-based migration paths and require supplemental API handling.
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 Corteza CRM 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.
Corteza CRM
Leads
Twenty CRM
Person
1:1Corteza Leads are a first-class module with standard fields (first name, last name, email, phone, rating) and a conversion workflow that creates Accounts, Contacts, and Opportunities. Twenty does not have a separate Lead object; all individual person records are Person objects. We migrate Corteza Lead records as Twenty Person records, and we flag the lead-conversion workflow as requiring a rebuild in Twenty's workflow builder. The original conversion status (converted vs not-yet-converted) is preserved in a custom field on the Person record for audit.
Corteza CRM
Account
Twenty CRM
Company
1:1Corteza Account records (representing companies) map directly to Twenty Company records. The account domain or website becomes the Company domainName field. Industry classification, address data, and social media URLs map to their equivalent Twenty Company fields. Company is the parent entity for Person in Twenty's data model, so we create all Company records before any Person import to satisfy the lookup relationship at insert time.
Corteza CRM
Contact
Twenty CRM
Person
1:1Corteza Contact records (individual people linked to Accounts) map to Twenty Person records. The contact-Account relation maps to the Person.companyId foreign key pointing to the migrated Company. First name, last name, email, phone, and job title migrate directly. Any custom fields on the Corteza Contact module migrate as custom fields on the Twenty Person object created via the /metadata API before import.
Corteza CRM
Opportunity
Twenty CRM
Opportunity
1:1Corteza Opportunities track sales deals with stage, amount, probability, and close date. Each Opportunity relates to an Account and multiple Contacts via OpportunityContactRole records. We map Opportunity to Twenty's Opportunity with stage, amount, probability, and closeDate preserved. The OpportunityAccountId maps from the Corteza Opportunity-Account relation. We create Opportunity records after Company and Person records are in place to satisfy lookups.
Corteza CRM
Campaign
Twenty CRM
Custom Object (Campaign)
lossyCorteza Campaigns group marketing activities and track campaign member responses. CampaignMember records link Contacts and Leads to a Campaign. Twenty does not have a native Campaign object in its standard schema, so we create a Campaign custom object via the /metadata API with fields for campaign name, status, type, start date, and end date. CampaignMember relations migrate as a separate custom association object linking the Person (or Company) custom object to the Campaign custom object.
Corteza CRM
Case
Twenty CRM
Custom Object (Case)
lossyCorteza Cases track customer support issues with status, priority, origin, and resolution fields. Cases link to Accounts and Contacts. Twenty does not have a native Case object; we create a Case custom object via the /metadata API with the relevant fields and create a CaseContact association to the Person object. Status values migrate as a picklist on the custom object.
Corteza CRM
Contract
Twenty CRM
Custom Object (Contract)
lossyCorteza Contracts store agreement details with line items (ContractLineItem), related Accounts, and Contact roles (ContractContactRole). Twenty does not have a native Contract object. We create a Contract custom object via the /metadata API with fields for contract name, account (linked to Company), start date, end date, status, and terms. Contract line items migrate as a related custom object with a lookup to the parent Contract record.
Corteza CRM
Task
Twenty CRM
Task (Activity)
1:1Corteza Tasks can be standalone or related to any parent record (Lead, Account, Contact, Opportunity) and have status, due date, assignee, and optional description. We map tasks to Twenty Activity records with the appropriate type discriminator. Task assignees resolve by email match against the Twenty User table. Any Corteza task without a matching User goes to a reconciliation queue for the customer's admin to provision.
Corteza CRM
Event
Twenty CRM
Task (Activity type=event)
1:1Corteza Events represent calendar items (meetings, calls) related to any CRM record. Each Event stores datetime, duration, organizer, and attendee references. We map Events to Twenty Activity records with the event type discriminator set. Start datetime, end datetime, and location migrate as custom fields on the Activity. Attendee references resolve by email match against migrated Person records and create ActivityParticipant records in Twenty.
Corteza CRM
Custom Module
Twenty CRM
Custom Object
lossyCorteza's low-code environment lets administrators create entirely custom modules beyond the standard CRM set. These custom modules may have non-standard field types, custom validation rules, or non-standard relationships. We audit each custom module during discovery, pre-create the destination custom object in Twenty via the /metadata API (creating DataSource, Object, and Field metadata entries), and then migrate records via the /graphql endpoint. Custom module naming conventions are preserved as the custom object name with API-compliant naming applied.
Corteza CRM
File and Attachment
Twenty CRM
Attachment
lossyCorteza file fields store attachments per module. The export path handles individual file records, but bulk attachment export with folder structure intact may require supplemental handling. Twenty's CSV export path explicitly excludes file attachments. We handle file migration by exporting files from Corteza's storage, uploading them to Twenty's storage layer, and creating Attachment records linked to the parent object by ID resolution. This requires supplemental API handling beyond the standard record migration sequence.
| Corteza CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Leads | Person1:1 | Fully supported | |
| Account | Company1:1 | Fully supported | |
| Contact | Person1:1 | Fully supported | |
| Opportunity | Opportunity1:1 | Fully supported | |
| Campaign | Custom Object (Campaign)lossy | Fully supported | |
| Case | Custom Object (Case)lossy | Fully supported | |
| Contract | Custom Object (Contract)lossy | Fully supported | |
| Task | Task (Activity)1:1 | Fully supported | |
| Event | Task (Activity type=event)1:1 | Fully supported | |
| Custom Module | Custom Objectlossy | Fully supported | |
| File and Attachment | Attachmentlossy | 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.
Corteza CRM gotchas
Namespace export fails on orphaned page references
Workflow automation breaks after restore or upgrade
Field-level security does not cover all access scenarios
Federation is experimental and not production-ready
No publicly documented API rate limits
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
Discovery and schema audit
We audit the source Corteza instance across all modules (standard and custom), namespace configuration, workflow definitions, file attachments, and API access. We assess the target Twenty instance for custom object requirements and confirm the /metadata API is accessible. The discovery output is a written migration scope covering which modules map to standard Twenty objects, which require custom object creation via metadata API, which require supplemental file handling, and which require admin rebuild (workflows, namespace configuration).
Namespace audit and orphaned page cleanup
We audit the Corteza namespace for orphaned page references that would cause export to fail. Any page referencing a deleted module is cleaned up by removing or re-linking the broken reference before namespace export is attempted. If the namespace cannot be cleaned (deleted modules cannot be restored without a backup), we fall back to direct JSON API extraction per module rather than namespace export.
Custom object schema creation in Twenty
For every Corteza custom module and every standard object that requires custom fields, we pre-create the destination schema in Twenty via the /metadata API. This includes creating DataSource entries, Object entries, and Field entries for each custom module. We wait for the GraphQL schema cache to recompute after each custom object is created before proceeding to the next. Standard objects (Company, Person, Opportunity) use their existing schema with any required custom fields added.
Sandbox migration and reconciliation
We run a full migration into a Twenty sandbox instance (or a staging environment) using production-like data volume. The customer's team reconciles record counts, spot-checks 25-50 random records against the Corteza source, and validates that parent-child relationships (Company-Person, Opportunity-Company) are intact. Any mapping corrections happen in this phase before production migration begins.
Production migration in dependency order
We run production migration in record-dependency order: custom object metadata (created via /metadata API first), Company records (from Corteza Accounts), Person records (from Corteza Leads and Contacts with CompanyId resolved), Opportunities (with CompanyId and PersonId lookups resolved), then Activity history (Tasks and Events via /graphql), then custom object records (with all lookups resolved). Files and attachments migrate last via supplemental API calls. Each phase emits a row-count reconciliation report before the next phase begins.
Cutover, validation, and workflow rebuild handoff
We freeze Corteza writes during cutover, run a final delta migration of any records modified during the migration window, then enable Twenty as the system of record. We deliver the workflow and automation inventory document to the customer's admin team. We support a one-week hypercare window where we resolve any reconciliation issues raised by the customer's team. We do not rebuild Corteza workflows in Twenty inside the migration scope; that is a separate engagement or an internal admin task.
Platform deep dives
Corteza CRM
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 Corteza CRM 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
Corteza CRM: Not publicly documented.
Data volume sensitivity
Corteza CRM 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 Corteza CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Corteza CRM 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 Corteza CRM
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.