CRM migration

Migrate from Customer Database App to Twenty CRM

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 logo

Customer Database App

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

80%

8 of 10

objects map 1:1 between Customer Database App and Twenty CRM.

Complexity

BStandard

Timeline

2-3 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Customer Database App logo

Customer Database App

What's pushing teams away

  • The absence of a programmatic API makes automated exports and integrations with downstream tools impossible without manual file handling.
  • No collaborative features such as user roles, activity logs, or shared dashboards create friction when a second team member needs access to a customer record.
  • The free tier carries no service-level guarantee; users have reported no recourse when data loss occurs on the hosted version.
  • Scalability is limited — performance degrades noticeably as the customer list grows beyond a few hundred records on mobile hardware.
  • Marketing and automation capabilities are absent, which pushes teams to migrate once they need email campaigns, lead scoring, or workflow triggers.

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 Customer Database App objects map to Twenty CRM

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

maps to

Twenty CRM

Person

1:1
Fully supported

Customer 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

maps to

Twenty CRM

Company

1:1
Fully supported

Customer 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

maps to

Twenty CRM

Custom Fields (Person and Company)

lossy
Mapping required

Every 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

maps to

Twenty CRM

Opportunity Stage

1:1
Fully supported

Customer 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

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Customer 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

maps to

Twenty CRM

Tag

lossy
Fully supported

Customer 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

maps to

Twenty CRM

Custom Date Field (Person)

1:1
Fully supported

Birthday 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

maps to

Twenty CRM

Attachment (via Files)

1:1
Fully supported

Contact 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

maps to

Twenty CRM

None

1:1
Fully supported

Vouchers 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

maps to

Twenty CRM

None

1:1
Not supported

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

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.

Customer Database App logo

Customer Database App gotchas

High

No API means migration runs through CSV exports only

Medium

User-defined schema creates field mapping ambiguity

Medium

MySQL sync creates a parallel data source that must be reconciled

Low

Voucher and birthday objects have no standard CRM equivalent

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

  • MySQL sync creates a parallel data source that must be reconciled

    Users with MySQL sync enabled hold two copies of their data — the local app database and the synced MySQL instance. Records modified after the last sync cycle may exist only in MySQL, and records pending sync may exist only in the app. We require customers to confirm the sync state of both copies before extraction. We extract from the MySQL source where it is reachable because it typically contains the most complete dataset. If the customer cannot confirm sync state, we extract from both sources and run a dedupe by email before loading into Twenty CRM.

  • User-defined schema creates field mapping ambiguity

    Customer Database App enforces no canonical schema, so the active field list must be inferred from each export's column headers. If the customer has added, renamed, or deleted custom fields since the last export, we flag the discrepancy before loading into Twenty. Custom fields with free-text values containing commas cause CSV parsing issues; we sanitize these during transform. We cannot pre-build a field mapper because no two Customer Database App installations share the same field set.

  • No API means migration runs through manual CSV exports only

    Customer Database App exposes no public REST or GraphQL API. We extract data exclusively through CSV or VCF exports generated from within the app. No automated delta-sync is possible after the initial export without re-running a manual export. For large datasets, we chunk exports into multiple CSV files when the record count exceeds the destination import threshold. The customer must be available to generate the export file on the day of migration.

  • Birthday and Voucher objects have no standard Twenty CRM equivalent

    Birthday exports as a date field but may land as a generic custom date field rather than a dedicated birthday property. Vouchers are not exported at all via CSV and have no equivalent object in Twenty CRM. We document these limitations in the migration scope and provide a supplemental CSV export for manual re-entry of voucher data post-migration.

  • Activity timeline is not exportable from Customer Database App

    Customer Database App does not export engagement history (calls, emails, meetings, notes) as structured data. Phone call logs are device-level only. We cannot migrate historical activity into Twenty CRM because no exportable activity records exist. The migration loads static contact and pipeline data only; the customer must configure email, calendar, and call tracking inside Twenty CRM post-migration.

Migration approach

Six steps for a successful Customer Database App to Twenty CRM data migration

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

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

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

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

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

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

Context on both ends of the pair

Customer Database App logo

Customer Database App

Source

Strengths

  • Zero cost with no contact count limit removes budget objections entirely for early-stage teams.
  • Mobile app and web browser access means the same database works on desktop and in the field.
  • User-defined schema accommodates non-standard business models without forcing a predefined data model.
  • MySQL sync option enables self-hosting for users who want data portability and ownership.
  • Built-in EU-GDPR tools such as data export and deletion requests simplify compliance for European users.

Weaknesses

  • No public API forces reliance on manual CSV or VCF exports, which breaks down at scale.
  • Absence of user roles and permissions makes the app unsuitable for teams with access-control requirements.
  • No email sequencing, marketing automation, or built-in communications channels limits long-term utility as a sales tool.
  • No SLA or data-residency guarantees on the hosted version introduce reliability risk for business-critical data.
  • Limited reporting and analytics mean users quickly outgrow the insight capabilities once the customer base matures.
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 Customer Database App 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

    Customer Database App: Not applicable — no API exists.

  • Data volume sensitivity

    B

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

Estimator

Estimate your Customer Database App 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 Customer Database App to Twenty CRM data migrations

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

Can't find your answer?

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 consultation

Most migrations land between two and three weeks for accounts with fewer than 2,000 Contacts and no MySQL sync complexity. Migrations with active MySQL sync, large custom field sets (over 20 fields), or attachment bundling requiring ZIP handling move to four to six weeks because of dual-source reconciliation, schema inference validation, and attachment linking. The timeline assumes the customer can generate a fresh CSV export on the migration day.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Customer Database App.
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