CRM migration

Migrate from Zilliant CPQ to Twenty CRM

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

Zilliant CPQ logo

Zilliant CPQ

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

58%

7 of 12

objects map 1:1 between Zilliant CPQ and Twenty CRM.

Complexity

BStandard

Timeline

4-8 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Zilliant CPQ to Twenty CRM is a cross-category migration: Zilliant CPQ is a manufacturing-focused Configure-Price-Quote platform built around Products, Quotes, and pricing matrices, while Twenty CRM is an open-source CRM centered on Companies, People, and Opportunities. The core challenge is that Twenty has no native Quote object and no native Product/Price List model, so Quotes from Zilliant land as Opportunities with custom pricing fields, and Products from Zilliant land as a custom object with price-list data stored in custom fields. We map Accounts to Companies, Contacts to People, and preserve the ERP_ID column from Price Items as a custom field that downstream fulfillment systems depend on. Groovy scripts and guided-selling rule packages do not migrate as executable logic; we export them as written documentation for the customer's team to recreate. Pricing agreement tiers, matrix pricing, and override pricing from Zilliant transfer as structured Opportunity fields and notes, not as live pricing rules. The migration is scoped for data only, with workflows, automations, and integrations excluded from standard scope.

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

Zilliant CPQ logo

Zilliant CPQ

What's pushing teams away

  • Slow loading and performance issues during complex operations are the most cited frustrations, particularly during quote generation with many line items
  • Time lag between configuration completion and pricing calculation creates friction in fast-moving sales cycles, with users describing it as a recurring bottleneck
  • Manufacturing complexity that exceeds the platform's constraint-based configuration model forces teams to maintain workarounds outside CPQ, undermining the single-source-of-truth goal
  • Integration complexity with multiple ERP systems (SAP, Salesforce) creates data synchronization drift that requires manual correction
  • Some users report the platform's opinionated approach to pricing logic conflicts with unique discounting requirements in their specific vertical

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

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

Zilliant CPQ

Account

maps to

Twenty CRM

Company

1:1
Fully supported

Zilliant CPQ Accounts (subject objects linked to Quotes and Opportunities) map to Twenty CRM Companies. Standard and custom account attributes migrate as custom fields on the Company object. Large account hierarchies with custom address structures require field-level mapping of address sub-fields (street, city, region, postal code, country) into Twenty's address compound field format.

Zilliant CPQ

Contact

maps to

Twenty CRM

People

1:1
Fully supported

Zilliant CPQ Contacts map to Twenty CRM People. We preserve contact-to-account linkages via the Twenty People-to-Company relationship. Custom BDA fields on Contact (mapped from C4C via lookup tables) migrate as custom fields on People, but we flag that C4C localized display labels for list-type BDA fields are not preserved—only the raw code value transfers.

Zilliant CPQ

Product

maps to

Twenty CRM

Custom Object: Products

lossy
Fully supported

Zilliant CPQ Products (the base entity, equivalent to ERP Materials) require a custom object created in Twenty Settings → Data Model before any import. Variant configuration rule sets and characteristic-based product models do not migrate as executable rules; we export them as a structured rule package document for manual recreation. The ERP_ID cross-reference on Products migrates as a custom text field.

Zilliant CPQ

Quote

maps to

Twenty CRM

Opportunity

1:many
Fully supported

Zilliant CPQ Quotes (the core output object with headers, SalesItem line items, pricing calculations, and guided-selling context) map to Twenty CRM Opportunities. Quote header fields (quote number, status, created date, expiration date) map to Opportunity fields. We preserve Quote status as a custom Opportunity field because Twenty Opportunities lack a native status concept equivalent to Zilliant's quote lifecycle states. Historical Quote status states require a custom picklist.

Zilliant CPQ

SalesItem (Quote line items)

maps to

Twenty CRM

Custom Object: Quote Line Items

lossy
Fully supported

Zilliant CPQ SalesItems (the line-item subject type containing quantity, pricing, and product references) require a custom object in Twenty because Opportunity Line Items are not a native CRM feature. Complex BOM (Bill of Materials) item configurations with nested quantity settings require recursive decomposition during transform. The parent Quote-to-Line-Item relationship is preserved via a lookup custom field on the line item object pointing to the Opportunity.

Zilliant CPQ

Price List

maps to

Twenty CRM

Custom Object: Price Lists

lossy
Fully supported

Zilliant CPQ Price Lists (containing catalog, reference, global list, published, and matrix price types) require a custom object in Twenty. Multi-currency price lists require explicit currency mapping to Twenty's currency field. The full price type hierarchy and sequencing is preserved as structured custom fields on the Price List object.

Zilliant CPQ

Price Item

maps to

Twenty CRM

Custom fields on Product

1:many
Fully supported

Zilliant CPQ Price Items (linked to Products and belonging to Price Lists) decompose into multiple custom numeric fields on the Product custom object: list price, agreement price, matrix price, and override price. The ERP_ID column on Price Items can be hidden system-wide or per-role via UI Profiles—we explicitly query hidden column data during extraction to preserve the ERP mapping layer that downstream order-fulfillment systems depend on, and store it as a custom field on the Product.

