CRM migration
Field-level mapping, validation, and rollback between Customer Database App and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Customer Database App
Source
Twenty CRM
Destination
Compatibility
8 of 10
objects map 1:1 between Customer Database App and Twenty CRM.
Complexity
BStandard
Timeline
2-3 weeks
Overview
Moving from Customer Database App to Twenty CRM is a data extraction and schema translation project. Customer Database App exposes no public API, so we extract records through CSV or VCF exports and infer the active field list from column headers. For users with MySQL sync enabled, the MySQL instance typically contains more complete data and is used as the primary source after confirming sync state. Twenty's data model uses People as the primary contact object alongside Companies, with Opportunities for pipeline stages and Custom Objects for non-standard fields. We map user-defined custom fields from Customer Database App into Twenty's corresponding custom fields on People and Companies. Voucher balances and phone call history do not migrate; we deliver a supplemental export CSV for manual re-entry of voucher data. Pipeline stages map to Opportunity stage names in Twenty, preserving the Kanban ordering. We do not migrate automations, workflows, or forms because Customer Database App does not expose these as structured data exports.
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 Customer Database App 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.
Customer Database App
Contact
Twenty CRM
Person
1:1Customer Database App Contacts map to Twenty CRM Person records. Every user-defined custom field in the export column header becomes a Twenty custom field on the Person object. We infer the full field list from the first CSV export file and create the corresponding custom field definitions in Twenty before import. Name, phone, email, address, and standard properties map directly; custom properties map as typed fields (text, number, date, checkbox) based on value inspection.
Customer Database App
Company
Twenty CRM
Company
1:1Customer Database App does not have a native Company object; company data lives as custom fields on Contact records (e.g., company name field, industry field). We extract these into a normalized Company object in Twenty CRM, deduplicating by company name, then link each Person record back to the resolved Company via the Person's companyId field. This requires a two-pass import: Companies first, then People with resolved CompanyId.
Customer Database App
Custom Properties
Twenty CRM
Custom Fields (Person and Company)
lossyEvery Customer Database App contact supports unlimited user-defined fields with no enforced schema. We reverse-engineer the active field list from exported CSV column headers, classify each field by inferred type (text string, numeric value, ISO date, boolean flag), and create matching custom fields in Twenty CRM under the appropriate object before data load. If a field was added after the last export, we flag the discrepancy and require a fresh export.
Customer Database App
Pipeline Stage
Twenty CRM
Opportunity Stage
1:1Customer Database App's Kanban pipeline stages export as a label-value pair on each contact record. We extract the distinct stage names, preserve their sort order, and create corresponding Opportunity stage values in Twenty CRM. Stage probability percentages default to Twenty's standard values but can be customized if the customer provides the original percentages from Customer Database App.
Customer Database App
Pipeline
Twenty CRM
Opportunity
1:1Customer Database App does not have a standalone Opportunity object; pipeline state is embedded in contact records. We create Opportunity records in Twenty CRM for each contact that has a non-empty pipeline stage, linking to the Person and the resolved Company. The Opportunity close date is set from any date field in Customer Database App that corresponds to an expected close date, or set to 90 days forward if no close date exists.
Customer Database App
Group / Tag
Twenty CRM
Tag
lossyCustomer Database App exports groups and tags as comma-separated label strings on each contact record. We split these into individual Tag records in Twenty CRM, creating the tag if it does not already exist, and link it to the corresponding Person via the Tag's targetId and targetObjectName fields. Tags used for segmentation (e.g., VIP, churned, referral) are preserved as-is.
Customer Database App
Birthday Record
Twenty CRM
Custom Date Field (Person)
1:1Birthday exports from Customer Database App as a date field on the contact record. We map it to a custom date field named birthday on the Person object in Twenty CRM. If Twenty's standard Person schema includes a birthday field in a later release, we map directly; otherwise it remains a custom date field.
Customer Database App
Document / Attachment
Twenty CRM
Attachment (via Files)
1:1Contact images and PDF exports of individual records can be bundled into a ZIP archive alongside the CSV. We attach each contact's image or PDF to the corresponding Person record in Twenty CRM using Twenty's attachment handling. Large ZIP archives are chunked to avoid upload timeouts, and each attachment is linked to the correct Person by email or name dedupe key.
Customer Database App
Voucher
Twenty CRM
None
1:1Vouchers are a standalone object in Customer Database App with no direct equivalent in Twenty CRM's data model. Voucher balances are not exported via CSV at all. We do not migrate voucher data. We recommend exporting vouchers as a separate supplemental CSV for manual re-entry in Twenty or a dedicated voucher management tool post-migration.
Customer Database App
Phone Call History
Twenty CRM
None
1:1Caller-ID logs and call history are transient device-level records stored on the mobile hardware, not persisted in the app database or exportable via CSV/VCF. These do not migrate. We recommend documenting current call-handling procedures separately for the customer's admin to re-establish in Twenty CRM or a linked telephony tool.
| Customer Database App | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact | Person1:1 | Fully supported | |
| Company | Company1:1 | Fully supported | |
| Custom Properties | Custom Fields (Person and Company)lossy | Mapping required | |
| Pipeline Stage | Opportunity Stage1:1 | Fully supported | |
| Pipeline | Opportunity1:1 | Fully supported | |
| Group / Tag | Taglossy | Fully supported | |
| Birthday Record | Custom Date Field (Person)1:1 | Fully supported | |
| Document / Attachment | Attachment (via Files)1:1 | Fully supported | |
| Voucher | None1:1 | Fully supported | |
| Phone Call History | None1:1 | Not 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.
Customer Database App gotchas
No API means migration runs through CSV exports only
User-defined schema creates field mapping ambiguity
MySQL sync creates a parallel data source that must be reconciled
Voucher and birthday objects have no standard CRM equivalent
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
Source extraction and schema inference
We guide the customer through generating a full CSV export from Customer Database App (or connect to the MySQL sync instance if reachable). For MySQL sync sources, we query the contacts table directly to capture records not yet synced to the local app. We parse the column headers to infer the active field list, classify each field by type (text, number, date, boolean), and build a preliminary field map before any data moves.
Schema design in Twenty CRM
We create custom fields in Twenty CRM's Person and Company objects to receive the inferred Customer Database App field set. We configure the Opportunity object with pipeline stages matching the exported stage names and sort order. If the customer has company data stored as custom fields on contacts, we create a Company record for each distinct company name and resolve the Person-to-Company linkage. Tags are provisioned in Twenty from the exported group/tag values.
Data transform and deduplication
We transform the exported CSV into Twenty CRM's import format, sanitizing free-text fields with embedded commas, parsing dates to ISO format, and resolving the Person-to-Company lookups by email and company name dedupe. If extracting from both MySQL and the app CSV simultaneously, we run a dedupe pass by email address, preferring the MySQL record where both sources have the same contact.
Attachment bundling
We instruct the customer to export contact images and PDF record exports from Customer Database App and bundle them into a ZIP archive organized by contact email or name. We chunk large archives into subfolders to avoid upload timeouts. Each attachment is linked to the corresponding Person record after the base import completes.
Test import into Twenty CRM staging
We run a full import into a staging Twenty CRM instance (or a fresh workspace if no staging environment is available) and reconcile record counts: Persons in, Companies in, Opportunities in, Tags applied, Attachments linked. The customer spot-checks 20-30 records against the source export and signs off before production migration proceeds.
Production cutover and supplemental exports
We run the production migration, freeze writes in Customer Database App during the cutover window, and load the final delta of any records modified since the test import. We deliver the voucher supplemental export CSV and the call-handling documentation template for the customer's admin to re-establish outside the CRM. We do not rebuild automations or workflows because Customer Database App does not expose these as structured data exports.
Platform deep dives
Customer Database App
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 Customer Database App 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
Customer Database App: Not applicable — no API exists.
Data volume sensitivity
Customer Database App 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 Customer Database App to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Customer Database App 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 Customer Database App
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.