CRM migration

Migrate from Hellotracks to Twenty CRM

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

Hellotracks logo

Hellotracks

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

92%

11 of 12

objects map 1:1 between Hellotracks and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Hellotracks is a field-service management platform built around Workers, Jobs, Places, Routes, Trips, and Alerts. Its data model centers on operational dispatching—tracking who is where, when, and what job they completed—rather than the lead-account-opportunity pipeline structure that Twenty CRM uses. When you migrate to Twenty, the core shift is from job-centric operations tracking to person-centric relationship management. We map Hellotracks Workers to Twenty People, Hellotracks Jobs to Twenty Opportunities (with status-to-stage value mapping), and Hellotracks Places to Twenty Companies. GPS location history (waypoints, trips, stops) migrates as Notes attached to the relevant People or Company record, preserving the operational timeline without forcing it into Twenty's opportunity-close-date model. Hellotracks custom fields (custom_$ prefixes and customFields arrays) map to Twenty custom fields via the Settings → Data Model schema setup step. Hellotracks Alerts and Forms migrate as Tasks and custom objects respectively, with the understanding that Hellotracks's alert triggers have no Twenty equivalent and must be rebuilt in Twenty's workflow builder. We run the migration via Twenty's CSV import API, sequencing object imports so Companies exist before People (for foreign-key resolution) and People before Opportunities (for assignee linking). A 24–48 hour delta-pickup window captures any Hellotracks records modified during cutover.

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

Hellotracks logo

Hellotracks

What's pushing teams away

  • Hellotracks lacks a calendar view for tasks, forcing dispatchers to manage job schedules in an unfamiliar or external calendar tool.
  • Customer information fields are limited compared to full CRM platforms, which frustrates teams that need richer customer profiles tied to jobs.
  • Several reviews cite bugs and inconsistent behavior that require workaround adaptation, particularly as businesses scale beyond the startup phase.
  • The platform is positioned for small-to-mid businesses; growing companies report outgrowing the feature set and switching to more robust FSM or ERP 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 Hellotracks objects map to Twenty CRM

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

Hellotracks

Worker (Member)

maps to

Twenty CRM

People

1:1
Fully supported

Hellotracks Workers map directly to Twenty People. The worker's name, email, phone, and role in Hellotracks populate the corresponding Twenty People fields. Hellotracks device_id and team membership are preserved as custom fields on the People record to maintain operational context and organizational structure after migration.

Hellotracks

Job

maps to

Twenty CRM

Opportunity

1:1
Fully supported

Hellotracks Jobs are the operational work orders. We map them to Twenty Opportunities so they appear in Twenty's pipeline kanban view. The job title becomes the Opportunity name, the assigned worker becomes the Opportunity's linked Person, and the status field undergoes value mapping to Twenty stage pick-list values.

Hellotracks

Job Status (progressSuccess, progressActive, custom strings)

maps to

Twenty CRM

Opportunity Stage

1:1
Fully supported

Hellotracks has no standard stage taxonomy. We map job status to Twenty Opportunity Stage values based on your configured stages. In-progress jobs typically map to 'Proposition', completed jobs to 'Won', and cancelled jobs to 'Lost'. Custom Hellotracks status strings are mapped individually during the planning phase.

Hellotracks

Place (geofenced location)

maps to

Twenty CRM

Company

1:1
Fully supported

Hellotracks Places (saved geofenced locations with radius and contact details) map to Twenty Companies. The place name becomes the Company name, the address becomes the Company address, and any place-level custom fields migrate to Company custom fields. Customer site Places become Companies representing the client organization.

Hellotracks

Trip (GPS journey with waypoints)

maps to

Twenty CRM

Note

1:1
Fully supported

Hellotracks Trips (complete GPS traces including start, waypoints, stops, end, speed data, and duration) migrate as Twenty Notes attached to the relevant People or Company record. The Note body contains a structured summary of the trip: distance, duration, stops, and peak speed, preserving the operational context without requiring a dedicated GPS object in Twenty.

Hellotracks

Waypoint (individual GPS point)

maps to

Twenty CRM

Note (embedded in Trip Note)

many:1
Fully supported

Individual GPS waypoints are too granular for Twenty's data model to handle efficiently. We merge all waypoints into the parent Trip Note as a structured section within the Note body, preserving route precision and sequence while keeping the data in a Twenty-native format that your team can reference.

Hellotracks

Alert

maps to

Twenty CRM

Task

1:1
Fully supported

Hellotracks Alerts (geofence violations, speed violations, no-show triggers) map to Twenty Tasks. The alert type becomes the Task subject, the alert message becomes the Task description, and the triggering worker is linked as the Task assignee. Note: Hellotracks alert trigger logic does not migrate; Tasks are created for historical alerts only.