Zilliant CPQ

Sales Agreement

maps to

Twenty CRM

Custom Object: Sales Agreements

1:1
Fully supported

Zilliant CPQ Sales Agreements (customer-specific pricing contracts with effective date ranges, discount tiers, and pricing overrides) require a custom object in Twenty because no native agreement or contract object exists. Effective dates map to custom date fields, discount tiers map to a custom multi-select field or child object, and pricing overrides are stored as structured fields on the Agreement. We document the agreement-to-account linkage for manual configuration in Twenty.

Zilliant CPQ

Guided Selling Rules

maps to

Twenty CRM

Written documentation (no direct mapping)

1:1
Mapping required

Zilliant CPQ Guided Selling Rules (product rules defined by characteristics that drive constraint-based configuration) are stored as structured rule packages, not individual records. We export them as a structured JSON and Markdown rule package document listing every rule, its trigger characteristics, constraints, and recommended configuration in Twenty. The rules themselves do not execute at the destination and require manual recreation by the customer's technical team.

Zilliant CPQ

Business Data Attributes (BDAs)

maps to

Twenty CRM

Custom fields on Company or People

1:1
Mapping required

Zilliant CPQ BDAs (custom fields mapped between SAP C4C and CPQ via lookup tables, supporting String, Boolean, and Decimal types) map to custom fields on Company or People objects in Twenty. We preserve the BDA-to-C4C lookup relationship in a separate reference table. List-type BDA fields lose C4C localization—we flag every BDA field with list-type data and advise customers that translated labels need to be re-established from C4C source records post-migration.

Zilliant CPQ

Owner (User)

maps to

Twenty CRM

Twenty workspace Members

1:1
Fully supported

Zilliant CPQ Users (with domain-approval restrictions and role-based UI Profiles controlling field visibility) map to Twenty CRM workspace Members. We resolve owners by email match. Any Zilliant Owner without a matching Twenty Member goes to a reconciliation queue for the customer's admin to provision users before record import resumes. Per Twenty's import documentation, users must be invited and active before record imports that reference them.

Zilliant CPQ

Attachment and Notes

maps to

Twenty CRM

Note

1:1
Fully supported

Zilliant CPQ attachment metadata and Notes from the Notes section of Quotes migrate as Twenty Note records linked via the target object (Opportunity, Company, or People). We verify the patch status of the source environment for any customers on pre-patch builds that exhibit the resolved attachment download bug.

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.

Zilliant CPQ logo

Zilliant CPQ gotchas

High

Groovy scripted logic does not export as data

Medium

ERP_ID column may be hidden but still critical

Medium

SAP characteristic labels can duplicate after legacy migration

Medium

BDA list-type fields lose C4C localization

Low

Attachment downloads could fire multiple times on older builds

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 CRM has no native Quote or Product object

    Twenty CRM is a CRM, not a CPQ platform. It has no native Quote object and no native Product or Price List object. Zilliant CPQ Quotes land as Opportunities with custom fields for quote-specific attributes, and Products land as a custom object created in Settings → Data Model before import. CSV imports in Twenty create records, not fields—custom fields must be defined before any data import begins. Customers expecting a direct quote-equivalent in Twenty will not find one without significant custom object design.

  • Groovy scripted logic does not export as data

    Zilliant CPQ allows custom business logic via Groovy scripts that modify standard functionality. These scripts are configuration artifacts, not data records—they are not included in standard CSV exports or API bulk reads. We cannot migrate Groovy logic automatically. We catalog every active Groovy script during scoping, export its logic as text, and flag for manual reimplementation at the destination or replacement with native platform features.

  • ERP_ID on Price Items may be hidden but is critical

    The ERP_ID column on Zilliant CPQ Price Item rows has a UI ID that can be hidden system-wide or per-role via UI Profiles. Migration tooling that reads visible columns only will miss ERP cross-references. We explicitly query hidden column data during extraction to preserve the ERP mapping layer that downstream order-fulfillment systems depend on. If the ERP_ID is absent, we flag it in the scoping report before extraction begins.

  • Twenty standard field set requires significant pre-work before import

    Twenty CRM's standard field set is minimal. An open GitHub issue documents that new users must spend 30-60 minutes creating basic fields before they can start using the CRM, and that third-party integrations expecting standard fields fail because those fields do not exist by default. We cannot import Zilliant data into Twenty until every custom object and custom field has been created in Settings → Data Model. This pre-work is scoped as part of the schema design phase and adds to the overall migration timeline.

  • BDA list-type fields lose C4C localization on transfer

    Custom BDA fields mapped from SAP C4C store only the raw list code value in Zilliant CPQ—C4C's localized display labels are not synced. When these BDAs migrate to Twenty custom fields, only the code value transfers. We flag every BDA field with list-type data during migration scoping and advise customers that translated labels will need to be re-established from C4C source records post-migration. This is particularly relevant for multi-language deployments.

