CRM migration
Field-level mapping, validation, and rollback between Agillic and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Agillic
Source
Twenty CRM
Destination
Compatibility
10 of 12
objects map 1:1 between Agillic and Twenty CRM.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Moving from Agillic to Twenty CRM is a structural migration from a Nordic omnichannel marketing automation platform to a modern open-source CRM. Agillic organises data around Recipients with fully custom schemas; Twenty CRM uses Contacts, Companies, and Opportunities with a defined field model. The primary migration challenge is schema enumeration — each Agillic client's recipient property set is unique, and we cannot begin mapping until every active property is captured via the Recipient API or Recipients Export. Activity records (sends, opens, clicks, SMS, events) carry a Flow Execution ID when enabled, which we preserve to allow matching activity records back to specific campaign runs. Agillic Flows (campaign automation) are not exportable as portable definitions; we document every Flow and deliver a written sequence plan for rebuilding in Twenty. We do not migrate Workflows or Forms as code — those require reimplementation in Twenty's interface after migration.
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 Agillic 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.
Agillic
Recipient
Twenty CRM
Contact
1:1Agillic Recipients map directly to Twenty CRM Contacts. The Recipient's email address is the primary dedupe key and maps to Contact.email. All standard recipient fields (first name, last name, phone, address) map to their Twenty CRM equivalents. Each client's custom recipient properties require enumeration before mapping — we extract the full property list via the Recipient API and create matching custom fields in Twenty CRM before import.
Agillic
Recipient
Twenty CRM
Person (in Company context)
1:1Agillic Recipients linked to a company context map to a Twenty CRM Person record associated with a Company record. We resolve the company association by extracting any company identifier from the Recipient's custom properties or Global Data Table joins and linking to the Company record during import.
Agillic
Global Data Table
Twenty CRM
Custom Object
1:manyAgillic Global Data Tables are custom relational structures referenced within Flows. We export table schemas and all row data. Each table maps to a Twenty CRM Custom Object. Table rows import as Custom Object records with lookup relationships to the relevant Contact, Company, or Opportunity where the join logic is resolvable from the source data.
Agillic
Activity: Send
Twenty CRM
Task (type: email_sent)
1:1Agillic Activity records of type send (email sends, SMS sends) map to Twenty CRM Tasks with the activity type recorded. The original send timestamp becomes the Task due date or activity date. The Flow Execution ID is preserved as a custom field for audit trail when enabled in Agillic's export settings.
Agillic
Activity: Open
Twenty CRM
Task (type: email_opened)
1:1Agillic Activity records of type open map to Twenty CRM Activity timeline entries. The open timestamp preserves the engagement date. Multiple opens per email generate multiple activity entries, each with the original timestamp.
Agillic
Activity: Click
Twenty CRM
Task (type: email_clicked)
1:1Agillic Activity records of type click map to Twenty CRM Activity timeline entries with the clicked URL preserved in a custom field if Twenty CRM supports it, or as a text note on the activity record. The click timestamp is preserved.
Agillic
Activity: Bounce
Twenty CRM
Task (type: email_bounced)
1:1Agillic bounce Activity records map to Twenty CRM Activity timeline entries with bounce type (hard/soft) and bounce reason preserved. Bounce records flag the Contact's email validity and can trigger an email verification workflow in Twenty post-migration.
Agillic
Activity: SMS Delivery
Twenty CRM
Task (type: sms_sent)
1:1Agillic SMS delivery Activity records map to Twenty CRM Tasks. Delivery status (delivered, failed, undelivered) migrates as a custom field or task status. SMS content migrates as a note attached to the activity record.
Agillic
Activity: Event
Twenty CRM
Task (type: custom_event)
1:1Agillic custom event Activity records (triggered events, behavioural events, point-of-sale events) map to Twenty CRM Tasks with the event type preserved in a custom field and event metadata stored as a text note. We flag these for manual verification post-migration because event taxonomy varies per Agillic client configuration.
Agillic
Flow Execution History
Twenty CRM
Custom Field or Tag
1:1The Flow Execution ID (when enabled in Agillic's Activity Export settings) is preserved as a custom field on the Activity record or as a Tag in Twenty CRM. This enables matching activity records back to specific campaign runs without native Flow integration in the destination platform.
Agillic
Profile
Twenty CRM
Contact (enriched)
1:1Agillic Profiles aggregate all known data about a Recipient across touchpoints. We treat Profile data as equivalent to a Contact record enriched with attributes from Activity and Global Data Table joins. All enriched attributes map to Twenty CRM Contact custom fields.
Agillic
Audience Data (Google/Meta)
Twenty CRM
Segment or Tag
lossyAgillic audience segments exported to Google and Meta are documented as Segment definitions. We capture the segment membership criteria and recreate them as Tags or Groups in Twenty CRM. The actual audience sync requires rebuilding in Twenty's integrations or a third-party sync tool post-migration.
| Agillic | Twenty CRM | Compatibility | |
|---|---|---|---|
| Recipient | Contact1:1 | Fully supported | |
| Recipient | Person (in Company context)1:1 | Fully supported | |
| Global Data Table | Custom Object1:many | Fully supported | |
| Activity: Send | Task (type: email_sent)1:1 | Fully supported | |
| Activity: Open | Task (type: email_opened)1:1 | Fully supported | |
| Activity: Click | Task (type: email_clicked)1:1 | Fully supported | |
| Activity: Bounce | Task (type: email_bounced)1:1 | Fully supported | |
| Activity: SMS Delivery | Task (type: sms_sent)1:1 | Fully supported | |
| Activity: Event | Task (type: custom_event)1:1 | Fully supported | |
| Flow Execution History | Custom Field or Tag1:1 | Fully supported | |
| Profile | Contact (enriched)1:1 | Fully supported | |
| Audience Data (Google/Meta) | Segment or Taglossy | 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.
Agillic gotchas
Undocumented API rate limits complicate bulk migration planning
Fully custom schema requires mandatory field enumeration during discovery
Flows are not exportable as portable workflow definitions
Activity Export requires explicit Flow Execution ID enablement
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
Schema discovery and custom property enumeration
We extract the complete Agillic recipient property list via the Recipient API and cross-reference it against a Recipients Export snapshot. We also enumerate Global Data Table schemas, Flow names, and Activity event types present in the client's instance. This discovery output is a complete entity-relationship diagram and field inventory that we present to the customer for validation. No mapping begins until the customer confirms the schema is complete because missing properties discovered mid-migration require rework.
Twenty CRM schema design and custom field creation
We design the destination Twenty CRM schema based on the discovered Agillic property list. This includes creating custom fields on Contact (and Company and Opportunity where applicable) to match every active Agillic recipient property. We also design the custom object schema for Global Data Table mappings. Twenty CRM's custom field creation is done via the UI or API before any data import. We document every Agillic Flow as a sequence handoff item for the customer's rebuild.
Data extraction, cleansing, and validation
We extract Recipients via the Agillic REST API and Recipients Export, Activity data via Activity Export (with Flow Execution ID confirmed enabled), and Global Data Table rows. We run data quality checks: duplicate detection on email address, missing required fields (first name, last name), invalid email formats, and orphaned Activity records (Activities with no valid Recipient reference). We present a data quality report to the customer and resolve cleansing decisions (duplicate merge, field backfill, record exclusion) before any load into Twenty CRM.
Test migration and reconciliation
We run a test migration into a Twenty CRM staging or development environment using production-like data volume. The customer reconciles record counts (Contacts in, Companies in, Activity entries in), spot-checks 20-30 random records against the Agillic source, and validates that custom fields populated correctly. We correct any mapping errors and validate the Activity timeline ordering before running the production migration. This step is critical for Agillic migrations because the custom schema is unique per client and mapping errors are common on first pass.
Production migration in dependency order
We run production migration in record-dependency order: Companies first (the foundation for Contact-to-Company relationships), then Contacts (with email dedupe key validated and custom fields populated), then Activity history (Tasks linked to Contact records by email match), then Global Data Table rows mapped to custom objects (last because they may have lookups to Contacts or Companies). Each phase emits a row-count reconciliation report before the next phase begins. We freeze Agillic writes during the cutover window.
Cutover, validation, and Flow rebuild handoff
We run a final delta migration of any records modified during the cutover window, then enable Twenty CRM as the system of record. We deliver the Flow inventory document describing each Agillic Flow's trigger, conditions, and actions with recommended Twenty Sequences equivalents. File attachment gaps are documented for manual re-upload. We support a one-week hypercare window to resolve reconciliation issues. We do not rebuild Agillic Flows as Twenty Sequences inside the migration scope; that is a separate engagement or an internal admin task.
Platform deep dives
Agillic
Source
Strengths
Weaknesses
Twenty CRM
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 Agillic and Twenty CRM.
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
Agillic: Not publicly documented — limited per production instance per day.
Data volume sensitivity
Agillic 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 Agillic to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Agillic 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 Agillic
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.