CRM migration
Field-level mapping, validation, and rollback between Markate and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
Markate
Source
Twenty CRM
Destination
Compatibility
6 of 11
objects map 1:1 between Markate and Twenty CRM.
Complexity
BStandard
Timeline
2-4 weeks
Overview
Moving from Markate to Twenty CRM is a structural migration from a field-service operations platform to an open-source CRM with a fundamentally different data model. Markate organizes work around Customers, Work Orders, Estimates, and Invoices for field service; Twenty CRM uses Companies, People, Opportunities, Tasks, and Custom Objects. We map Markate Work Orders to Twenty Tasks with custom field extensions to preserve job details, and we preserve Estimate line items by mapping Items and Categories to a custom catalog object before migrating linked records. The migration runs entirely over CSV files because Markate exposes no public REST API, which means we cannot use delta-sync or automated re-verification post-load. Every import step is validated in a staging run against a subset of records before the production import, because Markate's Data Migration tool cannot be reversed once submitted.
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 Markate 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.
Markate
Customer
Twenty CRM
Company + Person
1:manyMarkate Customers hold both company-level and contact-level data in a single record. We split each Customer into a Twenty Company record (for business name, address, and billing details) and a Twenty Person record (for the primary contact name, email, and phone). The Person is linked to the Company via the workspaceMember and personCompany relationships. We use the Customer email address as the dedupe key to avoid creating duplicate Person records when the same contact appears across multiple Markate records.
Markate
Customer Address
Twenty CRM
Company address fields
1:1Markate stores service address and billing address on the Customer record. We map the primary service address to the Twenty Company address fields (addressStreet, addressCity, addressState, addressCountry, addressPostcode). If Markate stores separate billing and service addresses, we capture both in address fields and note the billing address in a custom field billing_address__c created in Twenty before migration.
Markate
Estimate
Twenty CRM
Opportunity
1:1Markate Estimates map to Twenty Opportunities with a custom field estimate_status__c carrying the Markate estimate status (sent, accepted, declined). The estimated amount maps to Opportunity amount. We create a dedicated Opportunity Stage called 'Estimate' in Twenty's sales process before migration so that Estimate records appear as a distinct pipeline stage in reporting. If the customer uses multiple pipeline stages in Markate, we map each to a Twenty Opportunity stage configured in Settings.
Markate
Estimate Line Item
Twenty CRM
Custom Object: EstimateLineItem
1:manyMarkate Estimate line items reference Items from the catalog. We create a custom object EstimateLineItem in Twenty with fields for description, quantity, unit price, and total, and a lookup to the parent Opportunity (representing the Estimate) and the related Item. Items and Categories must be migrated first so that the Item reference is valid at line-item import time.
Markate
Work Order
Twenty CRM
Task + Custom Object: WorkOrder
lossyMarkate Work Orders are the job ticket entity with job details, assigned team members, and schedule information. We create a custom object WorkOrder in Twenty with fields for job description, scheduled date, assigned team member (lookup to Twenty User), status, and any Markate custom properties surfaced in the CSV. Work Order status maps to a custom picklist matching Markate's statuses. The Task object in Twenty handles assignment and due date for individual action items derived from Work Order tasks.
Markate
Invoice
Twenty CRM
Opportunity (closed) + Custom Fields
1:1Markate Invoices map to Twenty Opportunities with stage set to Closed Won and a custom field invoice_status__c holding the Markate payment status (paid, partial, outstanding). Invoice line items are migrated to the same EstimateLineItem custom object used for Estimates, linked to the closed Opportunity. Partial payment details are noted in custom fields invoice_amount_paid__c and invoice_amount_due__c.
Markate
Item
Twenty CRM
Custom Object: Product
1:1Markate Items (products and services) map to a custom object Product in Twenty since Twenty's standard Product2 object is oriented toward commerce and may not fit field-service pricing models. We create the Product custom object with fields for name, sku, description, unit_price, and unit_type. Items must be migrated before Invoices and Estimates so that line-item lookups resolve correctly.
Markate
Category
Twenty CRM
Custom Field or Picklist on Product
lossyMarkate Categories define groupings for Items. We map top-level categories to a custom picklist field category__c on the Product custom object. If the customer uses multi-level category hierarchies, we flatten them to a pipe-delimited string (e.g., 'HVAC | Repair | Compressor') and store in category_path__c. Category records without Items are flagged as orphans for the customer to review.
Markate
Expense
Twenty CRM
Note
1:1Markate Expenses track job-related costs linked to Work Orders or Customers. We migrate Expense records as Note records in Twenty linked via ContentDocumentLink to the related WorkOrder (custom object) or Company. The Note title carries the expense description and the Note body carries amount, vendor, and date. Receipt attachments are flagged as manual-upload items since Markate's Data Migration tool does not export files.
Markate
Team Member
Twenty CRM
User
1:1Markate Team Members are billable users assigned to Work Orders and Invoices. We map them to Twenty User records. The customer must invite all team members through Twenty Settings → Members before migration begins, per Twenty's requirement that referenced users exist before user-lookup fields can be populated. Team members without matching Twenty Users go to a reconciliation queue.
Markate
Custom Fields
Twenty CRM
Custom Object Fields
lossyMarkate does not expose custom field definitions via its CSV export, so any custom fields created by the customer in Markate are not visible in the exported data. We document this as a gap during scoping and work with the customer to identify which custom field values they need to preserve. Those values are re-entered or re-configured as custom fields on the relevant Twenty objects after migration. This is a manual step with no automated path.
| Markate | Twenty CRM | Compatibility | |
|---|---|---|---|
| Customer | Company + Person1:many | Fully supported | |
| Customer Address | Company address fields1:1 | Fully supported | |
| Estimate | Opportunity1:1 | Fully supported | |
| Estimate Line Item | Custom Object: EstimateLineItem1:many | Fully supported | |
| Work Order | Task + Custom Object: WorkOrderlossy | Fully supported | |
| Invoice | Opportunity (closed) + Custom Fields1:1 | Fully supported | |
| Item | Custom Object: Product1:1 | Fully supported | |
| Category | Custom Field or Picklist on Productlossy | Fully supported | |
| Expense | Note1:1 | Fully supported | |
| Team Member | User1:1 | Fully supported | |
| Custom Fields | Custom Object Fieldslossy | 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.
Markate gotchas
No duplicate checking during CSV import
Import cannot be reversed
Custom fields and attachments are excluded from exports
No public API for automated migration tooling
Support hours limited to business days only
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 data audit
We export CSV files for all Markate supported objects: Customers, Estimates, Work Orders, Invoices, Items, Categories, Expenses, and Team Members. We audit each CSV for field completeness, duplicate records, date format consistency, and orphaned lookups (e.g., line items referencing Items that do not exist). We document the attachment and custom field gaps and produce a manual-migration checklist for the customer. The discovery output is a written migration scope with record counts per object, a deduplication report, and a custom object and field specification for Twenty.
Twenty schema design
We create the destination schema in Twenty before any data is imported. This includes the WorkOrder custom object (with job details, status, and assignee fields), the Product custom object (with sku, description, and unit price), the EstimateLineItem custom object (with lookup to Opportunity and Product), and any additional custom fields on Company and Person needed to capture Markate address and contact details. We create a dedicated Opportunity Stage named 'Estimate' to distinguish quoted work from closed deals. The schema is validated in Twenty's staging environment before the production migration.
User provisioning and owner reconciliation
We extract every distinct Markate Team Member referenced on Work Orders, Invoices, and Estimates. We match each by email against the Twenty destination workspace's User table. Any Markate Team Member without a matching Twenty User goes to a reconciliation queue for the customer to provision. Migration cannot proceed past this step because Work Order assignee and Invoice owner lookups require a valid Twenty User reference. We confirm all required users are active and invited before record import begins.
Staging migration and reconciliation
We run a full migration into Twenty using the production data volume in a staging environment. The customer reconciles record counts per object (Customers in, Companies and People in, Work Orders in, Estimates and Invoices in, Items in), spot-checks 25-50 records against the Markate source, and reviews the custom object field values. The customer signs off the staging results before we schedule the production migration date. Any mapping corrections are applied to the production migration scripts at this stage.
Production migration in dependency order
We run production migration in record-dependency order: Categories (first, as parent to Items), Items (Products custom object), Customers (Companies and People split), Team Members (validated, already provisioned), Work Orders (WorkOrder custom object with assignee lookup), Estimates (Opportunities with Estimate stage and line items), Invoices (closed Opportunities with invoice status and line items), and Expenses (Notes linked to WorkOrder or Company). Each phase emits a row-count reconciliation report. We freeze Markate writes during the cutover window to prevent records from being created after the final export.
Cutover, validation, and manual handoff
We re-export Markate on cutover day to capture any records modified during the migration window, apply a delta import, and then disable Markate as the system of record. We deliver the manual-migration checklist for attachments (with file inventory sourced from the Markate audit) and the custom field re-entry guide (with field names, types, and recommended values based on the discovery audit). We support a one-week hypercare window for reconciliation issues. We do not rebuild Markate workflows, scheduling rules, or job dispatch automations in Twenty; these require a separate configuration engagement with the customer's admin team.
Platform deep dives
Markate
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 1 of 8 objects need a manual workaround.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Markate and Twenty CRM.
Object compatibility
1 of 8 objects need a manual workaround.
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
Markate: Not publicly documented — no public API exists.
Data volume sensitivity
Markate 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 Markate to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your Markate 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 Markate
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.