Migration approach

Six steps for a successful Zilliant CPQ to Twenty CRM data migration

  1. Discovery and Zilliant environment audit

    We audit the source Zilliant CPQ environment: Products and variant configuration models, Quote volumes and line-item complexity, Price List hierarchies and price type distribution, active Sales Agreements and tier structures, BDA field definitions with their C4C lookup table references, active Groovy scripts and their business function, ERP_ID column visibility settings, and user accounts with role-based UI Profiles. We also assess whether the customer has already decoupled Zilliant from their ERP, which simplifies the migration scope. The discovery output is a written migration scope document with record counts per object, custom field inventory, and a pre-work checklist for Twenty schema creation.

  2. Twenty custom object and field schema design

    We design the destination schema in Twenty CRM before any data import. This includes creating the Products custom object with variant configuration fields, creating the Quote Line Items custom object with a parent Opportunity lookup, creating the Price Lists custom object, creating the Sales Agreements custom object, and adding all custom fields required to hold Zilliant pricing data (list price, agreement price, matrix price, override price, ERP_ID). We map BDA fields to custom fields on Company and People. We create any custom picklists required for Quote status, agreement tier levels, and product categories. Per Twenty's documentation, all fields must exist before CSV import begins—this is a hard prerequisite we enforce.

  3. Twenty workspace preparation and member provisioning

    We coordinate with the customer's admin to provision all Twenty workspace Members corresponding to Zilliant CPQ Owners before record import begins. Per Twenty's migration documentation, owner references in imported records cannot resolve if the referenced user does not exist in the workspace. Any Zilliant Owner without a matching Twenty Member goes to a reconciliation queue. We also set up any required custom object visibility permissions so that imported records are accessible to the appropriate team members.

  4. Sandbox migration and reconciliation

    We run a full migration into a Twenty Sandbox environment (or a staging copy) using production-like data volumes. The customer's team reconciles record counts against the Zilliant source, spot-checks 25-50 random records, and validates that Quote-to-Opportunity mappings, Product-to-Custom-Object mappings, and BDA custom field values match the source. Any mapping corrections happen here, not in production. This phase also validates that Twenty's import row-size limits and character encoding handle the Zilliant export format correctly.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Companies (from Zilliant Accounts), People (from Zilliant Contacts with Company linkage resolved), Products custom object (from Zilliant Products with ERP_ID preserved), Price Lists custom object, Opportunities (from Zilliant Quotes with status, dates, and totals), Quote Line Items (with parent Opportunity lookup resolved), Sales Agreements custom object, BDA custom fields (with localization loss flagged), and Notes and Attachments. Each phase emits a row-count reconciliation report before the next phase begins. Guided Selling rules are exported as a structured JSON and Markdown package during this phase and delivered as a separate documentation artifact.

  6. Cutover, validation, and Groovy/rule handoff

    We freeze Zilliant CPQ writes during cutover, run a final delta migration of any records modified during the migration window, then enable Twenty CRM as the system of record. We deliver the Groovy script inventory and Guided Selling rule package as written documentation for the customer's technical team to recreate in the destination. We support a one-week hypercare window where we resolve any reconciliation issues. We do not rebuild automations, workflows, or pricing rules as part of the standard migration scope.

Platform deep dives

Context on both ends of the pair

Zilliant CPQ logo

Zilliant CPQ

Source

Strengths

  • Variant configuration models for complex manufactured products are purpose-built and accessible to sales teams without engineering involvement
  • Real-time pricing calculations and dynamic cost estimations eliminate manual quote math errors
  • Guided selling flows steer reps toward margin-positive configurations automatically
  • Salesforce CPQ and SAP integrations are natively supported with documented connector endpoints
  • Product modeling supports characteristic-based rules for assemble-to-order and engineer-to-order workflows

Weaknesses

  • Performance degradation on complex operations with many line items is a documented user complaint
  • Configuration-to-pricing lag creates quote turnaround friction in fast sales cycles
  • Heavy reliance on Groovy scripting for custom logic means bespoke workflows do not export cleanly
  • BDA custom-field architecture between C4C and CPQ introduces localization loss on list-type fields
  • No publicly documented API rate limits or bulk-export mechanism in available documentation
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 Zilliant CPQ 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

    Zilliant CPQ: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

Walk through your Zilliant CPQ 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 four and eight weeks for accounts with under 5,000 Products, 2,000 Quotes, and 3,000 Accounts and Contacts with no complex BDA cross-references. Migrations involving complex variant-configuration product hierarchies, multi-tier Sales Agreement structures, large Quote histories with detailed line-item breakdowns, or BDA fields with C4C localization dependencies extend to ten to sixteen weeks because of custom object schema design, pricing field decomposition, and Groovy logic documentation. The Twenty schema design phase (creating all custom objects and fields before import) adds two to four weeks that must happen before any data import begins.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Zilliant CPQ.
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