CRM migration
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
Source
Twenty CRM
Destination
Compatibility
7 of 12
objects map 1:1 between Zilliant CPQ and Twenty CRM.
Complexity
BStandard
Timeline
4-8 weeks
Overview
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.
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 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
Twenty CRM
Company
1:1Zilliant 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
Twenty CRM
People
1:1Zilliant 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
Twenty CRM
Custom Object: Products
lossyZilliant 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
Twenty CRM
Opportunity
1:manyZilliant 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)
Twenty CRM
Custom Object: Quote Line Items
lossyZilliant 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
Twenty CRM
Custom Object: Price Lists
lossyZilliant 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
Twenty CRM
Custom fields on Product
1:manyZilliant 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
Twenty CRM
Custom Object: Sales Agreements
1:1Zilliant 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
Twenty CRM
Written documentation (no direct mapping)
1:1Zilliant 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)
Twenty CRM
Custom fields on Company or People
1:1Zilliant 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)
Twenty CRM
Twenty workspace Members
1:1Zilliant 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
Twenty CRM
Note
1:1Zilliant 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.
| Zilliant CPQ | Twenty CRM | Compatibility | |
|---|---|---|---|
| Account | Company1:1 | Fully supported | |
| Contact | People1:1 | Fully supported | |
| Product | Custom Object: Productslossy | Fully supported | |
| Quote | Opportunity1:many | Fully supported | |
| SalesItem (Quote line items) | Custom Object: Quote Line Itemslossy | Fully supported | |
| Price List | Custom Object: Price Listslossy | Fully supported | |
| Price Item | Custom fields on Product1:many | Fully supported | |
| Sales Agreement | Custom Object: Sales Agreements1:1 | Fully supported | |
| Guided Selling Rules | Written documentation (no direct mapping)1:1 | Mapping required | |
| Business Data Attributes (BDAs) | Custom fields on Company or People1:1 | Mapping required | |
| Owner (User) | Twenty workspace Members1:1 | Fully supported | |
| Attachment and Notes | Note1:1 | 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.
Zilliant CPQ gotchas
Groovy scripted logic does not export as data
ERP_ID column may be hidden but still critical
SAP characteristic labels can duplicate after legacy migration
BDA list-type fields lose C4C localization
Attachment downloads could fire multiple times on older builds
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 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.
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.
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.
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.
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.
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
Zilliant CPQ
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 3 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 Zilliant CPQ and Twenty CRM.
Object compatibility
3 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
Zilliant CPQ: Not publicly documented.
Data volume sensitivity
Zilliant CPQ 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 Zilliant CPQ to Twenty CRM migration scoping. Not seeing yours? Book a call.
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 consultationAdjacent paths
Other ways to leave Zilliant CPQ
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.