CRM migration

Migrate from Handyman to Twenty CRM

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

Handyman logo

Handyman

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

objects map 1:1 between Handyman and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Handyman is a field service management platform focused on job scheduling, dispatch, and service delivery for tradespeople and small service businesses. Its data model centers on Customers (contacts with service addresses), Jobs (work orders with line items and status), Invoices (billing records), and custom fields for service types, territories, and equipment. Twenty CRM is a modern open-source CRM with standard People, Companies, Opportunities, Notes, and Tasks objects plus unlimited custom objects created through its metadata API at Settings → Data Model. The migration from Handyman to Twenty requires translating a field service data model into a CRM data model: customers map to People (with service-address data stored in custom fields or a custom Service Location object), jobs map to a custom WorkOrder object or Opportunities with a custom status pick-list, and invoices map to custom Invoice objects linked to People. FlitStack AI extracts Handyman data via its export API, builds a custom WorkOrder schema in Twenty before import, resolves owner relationships by email match against Twenty workspace members, and runs a sample migration with field-level diff before committing the full dataset. Workflows, scheduling rules, and dispatch logic in Handyman do not migrate — those must be rebuilt in Twenty's workflow builder. Attachments and files re-upload to Twenty's file storage and are linked back to the parent record by ID. The migration runs against Twenty's REST and GraphQL APIs at up to 200 calls per minute (Organization tier), with bulk CSV import as a fallback for large record sets. A 24–48 hour delta-pickup window captures any Handyman records modified during cutover so Twenty reflects the final operational state at go-live.

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

Handyman logo

Handyman

What's pushing teams away

  • Limited scalability beyond small team sizes, with businesses outgrowing the platform as they add multiple technicians or crews.
  • Feature set narrows for businesses expanding into specialty trades that require more complex project management capabilities.
  • Integration ecosystem narrower than larger competitors, making it difficult to connect with specialized accounting or CRM tools.

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 Handyman objects map to Twenty CRM

Each row shows how a Handyman 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.

Handyman

Customer

maps to

Twenty CRM

People

1:1
Fully supported

Handyman customers (contact records with name, email, phone, and service address) map directly to Twenty's People object. Service address fields that don't exist as standard Twenty fields are stored in custom fields on the People record. If a customer has multiple service locations, each location becomes a separate People record with a custom ServiceLocation custom field to differentiate them.

Handyman

Company (business customer)

maps to

Twenty CRM

Company

1:1
Fully supported

Handyman business accounts (commercial customers with company name, industry, and billing address) map directly to Twenty's Company object. Company records are imported first because Twenty's People object links to Company via the companyId relation field — the 'one' side of the relationship must exist before the 'many' side is loaded.

Handyman

Job

maps to

Twenty CRM

WorkOrder (custom object)

1:1
Fully supported

Handyman jobs are work orders with status (scheduled, in-progress, completed, cancelled), assigned technician, service type, service address, scheduled date, and completion notes. Twenty has no native work-order object. We create a WorkOrder custom object via Twenty's metadata API at Settings → Data Model before migration, with fields for jobId, status, technicianOwnerId, serviceTypeId, scheduledDate, completedDate, and completionNotes. The WorkOrder links to the People record representing the customer.

Handyman

LineItem (job materials and labor)

maps to

Twenty CRM

WorkOrderLineItem (custom object)

1:1
Fully supported

Handyman job line items (labor hours, material costs, and service codes) translate to a WorkOrderLineItem custom object linked to the WorkOrder by a relation field. Each line item includes description, quantity, unit price, total, and lineType (labor vs. material). This custom object is created alongside the WorkOrder object in Twenty's data model setup phase.

Handyman

Invoice

maps to

Twenty CRM

Invoice (custom object)

1:1
Fully supported

Handyman invoices map to a custom Invoice object in Twenty, linked to the People record (customer) and optionally to the related WorkOrder. The custom Invoice object holds invoiceNumber, invoiceDate, dueDate, totalAmount, status (draft, sent, paid, overdue), and paymentMethod. Invoice line items are stored in a related InvoiceLineItem custom object.

Handyman

ServiceType

maps to

Twenty CRM

ServiceType (custom object) or custom pick-list

1:1
Fully supported

Handyman service types (e.g., plumbing repair, electrical, HVAC maintenance) with their pricing rules become a custom ServiceType object in Twenty linked to WorkOrder records. Alternatively, for simpler setups, a custom pick-list field on WorkOrder (Service_Type__c) is used. Which approach is chosen depends on whether service types have additional metadata (descriptions, default pricing) that warrants a full object.

Handyman

Asset (customer equipment)

maps to

Twenty CRM

Asset (custom object) or Opportunity

1:1
Fully supported

