CRM migration
Field-level mapping, validation, and rollback between CRM Runner and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
CRM Runner
Source
Twenty CRM
Destination
Compatibility
8 of 12
objects map 1:1 between CRM Runner and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from CRM Runner to Twenty CRM is a platform-type transition as much as a data migration. CRM Runner bundles field-service operations (Jobs, Team Members, GPS tracking, dispatch) with CRM primitives; Twenty CRM is a self-hosted, open-source sales CRM with a Company-People-Opportunity model and no built-in field-service primitives. We map CRM Runner Contacts to Twenty People, Companies to Companies, and Jobs to Opportunities, but we flag that Jobs include time entries, location data, and team assignments that do not map to a standard Twenty CRM object. Team Members map to Twenty workspace Members, but CRM Runner role and permission levels require manual rebuild in Twenty. Communications history (calls, SMS, in-app chat) migrates as Note records attached to the People record. We do not migrate IFTTT automations, payments, or the digital catalog; these are documented separately for your admin to handle. The lack of a documented API on CRM Runner means extraction is UI-assisted rather than programmatic, which extends scoping timelines but does not prevent 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 CRM Runner 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.
CRM Runner
Contact
Twenty CRM
People
1:1CRM Runner Contacts map directly to Twenty CRM People. The CRM Runner contact record (name, email, phone, address, and any custom fields) migrates as a People record. Email becomes the dedupe key during import. CRM Runner custom fields on contacts pre-exist in Twenty as custom fields on the People object. If CRM Runner contacts are linked to a Company record, we preserve the link by resolving the company name to the Twenty CRM Company record via the CRM Runner company_id foreign key.
CRM Runner
Company
Twenty CRM
Company
1:1CRM Runner Company records map 1:1 to Twenty CRM Company. The CRM Runner domain field (if present) becomes the Twenty CRM website field. Company name is the dedupe key. Company records must import before People records so that the People-to-Company relationship is satisfied at the moment of People insert. Any CRM Runner custom fields on Company migrate as Twenty CRM custom fields created under Settings Data Model before import.
CRM Runner
Job
Twenty CRM
Opportunity
1:manyCRM Runner Jobs are the most complex migration object because they combine field-service work order data (location, assigned team members, status, time entries) with what functions as a deal record in a sales CRM. We map Jobs to Twenty CRM Opportunity with the CRM Runner job title becoming the Opportunity name, job status mapped to Opportunity stage values, and estimated or actual amounts carried as Opportunity amount fields. The location and assigned team member data does not have a native Twenty CRM equivalent; we preserve these as Note records attached to the Opportunity and flag them for manual rebuild if they drive workflow logic.
CRM Runner
Team Member
Twenty CRM
WorkspaceMember
1:1CRM Runner Team Members map to Twenty CRM Workspace Members. We extract role, department, and permission level from CRM Runner and migrate these to Twenty CRM member roles under Settings Members. CRM Runner GPS tracking and time-clock features have no equivalent in Twenty CRM; we export this as a separate data package and flag it as outside CRM scope. Permission level rebuild is manual because Twenty CRM's role permissions are structured differently from CRM Runner's permission tiers.
CRM Runner
Communications (Calls, SMS, Chat)
Twenty CRM
Note
1:manyCRM Runner embeds call logs, SMS threads, and in-app chat as discrete communication records attached to contacts or jobs. We flatten these into Note records in Twenty CRM, one Note per communication event. The Note body carries the communication type (call/SMS/chat), timestamp, direction (inbound/outbound), and content. We link each Note to the corresponding People record in Twenty CRM. This loses CRM Runner's threading model for SMS but preserves the full communication history in an accessible format.
CRM Runner
Task
Twenty CRM
Task
1:1CRM Runner Tasks migrate directly to Twenty CRM Task records. Due date, assignee (resolved via Team Member mapping), status, and description carry over. Task assignment in Twenty CRM uses the WorkspaceMember lookup; we resolve CRM Runner assignee references via the Team Member mapping to ensure the assignee is a valid Twenty CRM WorkspaceMember at migration time.
CRM Runner
Time Entry
Twenty CRM
(External Export Package)
1:1CRM Runner time entries (clock-in/clock-out records tied to Team Members and Jobs) do not map to a standard Twenty CRM object. Twenty CRM has no time-tracking module. We export time entries as a separate CSV package with fields for employee, job reference, date, clock-in time, clock-out time, and duration. This package is delivered alongside the main migration for import into a dedicated time-tracking or payroll tool.
CRM Runner
Pipeline
Twenty CRM
Opportunity Stage
lossyCRM Runner pipeline stages migrate as Twenty CRM Opportunity stage values. We capture the stage name, order, and probability percentage from CRM Runner and configure the corresponding stage in Twenty CRM under Settings Opportunities before migration. Custom stage logic (conditional routing, auto-close rules) does not migrate and is documented for manual rebuild.
CRM Runner
Custom Field (Contacts, Companies, Jobs)
Twenty CRM
Custom Field (People, Company, Opportunity)
lossyCRM Runner custom fields on Contacts, Companies, and Jobs require pre-creation in Twenty CRM before data import. We extract all custom field definitions during scoping (field name, type, options for picklists, required vs optional), create the equivalent Twenty CRM custom fields under Settings Data Model before migration begins, and map the source field values during the import phase. Fields with no equivalent type in Twenty CRM (e.g., CRM Runner-specific field-service field types) are flagged for review.
CRM Runner
Payment / Transaction
Twenty CRM
(External Export Package)
1:1CRM Runner payment and transaction records are embedded within Jobs or Contacts and are accounting-adjacent. Twenty CRM has no native payment or accounting module. We extract payment records as a separate CSV package with fields for customer, job reference, amount, payment method, date, and status. This package is delivered alongside the main migration for import into a dedicated accounting or bookkeeping tool.
CRM Runner
IFTTT Automation
Twenty CRM
(Written Specification Document)
1:1CRM Runner IFTTT-style automations are not migratable. The platform's trigger-action logic is configured through a proprietary interface with no documented export path. We document every active automation we identify during discovery as a written specification: trigger type, conditions, actions, and recommended Twenty CRM equivalent (manual action or workflow rule if applicable). The customer's admin uses this document to rebuild automations post-migration. This is not included in the standard migration timeline.
CRM Runner
Digital Catalog / QR Codes
Twenty CRM
(Not Migrated)
1:1CRM Runner product catalog entries and QR code configurations are platform-specific display assets with no standard CRM equivalent in Twenty CRM. These must be rebuilt in Twenty CRM or a separate product management tool. We do not include them in the migration scope.
| CRM Runner | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact | People1:1 | Fully supported | |
| Company | Company1:1 | Fully supported | |
| Job | Opportunity1:many | Fully supported | |
| Team Member | WorkspaceMember1:1 | Fully supported | |
| Communications (Calls, SMS, Chat) | Note1:many | Mapping required | |
| Task | Task1:1 | Fully supported | |
| Time Entry | (External Export Package)1:1 | Fully supported | |
| Pipeline | Opportunity Stagelossy | Fully supported | |
| Custom Field (Contacts, Companies, Jobs) | Custom Field (People, Company, Opportunity)lossy | Fully supported | |
| Payment / Transaction | (External Export Package)1:1 | Fully supported | |
| IFTTT Automation | (Written Specification Document)1:1 | Fully supported | |
| Digital Catalog / QR Codes | (Not Migrated)1:1 | Not 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.
CRM Runner gotchas
No free trial and immediate billing on subscription
No publicly documented API or export endpoints
IFTTT automations must be manually rebuilt post-migration
Time entries and payment data require separate export treatment
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 scoping
We conduct a structured discovery with the customer's CRM Runner instance, extracting all supported object types (Contacts, Companies, Jobs, Team Members, Tasks, Communications, Pipelines, Custom Fields) via UI-assisted methods. We document record counts, custom field definitions, pipeline stage names, active automations, and any embedded data (time entries, payments) that requires separate export treatment. We also assess data quality: duplicate records, outdated contacts, and test data that should be archived rather than migrated. The discovery output is a written migration scope and a data retention recommendation.
Target schema preparation in Twenty CRM
We create the destination schema in Twenty CRM before any data import. This includes creating custom fields on People, Company, and Opportunity to match CRM Runner's custom field definitions; configuring Opportunity stage values to match CRM Runner pipeline stages with probability percentages; setting up Twenty CRM Workspace Members and roles to match the CRM Runner Team Member structure; and creating any custom objects required for domain-specific records. Schema creation happens in the customer's Twenty CRM instance (Sandbox if available, Production if not). Fields must exist before import; we do not create fields during the import phase.
Data extraction and transformation
We extract data from CRM Runner in dependency order: Companies first (as the parent object for People), then People (with company linkage resolved via company name or CRM Runner company_id), then Team Members (as Workspace Members in Twenty), then Jobs (as Opportunities with field-service specifics extracted to Notes), then Tasks, then Communications (as Notes). Embedded time entries and payment records are extracted as separate CSV packages for payroll and accounting tools. We apply transformation rules during extraction: CRM Runner date formats normalized to ISO 8601, phone numbers stripped of formatting, custom picklist values mapped to Twenty CRM picklist options.
Import sequencing and reconciliation
We import into Twenty CRM in strict dependency order: Companies, then People (linked to Companies), then Workspace Members (Team Members), then Opportunities (Jobs linked to People and Workspace Members), then Tasks, then Notes (Communications). Each import phase emits a row-count reconciliation report. We validate 25-50 records per object against the CRM Runner source, checking field-level accuracy and relationship integrity. Corrections are applied to the transformation scripts before the next phase begins. Any unmapped fields are documented for review.
Parallel operation and cutover planning
We recommend running CRM Runner and Twenty CRM in parallel during the migration window. CRM Runner remains the system of record while data migrates; the team continues working in CRM Runner. During parallel operation, we coordinate a cutover date with the customer's admin, during which new records created in CRM Runner after the final migration delta are migrated to Twenty CRM before cutover. We recommend scheduling cutover during off-peak hours with a one-hour freeze window. CRM Runner can remain accessible read-only post-cutover for reference if needed.
Delivery and automation handoff
We deliver the migration artifacts: the Twenty CRM instance with all migrated records, a data quality report (record counts, duplicate summary, unmapped fields), separate export packages for time entries and payment records, and the written automation specification document for manual rebuild in Twenty CRM. We conduct a validation session with the customer's admin to spot-check migrated records and confirm relationship integrity. We do not rebuild CRM Runner automations as Twenty CRM workflow rules within the migration scope; that work is handled separately by the customer's admin or a Twenty CRM implementation partner.
Platform deep dives
CRM Runner
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 2 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 CRM Runner and Twenty CRM.
Object compatibility
2 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
CRM Runner: Not publicly documented.
Data volume sensitivity
CRM Runner 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 CRM Runner to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your CRM Runner 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 CRM Runner
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.