CRM migration

Migrate from Markate to Twenty CRM

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

Markate logo

Markate

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

55%

6 of 11

objects map 1:1 between Markate and Twenty CRM.

Complexity

BStandard

Timeline

2-4 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

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

Markate logo

Markate

What's pushing teams away

  • The desktop and mobile UI is frequently described as outdated, cluttered, and unintuitive, with slow load times and error messages that are hard to find.
  • Mobile app crashes and unresponsiveness disrupt field workers who depend on real-time job updates on job sites.
  • Support operates only during business hours with no in-app chat, leading to multi-day delays when critical issues arise during a job.
  • The advertised base price hides $10/month add-ons for online booking, review requests, business phone, and photo documentation that stack quickly for a full-featured setup.
  • Integration with Google Contacts and calendar requires manual re-entry rather than a native sync, breaking expected workflows.

Choosing

Twenty CRM logo

Twenty CRM

What's pulling them in

  • Top open-source CRM on GitHub with 40.6K stars, giving teams full source code access and infrastructure ownership without per-feature licensing surprises.
  • Free self-hosting under AGPL-3.0 means unlimited users and custom objects for the cost of cloud infrastructure alone, typically $20–100/month.
  • Pricing page explicitly mocks competitors for charging add-on fees for API access, webhooks, and workflows — transparency that resonates with RevOps teams burned by Salesforce.
  • Unlimited custom objects and fields with no price impact, letting teams shape the data model to their business rather than forcing business into rigid schemas.
  • Modern TypeScript/React/PostgreSQL stack means developer-led teams can extend, self-host, or integrate without fighting legacy architecture.

Object mapping

How Markate objects map to Twenty CRM

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

maps to

Twenty CRM

Company + Person

1:many
Fully supported

Markate 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

maps to

Twenty CRM

Company address fields

1:1
Fully supported

Markate 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

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Markate 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

maps to

Twenty CRM

Custom Object: EstimateLineItem

1:many
Fully supported

Markate 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

maps to

Twenty CRM

Task + Custom Object: WorkOrder

lossy
Fully supported

Markate 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

maps to

Twenty CRM

Opportunity (closed) + Custom Fields

1:1
Fully supported

Markate 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

maps to

Twenty CRM

Custom Object: Product

1:1
Fully supported

Markate 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

maps to

Twenty CRM

Custom Field or Picklist on Product

lossy
Fully supported

Markate 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

maps to

Twenty CRM

Note

1:1
Fully supported

Markate 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

maps to

Twenty CRM

User

1:1
Fully supported

Markate 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

maps to

Twenty CRM

Custom Object Fields

lossy
Not supported

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

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.

Markate logo

Markate gotchas

High

No duplicate checking during CSV import

High

Import cannot be reversed

Medium

Custom fields and attachments are excluded from exports

Medium

No public API for automated migration tooling

Low

Support hours limited to business days only

Twenty CRM logo

Twenty CRM gotchas

High

Import order is enforced and critical

High

Export limited to 20,000 records and visible columns only

Medium

Soft-deleted records count toward uniqueness and trigger restores

Medium

API rate limits cap at 200 req/min on Organization tier

Low

No native email sequences — follow-up cadences require external tools

Pair-specific challenges

  • Markate's CSV import cannot be reversed

    Markate's Data Migration tool has no rollback or bulk-delete capability. Once a CSV file is submitted, all records are committed permanently. We mitigate this by running a full validation pass on field counts, required field presence, and data type compliance against Markate's documented CSV format before any submission. We always run a partial import of a 50-100 record subset first to confirm the mapping is correct, and we freeze new Markate data entry during the cutover window to prevent post-import writes that would require a second migration run.

  • No duplicate detection during Markate import

    Markate's Data Migration tool does not check for existing records when importing a CSV. If a customer was previously entered manually in Markate, the CSV import will create a second record without any merge prompt. We run a pre-flight duplicate analysis on the exported CSV using name and email matching, and present a deduplication report to the customer before import. The customer decides which records to keep or merge. We cannot prevent duplicates at the Markate import layer because Markate provides no dedupe configuration.

  • No REST API — delta sync impossible after initial migration

    Markate exposes no public REST or GraphQL API for programmatic data extraction. All migration tooling relies on CSV exports through Markate's UI. This means we cannot run a delta sync after initial migration to capture records created or modified during the migration window without a second export-and-import cycle. We mitigate this by minimizing the cutover window and by scheduling the final Markate data freeze to coincide with the last export before production import. Customers with active field operations must plan for a brief write-freeze period.

  • Attachments and custom fields excluded from Markate export

    Markate's Data Migration tool does not include file attachments (photos, signed documents, receipts) or custom field values in the export. We explicitly document these gaps during scoping. For attachments, we provide a manual-migration checklist enumerating every file to re-upload in Twenty after migration. For custom field values, we identify which fields the customer needs to preserve and re-enter them as Twenty custom fields post-migration. Both are manual activities outside the automated migration scope.

  • Twenty requires custom objects and fields to exist before import

    Twenty's CSV import creates records, not fields or objects. All custom objects and custom fields must be created in Settings → Data Model before any data import begins. We handle this by designing the complete Twenty schema (WorkOrder, Product, EstimateLineItem custom objects and their fields) in a staging run before the production migration. The customer must also invite all team members as Twenty Users before migration so that Owner and assignee lookups resolve on import. Skipping this step causes import failures on User-reference fields.

