CRM migration
Field-level mapping, validation, and rollback between Cordial and Nutshell. We move data and schema; workflows are rebuilt natively in Nutshell.
Cordial
Source
Nutshell
Destination
Compatibility
4 of 8
objects map 1:1 between Cordial and Nutshell.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Cordial to Nutshell is a migration from an enterprise marketing messaging platform to a sales-focused CRM built for small and mid-market teams. Cordial organizes contact data as flexible JSON attributes with dynamic segmentation and behavioral event tracking, while Nutshell uses a structured schema with People, Companies, Deals, and Activities as first-class objects. We extract all standard and custom contact attributes from Cordial's collections, normalize array-type properties (tags, preferences, behavioral arrays) into delimited strings or separate lookup tables compatible with Nutshell's field types, and map product variant records into one product row per SKU. Cordial's Programs and automation sequences are not API-exportable and must be rebuilt manually in Nutshell. We deliver a written Program inventory documenting every active automation trigger, condition, and action for the customer's admin to reference during rebuild. Segment definitions migrate as rule summaries and tag-based flags rather than as live dynamic filters.
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 Cordial object lands in Nutshell, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Cordial
Contact
Nutshell
Person
1:1Cordial Contact records map to Nutshell People. We export all standard fields (email, first_name, last_name, phone) plus every custom contact attribute stored on the contact. Cordial's flexible JSON attribute schema requires type inference (string, number, boolean) and mapping to Nutshell's custom field types via the custom_fields configuration. Array-type attributes (tags, behavioral lists, preference arrays) are normalized to delimited strings or held in a separate lookup table for reconciliation with the customer before import.
Cordial
Contact Attributes (Custom Fields)
Nutshell
Person Custom Fields
lossyCordial unlimited custom contact attributes map to Nutshell custom fields on the Person object. During discovery we export the full attribute key list, infer data types, and configure matching field types in Nutshell before migration. Array-type attributes require a normalization decision (delimited string vs lookup table) agreed upon with the customer. Fields that cannot map to any Nutshell field type are flagged for manual review.
Cordial
List
Nutshell
Person Tag or Custom Field
1:manyCordial Lists store static contact memberships as boolean flags or separate membership records. We export list membership per contact and map each list to a Nutshell Person Tag. Contacts belonging to multiple lists receive multiple tags. If the customer prefers a field-based approach, we create a multi-select custom field with list names as picklist values instead.
Cordial
Products (with variants)
Nutshell
Product
1:manyCordial Products store variants as nested JSON arrays under a single product record. Nutshell's product model has no native variant concept. We unpack each variant (color, size, SKU) into a separate Product row, preserving the parent product ID as a custom reference field (parent_product_id__c) to maintain the relationship. Product name, price, and SKU map directly from Cordial fields to Nutshell Product fields.
Cordial
Channel Preferences
Nutshell
Person Preferences
1:1Cordial Channels (email, SMS, push) store opt-in status and preference data as sub-attributes on contacts. We export channel preferences as separate boolean fields (email_opt_in, sms_opt_in) and map them to Nutshell Person contact preferences. Any non-standard channel types (WhatsApp, voice) are flagged for manual mapping with the customer.
Cordial
Events / Contact Activities
Nutshell
Activity (Call, Email, Meeting, Task)
1:1Cordial behavioral events (opens, clicks, purchases, custom events) map to Nutshell Activity records. Standard event types (email_open, email_click, purchase) are mapped to their nearest Nutshell Activity equivalent (Email, Task). Custom event types are mapped to Task records with a custom event_type field preserving the original Cordial event name. Event timestamps migrate as Activity dates for timeline ordering. Large event volumes (over 200,000 records) are chunked and batched to respect API rate limits.
Cordial
Orders
Nutshell
Deal Line Items or Custom Fields
1:1Orders are not a native first-class object in Cordial; they are stored as custom attributes or linked via event data. We identify order-related attributes and custom event types during schema discovery, then map order data to Deal Line Items in Nutshell if the customer uses Deals, or to a custom order object if Deals are not the primary workflow. Order totals, dates, and product references are preserved as custom fields on the target record.
Cordial
Segments / Audiences
Nutshell
Person Tags + Custom Field Flags
lossyCordial Segments are dynamic rule-based audiences that evaluate in real time against contact attributes. Nutshell does not have a live segment engine. We export segment definitions as rule summaries (a text description of the segment criteria) and flag which contacts currently match each segment using tag-based flags on the Person record. The customer can use Nutshell's static lists and tags for manual segmentation post-migration.
| Cordial | Nutshell | Compatibility | |
|---|---|---|---|
| Contact | Person1:1 | Fully supported | |
| Contact Attributes (Custom Fields) | Person Custom Fieldslossy | Fully supported | |
| List | Person Tag or Custom Field1:many | Fully supported | |
| Products (with variants) | Product1:many | Fully supported | |
| Channel Preferences | Person Preferences1:1 | Fully supported | |
| Events / Contact Activities | Activity (Call, Email, Meeting, Task)1:1 | Mapping required | |
| Orders | Deal Line Items or Custom Fields1:1 | Mapping required | |
| Segments / Audiences | Person Tags + Custom Field Flagslossy | Mapping required |
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.
Cordial gotchas
Message experiment results are not API-exportable
Rate limits are method- and endpoint-specific
Custom contact attribute arrays require schema normalization
Products collection uses nested JSON with variants
Nutshell gotchas
Contact tier limits enforced on import
No bulk API endpoint requires paginated extraction
Email sequences not exportable via API
Foundation plan disables key sales features
Pair-specific challenges
Migration approach
Discovery and schema audit
We audit the Cordial account across collections (Contacts, Products, Channels), custom attribute schemas, list definitions, active Programs, and behavioral event types. We map the full attribute inventory to Nutshell field types and identify any Cordial data that has no direct Nutshell equivalent (arrays, variant nesting, custom event types). The discovery output is a written migration scope with a field-level mapping table and a list of data requiring normalization decisions from the customer.
Normalization strategy and customer agreement
We present the normalization strategy for array-type attributes, variant unpacking, and order data handling. The customer confirms the approach for each flagged field. We configure Nutshell custom fields to match the agreed schema before any data export begins. This step prevents import failures due to field type mismatches.
Sample migration and reconciliation
We run a sample migration importing a representative subset of contacts (typically 50-100 records) into Nutshell to validate field mapping, custom field creation, and normalization output. The customer reviews the sample records against the Cordial source and confirms mapping accuracy. Any corrections are applied to the migration configuration before the full migration proceeds.
Contact and list migration
We export all Cordial Contacts with their standard and custom attributes, normalize array-type fields, and import into Nutshell People. List memberships are mapped to Person Tags or custom field flags based on the agreed strategy. We run deduplication checks against email addresses before import and flag duplicates for customer resolution.
Product and activity migration
We unpack Cordial product variants into separate Nutshell product rows with parent product references preserved. Behavioral events and contact activities are exported in batches, mapped to Nutshell Activity records, and imported with timestamps preserved for timeline accuracy. Order data is mapped to Deal Line Items or custom fields depending on the customer's Nutshell workflow.
Cutover, validation, and Program handoff
We freeze Cordial writes during cutover, run a final delta migration of any records modified during the migration window, then enable Nutshell as the system of record. We deliver the Program inventory document to the customer's admin team with recommended Nutshell equivalents for each automation. We support a brief post-migration validation window where the customer spot-checks migrated records and flags any reconciliation issues for resolution.
Platform deep dives
Cordial
Source
Strengths
Weaknesses
Nutshell
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 Cordial and Nutshell.
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
Cordial: Method- and endpoint-specific limits; default limits vary per tier; X-Rate-Limit-* response headers exposed; Retry-After header for backoff; limits are customizable per customer contract.
Data volume sensitivity
Cordial exposes a bulk API — large-volume migrations stream efficiently.
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 Cordial to Nutshell migration scoping. Not seeing yours? Book a call.
Walk through your Cordial to Nutshell migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Cordial
Other ways to arrive at Nutshell
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.