Handyman tracks customer equipment (HVAC units, water heaters, appliances) as Assets linked to the customer record. In Twenty, we create a custom Asset object with fields for assetId, name, equipmentType, manufacturer, model, serialNumber, installDate, and linkedPeopleId (relation to the People record). If the business only tracks equipment on closed deals, Opportunity records can store this in a custom field instead.

Handyman

User (technician / office staff)

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

Handyman users (technicians and office staff) are matched to Twenty Workspace Members by email address. Twenty requires all workspace members to be invited and to accept their invitation before user lookups on records can resolve. We flag any Handyman users without a matching Twenty member and assign their records to a fallback member or leave the owner field blank for manual assignment after migration.

Handyman

Attachment (job photo, signed form)

maps to

Twenty CRM

File (Twenty file storage)

1:1
Fully supported

Handyman file attachments (photos, signed forms, inspection reports) are downloaded and re-uploaded to Twenty's file storage, then linked back to the parent People, WorkOrder, or Invoice record by ID. Handyman does not expose attachments via a public API in all tiers, so the export method (direct download vs. manual export) is confirmed in the data audit phase before the migration plan is finalized.

Handyman

Note (job notes, internal comments)

maps to

Twenty CRM

Note

1:1
Fully supported

Handyman job notes and internal comments map to Twenty's standard Note object. Notes are linked to the parent record (People or WorkOrder) via the noteTargetId relation. Original timestamps and note authors are preserved. Rich-text formatting in Handyman notes is flattened to plain text during migration to ensure compatibility with Twenty's Note field type.

Handyman

Task (follow-up, reminder)

maps to

Twenty CRM

Task

1:1
Fully supported

Handyman follow-up tasks and reminders map to Twenty's standard Task object. Tasks are linked to the parent People or WorkOrder record via the taskTargetId relation. Status (open, completed), due date, and assignee are preserved. Completed tasks retain their completion timestamp for historical completeness in Twenty's activity view.

Handyman

Tag / Label (customer or job tag)

maps to

Twenty CRM

Custom Tag field or custom Select field

1:1
Fully supported

Handyman tags on customers and jobs are mapped to a custom Tag__c multi-select field on the relevant Twenty object. Each unique Handyman tag value is created as an option in the pick-list. If there are more than 50 unique tags, a custom Tag object with a many-to-many relation to People and WorkOrder is created instead to avoid pick-list overflow.

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.

Handyman logo

Handyman gotchas

Medium

Pricing model terminology varies across destinations

Low

Service history chunking for accounts with large job counts

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

  • Twenty requires all custom fields and objects to exist before CSV import — fields are not auto-created during data load

    Unlike Handyman, where custom fields can be added inline during data entry, Twenty's CSV import creates records only — it does not create fields. If you attempt to import a CSV column for a field that does not already exist in Settings → Data Model, Twenty silently ignores that column. FlitStack AI builds the complete custom field and custom object schema in Twenty before the migration run, referencing Handyman's field list during the data audit phase. This schema setup step is delivered as a documented plan so your Twenty admin can review and approve the field names, types, and pick-list values before data lands.

  • Twenty's import order enforces referential integrity — parent records must load before child records

    Twenty's CSV import engine enforces a dependency order: Companies must be imported first, then People (linked by companyId), then Opportunities and custom objects. Handyman does not enforce this ordering. If you attempt to import WorkOrder records before the associated People records exist in Twenty, the WorkOrder.PeopleId foreign key column will not resolve, leaving orphan records. FlitStack AI sequences the migration load in the correct dependency order — Companies → People → WorkOrders → WorkOrderLineItems → Invoices — and re-runs the import in stages with validation checkpoints between each object type.

  • Twenty lacks native work-order, service-address, and asset objects — these require custom object build-out

    Handyman's core objects (Job, Asset, ServiceAddress) have no direct Twenty CRM equivalent — Twenty ships with People, Company, Opportunity, Note, and Task as standard objects. Migrating a field service operation into Twenty requires creating a WorkOrder custom object, an Asset custom object, and optionally a ServiceLocation custom object using Twenty's metadata API (POST to /metadata). Each custom object needs its fields created individually before the migration CSV is prepared. FlitStack AI delivers a complete custom object schema specification as part of the migration plan, so your Twenty admin can pre-build the schema or authorize FlitStack to create it via API before the data migration begins.

  • Handyman attachments may not be accessible via API in all subscription tiers

    Handyman does not expose a public REST API for file attachments in all plan tiers. Photos attached to jobs, signed customer forms, and invoice PDFs may only be downloadable through the Handyman admin UI or may require a manual export step. If attachment download requires manual export per record, the migration timeline extends because each attachment must be individually retrieved and re-uploaded to Twenty. FlitStack AI audits the Handyman API attachment endpoints during the data audit phase and flags any records where attachments require manual extraction, so the timeline impact is known before migration begins.

  • Handyman dispatch rules, scheduling constraints, and recurring job templates do not map to Twenty

    Handyman's scheduling engine — including technician routing rules, geographic dispatch zones, availability calendars, and recurring service templates — is a proprietary automation layer with no equivalent in Twenty's workflow builder. Twenty's workflow builder (Settings → Workflows) handles CRM-level automations like task creation triggers and field-update rules, but it does not replicate field service scheduling logic. Any recurring job templates in Handyman (e.g., 'quarterly HVAC maintenance for customer X') must be rebuilt as Opportunities with custom recurrence fields or as Tasks in Twenty. FlitStack AI exports Handyman scheduling rules as a documented configuration reference for the client's Twenty admin to rebuild.