Migration approach

Six steps for a successful Markate to Twenty CRM data migration

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

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

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

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

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

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

Context on both ends of the pair

Markate logo

Markate

Source

Strengths

  • Single platform replacing separate scheduling, invoicing, and CRM tools for small field service teams.
  • Per-employee pricing model is transparent and predictable as teams grow.
  • Built-in automation for appointment reminders, follow-up emails, and payment collection reduces manual admin work.
  • QuickBooks Online sync is available for accounting integration without abandoning existing bookkeeping.
  • Mobile app (despite reliability complaints) covers the core field worker workflow of job updates and customer communication.

Weaknesses

  • No public REST API limits migration tooling to CSV file exchange only, with no bulk export capability built into Markate.
  • Add-on pricing model inflates the effective cost significantly when contractors need online booking, review management, or photo documentation.
  • Data Migration tool does not check for duplicates, does not alter data, and imports cannot be reversed after submission.
  • No in-app live chat or 24/7 support means issues on a job site can wait days for a response.
  • Limited native integrations beyond QuickBooks Online; Zapier and CompanyCam require separate paid subscriptions on top of Markate's own add-on fees.
Twenty CRM logo

Twenty CRM

Destination

Strengths

  • AGPL-3.0 open-source license with full source code on GitHub — no vendor lock-in, no sunset risk.
  • Unlimited users and unlimited custom objects on self-hosted, with no feature gating based on headcount.
  • REST and GraphQL APIs available on all paid tiers, not locked behind an enterprise add-on fee.
  • MCP server and webhooks shipped as standard features, not premium upgrades.
  • Modern PostgreSQL-backed data model that developer teams can query, extend, and self-host.

Weaknesses

  • Recent v1.0 release means limited production hardening compared to CRMs with multi-year operational track records.
  • No native email sequencing or sales engagement tools — follow-up cadences require a separate platform.
  • No native two-way email sync or inbox integration, requiring third-party connectors for full activity logging.
  • Self-hosting 'free' pricing hides real infrastructure and DevOps costs that stack up over time.
  • Workflow automation is functional but lacks the complexity needed for sophisticated multi-step sales motions.

Complexity grading

How hard is this migration?

Standard CRM migration. 1 of 8 objects need a manual workaround.

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Markate and Twenty CRM.

  • Object compatibility

    B

    1 of 8 objects need a manual workaround.

  • 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

    Markate: Not publicly documented — no public API exists.

  • Data volume sensitivity

    B

    Markate doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Markate to Twenty CRM 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 Markate to Twenty CRM data migrations

Answers to the questions buyers ask most during Markate to Twenty CRM migration scoping. Not seeing yours? Book a call.

Can't find your answer?

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 consultation

Most migrations land between two and four weeks for accounts under 5,000 Customers, 2,000 Work Orders, and 1,000 Invoices with a straightforward data model and no multi-level category hierarchies. Migrations with large historical datasets (over 10,000 records), custom catalog structures, or a requirement to rebuild Markate job ticket fields as Twenty custom objects move to six to ten weeks because of data staging, dependency-ordered sequencing, and the manual attachment and custom field re-entry work that falls outside automated migration scope.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Markate.
Land in Twenty CRM, 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