Hellotracks

Form (worker input form)

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Hellotracks Forms with extra_number_$ and extra_text_$ fields map to a Twenty custom object named 'FieldForm'. Each form instance becomes a custom object record, linked to the relevant Job (Opportunity) and Worker (People). The form field labels become custom field names in Twenty.

Hellotracks

customFields array (key-value pairs)

maps to

Twenty CRM

Custom Fields on respective object

1:1
Fully supported

Hellotracks customFields JSON arrays (e.g., {key: 'PO_Number', val: 'PO-2026-1234'}) are exploded into named Twenty custom fields on the parent object. The custom field is created in Twenty's Settings → Data Model during schema setup, then populated from the key-value data during migration.

Hellotracks

Team

maps to

Twenty CRM

Custom Field on People

1:1
Fully supported

Hellotracks team membership (worker-to-team relationships) has no direct Twenty equivalent for organizational hierarchy. We preserve team assignment as a custom pick-list or text field on the People record, mapping team names to a consistent set of values in Twenty for reporting and filtering.

Hellotracks

Route

maps to

Twenty CRM

Note (on People)

1:1
Fully supported

Hellotracks Routes (scheduled sequences of Jobs) are preserved as Notes on the assigned Worker's People record. The Note captures the route name, scheduled sequence of stops, and the order of job assignments active at the time the route was executed.

Hellotracks

Attachment / File

maps to

Twenty CRM

Attachment (Twenty native)

1:1
Fully supported

Hellotracks file attachments on Jobs or Places are downloaded from source storage and re-uploaded to Twenty as native attachments on the corresponding Opportunity (Job) or Company (Place) record. File size limits and supported formats from Hellotracks export are respected during transfer.

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.

Hellotracks logo

Hellotracks gotchas

High

Polling the API aggressively triggers rate limiting

Medium

No structured customer profile object

Medium

Location tracking must be actively enabled on devices

Low

Waypoint and stop density can inflate export file sizes

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

  • GPS location data has no native Twenty CRM equivalent and requires manual preservation strategy

    Hellotracks stores GPS as first-class data: waypoints, trips, stops, speed traces, and geofence violations. Twenty CRM has no location object, no trip history model, and no native way to represent a field worker's route through the day. We migrate trip data as Notes attached to the relevant People or Company record, preserving distance, duration, start/end times, and stop count in structured Note text. However, Twenty's native reporting cannot summarize trip data—you must use a BI tool or custom dashboard to analyze location history. Plan this gap before migration if route analysis is a business-critical report.

  • Hellotracks job status is untyped while Twenty Opportunity stages are configured pick-lists

    Hellotracks Jobs use a flexible status system: progressSuccess (binary completion flag), progressActive (binary in-progress flag), and custom string status fields that Hellotracks administrators can define freely. There is no standard set of stage names. Twenty CRM Opportunities use a Stage pick-list with values your admin configures in Settings. We map each Hellotracks status string to a Twenty stage value value-by-value, but this requires your team to decide which Hellotracks statuses correspond to which Twenty stages. If Hellotracks has more distinct statuses than Twenty has stages, some statuses must be collapsed or stored as a custom field.

  • Twenty requires custom fields to exist before import, but Hellotracks custom field names are dynamic

    Hellotracks stores custom data in key-value arrays (customFields: [{key, val}]) and numbered extra_ fields (extra_number_1, extra_text_3). The field names are defined at runtime by Hellotracks admins and can be anything. Twenty's CSV import creates records, not fields—you must pre-create every custom field in Settings → Data Model before the import step. We extract every unique Hellotracks custom field name during the audit phase and generate a Twenty field creation plan. If your Hellotracks instance has hundreds of named custom fields, the schema setup phase extends the project timeline significantly.

  • Twenty workspace members must be invited and must accept before user references resolve

    Hellotracks Workers assigned to Jobs are referenced by worker ID and email. Twenty's relation model requires the target record to exist before a foreign key can resolve. Twenty's documentation explicitly states that users must be invited and accept the invitation before user references (like a Task assignee) can point to them. We resolve Hellotracks workers to Twenty People by email match, but any Job that references a worker who has not yet accepted their Twenty invitation will land with an unassigned assignee. We flag unmatched workers before migration so your team can pre-invite them.

  • Hellotracks workflows, alert triggers, and dispatch rules do not migrate to Twenty's workflow builder

    Hellotracks dispatch rules, geofence alert triggers, speed alerts, and route automation are internal configuration that has no export mechanism. Twenty's workflow builder supports triggers and actions but the trigger logic is platform-native. We do not attempt to reverse-engineer Hellotracks automation logic. Your team must rebuild dispatch rules, alert triggers, and route optimization logic manually in Twenty's workflow builder. We provide an automation audit document listing every Hellotracks rule as a rebuild reference, but the rules themselves do not transfer.