Migration approach

Six steps for a successful Handyman to Twenty CRM data migration

  1. Audit Handyman data export and build Twenty custom object schema

    FlitStack AI exports a full data snapshot from Handyman covering all objects identified in the mapping plan: Customers, Companies, Jobs, LineItems, Invoices, Users, Attachments, Tags, and any custom fields. Simultaneously, we build the custom object schema in Twenty via the metadata API — creating WorkOrder, WorkOrderLineItem, Invoice, InvoiceLineItem, Asset, and ServiceLocation objects with all required fields, pick-list values, and relation definitions. The schema plan is reviewed and approved by your Twenty admin before any data is loaded. This step also identifies any Handyman records that cannot be exported via API and flags manual extraction requirements.

  2. Invite and verify all Handyman users as Twenty Workspace Members

    Twenty requires workspace members to exist before owner lookups on migrated records can resolve. FlitStack AI generates the list of all Handyman users and matches them to Twenty Workspace Members by email. Any Handyman users without a matching Twenty account are flagged for your team to invite before the migration run. Records owned by unmatched users are temporarily assigned to a fallback member and re-assigned post-migration. This step eliminates the most common cause of null owner fields in Twenty after migration.

  3. Load Companies, then People, then custom objects in dependency order

    FlitStack AI runs the migration in the correct Twenty import order: Companies first (the 'one' side of the company→people relationship), then People (linked to Companies via companyId), then WorkOrders (linked to People via PeopleId), then WorkOrderLineItems (linked to WorkOrders), then Invoices (linked to People), then Assets and Tags. Between each stage, a record-count validation confirms all parent records exist before child records are loaded, preventing orphan foreign-key references. All timestamps, owner IDs, and source system IDs are preserved as custom fields during this phase.

  4. Run a sample migration with field-level diff on a representative record slice

    A representative slice of 100–500 records — spanning Customers, Jobs, Invoices, and attachments — migrates first. FlitStack AI generates a field-level diff showing the source value in Handyman and the destination value in Twenty for every mapped field, including custom fields on WorkOrder and Invoice objects. You review the diff to verify status mapping, owner resolution, date formatting, and attachment re-upload. Any field mapping corrections are applied before the full migration run commits.

  5. Execute full migration with delta-pickup window and one-click rollback

    The full Handyman dataset migrates into Twenty across all objects in the sequenced load order. A delta-pickup window of 24–48 hours captures any records created or modified in Handyman during the cutover. All migration operations are logged to an audit record (source ID, target ID, timestamp, operation type). If reconciliation reveals missing records or data quality issues, FlitStack AI executes a one-click rollback that removes migrated records and restores the pre-migration state in Twenty, then re-runs with corrected mappings.

Platform deep dives

Context on both ends of the pair

Handyman logo

Handyman

Source

Strengths

  • Purpose-built for handyman and general trades with terminology that matches the trade.
  • Integrated job management, scheduling, and invoicing without requiring third-party integrations.
  • Supports multiple pricing models including flat-rate and time-and-materials billing.

Weaknesses

  • Narrower integration ecosystem compared to enterprise field service platforms.
  • Limited scaling for businesses with multiple crews or complex organizational structures.
  • Fewer advanced features for specialty trades or project-based work beyond simple jobs.
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. 2 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

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

  • Object compatibility

    B

    2 of 8 objects need a mapping; the rest are 1:1.

  • 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

    Handyman: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

Walk through your Handyman to Twenty CRM migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most Handyman-to-Twenty CRM migrations complete in 48–72 hours of clock time for setups under 25,000 records. The longest planning step is building the custom WorkOrder, Invoice, and Asset schema in Twenty before data can load. Larger setups with 200,000+ records or multiple custom objects extend to 5–10 days, primarily because Twenty's CSV import is single-threaded per object type and the custom object metadata API has per-request throttling on the Organization tier (200 calls per minute). FlitStack pipelines the load to maximize throughput within those limits.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Handyman.
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