CRM migration

Migrate from Cordial to Nutshell

Field-level mapping, validation, and rollback between Cordial and Nutshell. We move data and schema; workflows are rebuilt natively in Nutshell.

Cordial logo

Cordial

Source

Nutshell

Destination

Nutshell logo

Compatibility

50%

4 of 8

objects map 1:1 between Cordial and Nutshell.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Cordial logo

Cordial

What's pushing teams away

  • Some users report that complex reporting and advanced analytics require workarounds, with out-of-the-box dashboards feeling insufficient for deep performance analysis.
  • Scaling large contact databases can introduce latency in segment queries and campaign execution, particularly when audiences exceed several million records.
  • The drag-and-drop interface, while easy to use for basic campaigns, can become limiting when building sophisticated multi-step automation logic that requires more programmatic control.

Choosing

Nutshell logo

Nutshell

What's pulling them in

  • Lowest cost entry point among mid-market CRMs—Foundation plan starts at $13/user/month, making it accessible for teams validating CRM fit before committing.
  • Integrated sales automation and email sequencing on Pro plans without requiring a separate email marketing platform, per verified Capterra reviews.
  • Consistently praised for intuitive interface and fast onboarding, with case studies reporting 100% team adoption rates within initial deployment periods.
  • Strong customer support responsiveness cited across G2 reviews, with dedicated support tiers available on Enterprise plans.
  • Native integrations with WhatsApp, Facebook Messenger, Instagram, and Slack reduce reliance on third-party middleware for common communication channels.

Object mapping

How Cordial objects map to Nutshell

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

maps to

Nutshell

Person

1:1
Fully supported

Cordial 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)

maps to

Nutshell

Person Custom Fields

lossy
Fully supported

Cordial 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

maps to

Nutshell

Person Tag or Custom Field

1:many
Fully supported

Cordial 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)

maps to

Nutshell

Product

1:many
Fully supported

Cordial 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

maps to

Nutshell

Person Preferences

1:1
Fully supported

Cordial 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

maps to

Nutshell

Activity (Call, Email, Meeting, Task)

1:1
Mapping required

Cordial 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

maps to

Nutshell

Deal Line Items or Custom Fields

1:1
Mapping required

Orders 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

maps to

Nutshell

Person Tags + Custom Field Flags

lossy
Mapping required

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

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.

Cordial logo

Cordial gotchas

Medium

Message experiment results are not API-exportable

Medium

Rate limits are method- and endpoint-specific

Low

Custom contact attribute arrays require schema normalization

Low

Products collection uses nested JSON with variants

Nutshell logo

Nutshell gotchas

High

Contact tier limits enforced on import

Medium

No bulk API endpoint requires paginated extraction

Medium

Email sequences not exportable via API

Medium

Foundation plan disables key sales features

Pair-specific challenges

  • Cordial Program automation is not API-exportable

    Cordial's Programs (campaign automation sequences with triggers, delays, and actions) have no public export API. We cannot migrate automation logic programmatically. During scoping we document the active Program structure, trigger points, step logic, and success criteria. The customer receives a written Program inventory with a recommended Nutshell equivalent for each automation. Rebuilding Programs in Nutshell is an admin task or a separate implementation engagement. We flag this gap clearly before migration begins.

  • Array-type contact attributes require normalization strategy

    Cordial stores some contact properties as arrays (tags, favorite colors, behavioral history, preference lists). Nutshell's Person object does not natively support multi-value array fields. We normalize array attributes to delimited strings (pipe-separated or comma-separated) or separate them into a lookup table. We agree on the normalization strategy with the customer during discovery and flag any arrays that would lose semantic meaning when flattened.

  • Product variant unpacking changes product record count

    Cordial products with nested variants (one product record with multiple SKUs for colors, sizes) unpack into one Nutshell product row per SKU. A Cordial catalog with 200 products averaging 5 variants each becomes 1,000 Nutshell product rows. We discuss this with the customer during scoping, preserve the parent product ID as a custom reference field, and ensure the import batch size accommodates the inflated record count.

  • Message experiment results are not API-exportable from Cordial

    Cordial's Message Analytics Export API explicitly excludes experiment results for batch and automated messages. A/B test outcomes and multivariate test data cannot be pulled programmatically. We flag this gap during scoping and recommend exporting experiment data from the Cordial UI before migration cutover if historical test performance is required in the destination system.

Migration approach

Six steps for a successful Cordial to Nutshell data migration

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

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

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

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

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

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

Context on both ends of the pair

Cordial logo

Cordial

Source

Strengths

  • Flexible JSON-based data model accommodating unlimited custom contact attributes without schema migration overhead.
  • Drag-and-drop Sculpt block editor for rapid email production without requiring developer resources.
  • Product-centric architecture treating SKUs, variants, and catalog data as native objects for personalization.
  • AI agents introduced in 2026 for automated email production and data intelligence workflows.
  • SFTP, AWS S3, and Google Cloud Storage integration for automated data export workflows.

Weaknesses

  • Message experiment results are explicitly not available via the export API, requiring manual UI-based export for A/B test data.
  • Reporting and analytics dashboards are described as insufficient by some users for deep performance analysis, often requiring supplemental BI tooling.
  • Segment logic and automation workflows lack a public export API, making migration of campaign automation a manual rebuild exercise.
  • Order data is not a native first-class object, often stored as custom attributes or behavioral events, requiring careful schema discovery before migration.
Nutshell logo

Nutshell

Destination

Strengths

  • Simple, intuitive interface with minimal learning curve for sales teams new to CRM
  • Per-seat pricing is transparent and predictable, with annual billing reducing monthly cost
  • Full data export tool available for all account data including backups
  • Open JSON-RPC API allows programmatic access to all core objects
  • Native multichannel engagement (email, SMS, WhatsApp) without third-party add-ons for communication

Weaknesses

  • Reporting and analytics are considered weak, requiring manual Excel exports for detailed analysis
  • No bulk API endpoint—migration requires paginated API reads that must be rate-limited carefully
  • JSON-RPC API is less common than REST, requiring custom integration code compared to standard REST CRMs
  • Add-on costs (Forms, Nutshell IQ, Email Marketing) are per-company charges that stack on top of per-seat pricing
  • Feature restrictions on entry-level plans mean teams often need mid-tier to get basic automation

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 Cordial and Nutshell.

  • 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

    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

    A

    Cordial exposes a bulk API — large-volume migrations stream efficiently.

Estimator

Estimate your Cordial to Nutshell 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 Cordial to Nutshell data migrations

Answers to the questions buyers ask most during Cordial to Nutshell migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your Cordial to Nutshell migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most migrations land between three and five weeks for accounts under 15,000 contacts and 2,000 products without behavioral event history. Migrations with large engagement histories (over 200,000 event records), extensive custom attribute schemas, or product catalogs with hundreds of variant SKUs extend to six to ten weeks because of event normalization, variant unpacking, and multi-phase reconciliation testing.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Cordial.
Land in Nutshell, 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