Migration approach

Six steps for a successful Hellotracks to Twenty CRM data migration

  1. Audit Hellotracks data and generate custom field schema plan for Twenty

    We extract all Hellotracks objects (Workers, Jobs, Places, Trips, Alerts, Forms) via the Hellotracks REST API, respecting rate limits by using batched requests. We identify every unique custom field name (custom_$ keys, extra_number_$ labels, extra_text_$ labels) and generate a Twenty field creation manifest grouped by parent object. This manifest tells your admin exactly which fields to create in Settings → Data Model, with the correct field type (text, number, select, date, etc.) for each. No data moves until the schema plan is approved and fields are created in Twenty.

  2. Invite Twenty workspace members and resolve user mappings

    Before any data with user references can migrate, your admin (or our team) invites every Hellotracks Worker who will be a Twenty Workspace Member. Workers must accept the invitation and appear in the Twenty Members list. We cross-reference Hellotracks worker IDs with Twenty member IDs by email, building an owner resolution map. Any Hellotracks worker without a corresponding Twenty member is flagged as unassigned—we assign those records to a fallback Twenty user you designate, and we surface the list of unassigned workers for your team to resolve before the full migration.

  3. Migrate Companies first, then People, then Opportunities with ordered foreign-key resolution

    Twenty's import documentation explicitly requires that the 'one' side of one-to-many relationships exist before the 'many' side can be imported. We sequence the migration in this order: (1) Places → Companies, so every Hellotracks Place has a corresponding Twenty Company; (2) Workers → People, with team membership preserved as a custom field; (3) Jobs → Opportunities, linking to resolved Company and People records by ID; (4) Trips → Notes, attached to the People or Company that owns the trip; (5) Alerts → Tasks, assigned to the resolved People record. Custom object records (Forms) are migrated last since they may reference any of the above.

  4. Run sample migration with field-level diff before committing the full run

    We migrate a representative sample of records—typically 100–500 spanning Workers, Jobs, Places, Trips, and Alerts—to validate the mapping. We generate a field-level diff comparing each Hellotracks field value against its Twenty destination value. Your team reviews the diff to confirm that status-to-stage value mapping matches expectations, that custom field data landed in the correct Twenty fields, that GPS trip Notes contain the expected summary data, and that People and Company links resolve correctly. No full migration run commits until the sample is approved.

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

    The full migration runs against Twenty's import API, following the sequenced object order validated in the sample step. A 24–48 hour delta-pickup window opens at cutover, capturing any Hellotracks records created or modified during the migration run (new jobs assigned, status changes, worker updates). Every operation is logged in an audit trail. If reconciliation reveals a mapping error after go-live, one-click rollback reverts the Twenty workspace to its pre-migration state, and the migration re-runs with the corrected mapping. Your team continues working in Hellotracks during the entire window—scoped read access only, no disruption to active operations.

Platform deep dives

Context on both ends of the pair

Hellotracks logo

Hellotracks

Source

Strengths

  • Real-time GPS tracking accurate to the second with 20-second location update intervals.
  • Automatic geofenced check-in and check-out at saved Places reduces manual time-tracking overhead.
  • Built-in job dispatching with team and worker assignment and dynamic route adjustments.
  • Mobile-first design with iOS and Android apps covering the full feature set.
  • Trip quality metadata flags GPS signal gaps and multipath issues for route reliability reporting.

Weaknesses

  • No native calendar view for job scheduling, requiring teams to manage schedules in external tools.
  • Limited customer profile fields — Hellotracks is not a CRM and stores minimal customer contact data beyond what is attached to Jobs.
  • Reviewers report bugs and inconsistent behavior that require workaround adaptation as team size grows.
  • No structured attachment export via API, limiting complete document migration.
  • Reporting is export-focused rather than native dashboard-centric, which may require additional BI tooling.
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 mapping; the rest are 1:1.

B

Overall complexity

Standard migration

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

  • Object compatibility

    B

    1 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

    Hellotracks: Not publicly documented — the API docs explicitly advise against polling and recommend webhooks instead.

  • Data volume sensitivity

    A

    Hellotracks exposes a bulk API — large-volume migrations stream efficiently.

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Hellotracks-to-Twenty migrations complete in 48–72 hours for setups with fewer than 10,000 records. The longest phase is schema setup—creating custom fields in Twenty's Data Model to match Hellotracks's dynamic customFields array takes 2–4 days of planning and admin work before data moves. Complex migrations with 100,000+ records or multiple custom object types (Forms, Alerts) extend to 5–10 days. GPS trip history (waypoints, stops) is the most time-intensive to structure as Notes.

Adjacent paths

Related migrations to explore

Ready when you are

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