CRM migration
Field-level mapping, validation, and rollback between OctopusPro and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
OctopusPro
Source
Twenty CRM
Destination
Compatibility
9 of 14
objects map 1:1 between OctopusPro and Twenty CRM.
Complexity
BStandard
Timeline
4-8 weeks
Overview
OctopusPro is a field service management platform built around the booking lifecycle, with native objects for Jobs, Field Workers, Invoices, and Quotes that reflect a service-business data model. Twenty CRM is an open-source modern CRM built in TypeScript with a People, Companies, and Opportunities object model, and a Custom Object framework for domain-specific records. There is no direct one-to-one object mapping between these platforms: Bookings, Jobs, Field Workers, Services, and the operational data that powers OctopusPro's dispatch interface must be reconstructed in Twenty as Custom Objects with custom fields. We begin every migration by requesting a structured export from OctopusPro's support team, discovering the tenant-specific custom field schema, and designing the destination Custom Object schema in Twenty before any data moves. We do not migrate OctopusPro automations, the Customer Portal configuration, or GPS location history from the worker app as time-series records; these require rebuild or reconfiguration in Twenty post-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 OctopusPro 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.
OctopusPro
Customer
Twenty CRM
Person (People)
1:1OctopusPro Customer profiles (name, phone, email, address, notes) map directly to Twenty Person records. The primary email becomes the Twenty email field and serves as the dedupe key. Custom fields attached to the Customer profile in OctopusPro (vertical-specific data such as gate codes or pet health history) are migrated as Twenty custom fields on Person. The custom field schema is tenant-specific and must be requested from OctopusPro support during export discovery.
OctopusPro
Customer
Twenty CRM
Company
lossyIf OctopusPro Customer records include business entity data (company name separate from contact name), we create a Twenty Company record and link the Person as a relation (employee-of or contact-at). The mapping decision is confirmed during scoping by reviewing whether the OctopusPro export separates business and individual contact fields.
OctopusPro
Booking
Twenty CRM
Custom Object: Booking
lossyOctopusPro Bookings are the central object linking a Customer, Field Worker, Service, time slot, status, and Invoice. Twenty has no native booking or scheduling object, so we create a Booking Custom Object in Twenty with custom fields for customer (Person lookup), field worker (User lookup), service, scheduled date and time, status, and related invoice. Booking status history migrates as custom fields or as linked Task records if timeline tracking is needed.
OctopusPro
Job
Twenty CRM
Custom Object: Job or Task
1:manyOctopusPro Jobs are work order records that may exist independently of or alongside Bookings depending on the customer's workflow. We create a Job Custom Object in Twenty or, for simpler job tracking, use Task records with a custom job_reference__c field linking back to the parent Booking. Field-level job data (description, priority, tags, photos from forms) migrates as custom fields on the destination object. Form schema varies by service type; we flag any fields that require new custom field creation in Twenty during scoping.
OctopusPro
Field Worker
Twenty CRM
User
1:1OctopusPro Field Worker records (name, role, contact details, pay rate, location tracking preferences) map to Twenty User accounts. We resolve field workers by email match. GPS tracking preferences from the OctopusPro worker app are noted as custom fields in Twenty but do not activate live location sharing; that feature requires rebuild in Twenty using a third-party GPS integration.
OctopusPro
Invoice
Twenty CRM
Opportunity + Custom Fields
1:1OctopusPro Invoices (line items, tax, totals, payment status tied to a Booking) are reconstructed in Twenty as Opportunity records with custom fields capturing invoice_number__c, invoice_date__c, subtotal__c, tax_amount__c, total_amount__c, and payment_status__c. The Opportunity Stage maps to invoice payment status (Open, Won for paid, Closed Lost for written off). For businesses that need invoice documents, we attach the exported invoice PDF as a ContentDocument via ContentDocumentLink.
OctopusPro
Payment
Twenty CRM
Opportunity Activity (Task/Note)
1:1OctopusPro Payment records (amount, method, date, status against an Invoice) migrate as Task records linked to the parent Opportunity, with custom fields capturing payment_method__c, amount_paid__c, and payment_date__c. Partial payments and refunds are flagged as separate Task records with a payment_type__c custom field (full, partial, refund). This reconstructs the payment history against the Opportunity without requiring a native payment object in Twenty.
OctopusPro
Quote / Estimate
Twenty CRM
Opportunity
1:1OctopusPro Quotes (pre-booking documents with line items, validity dates, and accept/reject status) migrate to Twenty as Opportunities with a quote_status__c custom field (pending, accepted, rejected, expired) and validity_date__c. Line items from the Quote migrate as OpportunityLineItem records if the Twenty workspace has a Pricebook2 configured; otherwise, they are stored as custom fields or a Note attachment.
OctopusPro
Service
Twenty CRM
Custom Object: Service
lossyOctopusPro Service definitions (name, description, pricing rules, duration, service area) migrate as a Service Custom Object in Twenty. This provides a reference catalog that can be linked from Booking or Job Custom Object records. Service pricing rules that drive invoice line items are stored as custom fields on the Service object. We create the Service Custom Object in Twenty's Data Model before any Booking or Job import.
OctopusPro
Custom Fields
Twenty CRM
Custom Fields on relevant objects
lossyOctopusPro allows custom fields on Customer profiles and Bookings to capture vertical-specific data. We discover the custom field schema by requesting a field inventory from OctopusPro support alongside the export. Each custom field is typed (text, number, date, picklist) and mapped to the corresponding Twenty object and field type. Custom fields that do not map directly (e.g., multi-checkbox in OctopusPro to multi-select picklist in Twenty) are flagged for transformation during scoping.
OctopusPro
Forms & Checklists
Twenty CRM
Custom Object: Form Record
1:1OctopusPro Forms and checklists capture structured field data at the job level (photos, tags, intake information). The form schema varies by service. We migrate available field data as custom fields on the Job or Booking Custom Object, with the raw form output stored as a Note attachment if the data does not fit a structured custom field. Any form field requiring a new custom field in Twenty is added to the Data Model before migration runs.
OctopusPro
Customer Portal
Twenty CRM
None
1:1The OctopusPro Customer Portal is a configuration layer for self-booking, invoice viewing, and FAQ access. Portal settings, permission flags, and branded theme configurations do not migrate as data objects. We document the active portal features during scoping so the customer can configure equivalent functionality in Twenty or via a separate customer-facing tool post-migration.
OctopusPro
Automations
Twenty CRM
None
1:1OctopusPro Automations define trigger-action workflows for scheduling, notifications, and status changes. Twenty supports workflow automation from its Pro plan. We capture automation rules during scoping as part of the written inventory delivered to the customer. Automation logic is not migrated as code; the customer's admin rebuilds the relevant triggers in Twenty's workflow builder post-migration.
OctopusPro
FAQs
Twenty CRM
Note or Custom Field on Service
1:1OctopusPro service-level FAQs are linked to specific Services and appear in the customer portal and email templates. FAQ content and service associations migrate as Note records linked to the corresponding Service Custom Object in Twenty, or as a long-text custom field on the Service object. Display configuration (portal placement, email inclusion) must be reconfigured in Twenty manually after migration.
| OctopusPro | Twenty CRM | Compatibility | |
|---|---|---|---|
| Customer | Person (People)1:1 | Fully supported | |
| Customer | Companylossy | Fully supported | |
| Booking | Custom Object: Bookinglossy | Fully supported | |
| Job | Custom Object: Job or Task1:many | Fully supported | |
| Field Worker | User1:1 | Fully supported | |
| Invoice | Opportunity + Custom Fields1:1 | Fully supported | |
| Payment | Opportunity Activity (Task/Note)1:1 | Fully supported | |
| Quote / Estimate | Opportunity1:1 | Fully supported | |
| Service | Custom Object: Servicelossy | Fully supported | |
| Custom Fields | Custom Fields on relevant objectslossy | Mapping required | |
| Forms & Checklists | Custom Object: Form Record1:1 | Mapping required | |
| Customer Portal | None1:1 | Not supported | |
| Automations | None1:1 | Mapping required | |
| FAQs | Note or Custom Field on Service1:1 | 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.
OctopusPro gotchas
Booking Fee vs Commission billing model affects migration cost estimates
Incorrect charges and billing disputes are documented in reviews
No documented public API or bulk export mechanism
Customer Portal settings do not migrate independently
Custom field schema is tenant-specific and must be discovered before mapping
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
Scoped export request from OctopusPro
We open a structured export request with OctopusPro support on the customer's behalf, requesting CSV or JSON exports of Customers, Bookings, Field Workers, Invoices, Payments, Quotes, Services, Forms, and Custom Fields. We simultaneously request a full custom field inventory so we can map tenant-specific fields to Twenty custom fields during scoping. We recommend the customer authorize this request at the earliest opportunity because OctopusPro's support response time is outside our control and can add one to three weeks to the project timeline.
Twenty workspace setup and custom object schema design
While waiting for the OctopusPro export, we set up the Twenty workspace. We create the Custom Objects required to model the booking lifecycle: Booking, Job, and Service Custom Objects with all necessary custom fields for status, GPS coordinates (as text), payment terms, and form data. We configure the Twenty Data Model (Settings > Data Model) for each Custom Object, define custom fields on Person for customer-specific data, and add Opportunity custom fields for invoice reconstruction. We invite all team members before importing so that Owner lookups are satisfied at migration time.
Data cleansing and field mapping document
When the OctopusPro export files arrive, we profile the data for completeness, duplicates, and formatting inconsistencies. We clean duplicate customer records (keeping the most complete), standardize phone number formats, and resolve partial addresses before mapping. We produce a written field mapping document that assigns each OctopusPro field to a Twenty field or custom field, noting any type transformations (date formats, picklist values, multi-checkbox to multi-select picklist). The mapping document is reviewed and signed off by the customer before any import begins.
Sandbox migration and reconciliation
We run a full migration into Twenty's sandbox environment using production-like data volume. The customer reconciles record counts (People, Companies, Bookings, Jobs, Invoices, Payments) against the OctopusPro source, spot-checks 25-50 records for field-level accuracy, and validates that lookup relationships (Booking to Customer, Job to Field Worker) resolved correctly. Any mapping corrections are documented and applied before the production migration runs.
Production migration in dependency order
We run production migration in record-dependency order: Person records (from Customers), Company records (where applicable), Service Custom Object (referenced by Bookings), Booking Custom Object (with customer and field worker lookups resolved), Job Custom Object (linked to Booking), Opportunities (with invoice custom fields populated from Invoice records), Task records (from Payments), and finally any remaining Custom Object records. Each phase emits a row-count reconciliation report. We use Twenty's CSV import for standard objects and the REST or GraphQL API for Custom Objects with per-record validation checks.
Cutover, validation, and automations handoff
We coordinate the cutover window: final writes to OctopusPro are frozen, any records modified during the migration window are migrated as a delta pass, then Twenty is enabled as the system of record. We validate record counts and spot-check relationships in production. We deliver the automation inventory document (Captured from OctopusPro scoping) to the customer with a written note on each automation requiring rebuild in Twenty's workflow builder. We offer a one-week hypercare window for reconciliation issues. We do not rebuild OctopusPro automations as Twenty workflows within the migration scope.
Platform deep dives
OctopusPro
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 OctopusPro 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
OctopusPro: Not publicly documented.
Data volume sensitivity
OctopusPro 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 OctopusPro to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your OctopusPro 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 OctopusPro
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.