CRM migration

Migrate from Timefold to Twenty CRM

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

Timefold logo

Timefold

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

objects map 1:1 between Timefold and Twenty CRM.

Complexity

BStandard

Timeline

72–96 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Timefold is an AI-powered scheduling optimization platform built around constraint-satisfaction problem definitions: planning entities (Shifts, Visits, Vehicles), planning variables (employee-to-shift assignments, visit-to-vehicle routes), problem facts, and scored solutions. It has no native CRM objects — contacts, accounts, and deals do not exist in Timefold's data model. Twenty CRM is an open-source CRM with standard People, Companies, and Opportunities objects, plus unlimited custom objects for anything outside that core. There is no native scheduling model in Twenty, so Timefold's entire planning domain (entities, constraints, assignments, scores) migrates as a set of custom objects and custom fields on Twenty's standard records. FlitStack AI sequences the migration by first creating the custom object schema in Twenty, then exporting Timefold problem data via its REST API, transforming the constraint and entity model into Twenty-compatible JSON/CSV, and loading through Twenty's API or CSV import. Constraint configurations do not auto-enforce in Twenty — they become reference data that your team rebuilds using Twenty's workflow builder. We preserve Timefold's internal IDs on all migrated records for traceability and run delta-pickup during cutover so any new or modified planning entities land in Twenty before 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

Timefold logo

Timefold

What's pushing teams away

  • Steep learning curve when modeling custom constraints — teams struggle to correctly express business rules as DRL rules or Constraint Streams without specialist help.
  • Constraint enforcement bugs reported on GitHub (issue #307) cause unexpected infeasibility in production, particularly around capacity and dependency constraints.
  • Performance unpredictability at scale — without Enterprise Edition features (multithreaded solving, partitioned search), large datasets produce prohibitively slow solve times.
  • Lack of native no-code UI for business users — the platform is primarily developer-facing, making it harder for operations teams to tweak schedules directly.
  • Website performance issues noted in G2 review (occasionally slow loading) suggest infrastructure concerns for the managed SaaS offering.

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

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

Timefold

Planning Entity: Shift

maps to

Twenty CRM

Custom Object: Shift

1:1
Fully supported

Timefold's Shift entity (employee-to-shift assignments, start/end times, location) migrates as a Twenty custom object with fields for shiftName, startTime, endTime, locationId, and assignedEmployee. Twenty's custom object creation via Settings → Data Model must happen before CSV import or API load.

Timefold

Planning Entity: Visit

maps to

Twenty CRM

Custom Object: Visit

1:1
Fully supported

Timefold Field Service Routing's Visit entity (customer location, time window, required skills, duration) maps to a Twenty custom object. The visit's time window dates become startDate and endDate fields; required skills become a multi-select field or linked Skills custom object.

Timefold

Planning Entity: Vehicle

maps to

Twenty CRM

Custom Object: Vehicle

1:1
Fully supported

Timefold routing models' Vehicle entity (capacity, skills, startLocation) maps to a Twenty custom object. Vehicle capacity and skill requirements become number and multi-select fields respectively. Routes assigned to this vehicle in Timefold's solution become linked Route records. If your routing model includes multi-day routes with intermediate stops, the route hierarchy is preserved as nested relation fields on the Vehicle record.

Timefold

Planning Entity: Employee

maps to

Twenty CRM

People

1:1
Fully supported

When Timefold's employee roster needs to link to a CRM contact model, the Employee entity maps to Twenty's People object. Standard fields: name, email, phone, jobTitle. Employee skills stored in Timefold become a multi-select custom field on the People record.

Timefold

Planning Entity: Task (generic work item)

maps to

Twenty CRM

Tasks

1:1
Fully supported

Timefold planning tasks (the work items being assigned to employees/shifts) map to Twenty's standard Tasks object. The Twenty Tasks object supports dueDate, assignee (linked to People), status, and body — matching the structure of a generic planning task. Task dependencies from Timefold become predecessor-link custom fields on the Twenty Tasks record.

Timefold

Problem Fact: Location

maps to

Twenty CRM

Companies

1:1
Fully supported

Timefold location records (addresses, coordinates for routing) can map to Twenty Companies for physical service locations. The Company object captures address, city, country, and domain. Locations used in Visit routing become Company records with address fields populated from Timefold's location data. GPS coordinates from Timefold are stored in a custom lat/long field on the Company record for map integration.

Timefold

Planning Variable: Shift-to-Employee assignment

maps to

Twenty CRM

Custom Field on Shift

1:1
Fully supported

Timefold's planning variable assigning an Employee to a Shift becomes a relation field (assignedEmployee) on the Shift custom object in Twenty. This is a lookup to the People record representing the employee, resolving the foreign key by email match. If an employee record does not yet exist in Twenty, FlitStack creates a stub People record to preserve the assignment relationship.

Timefold

Planning Variable: Visit-to-Vehicle assignment

maps to

Twenty CRM

Custom Field on Visit

1:1
Fully supported

Timefold's vehicle assignment for a Visit (which vehicle serves which visit) becomes a VehicleId lookup field on the Visit custom object. The vehicle must exist as a Vehicle custom object record before the Visit assignment can reference it. This ensures referential integrity during import and prevents orphan lookups on the Twenty side.

Timefold

Score / Optimization Output

maps to

Twenty CRM

Custom Field on Planning Entity

1:1
Fully supported

Timefold's score output (e.g., '0hard/-257medium/-6119520soft') has no native equivalent in Twenty. We store it as a text field (Score__c) on each planning entity for historical reference. Teams using score to evaluate schedule quality see it as metadata on the entity record. Score__c enables audit and compliance review but requires spreadsheet export for trend analysis.

Timefold

Constraint Configuration

maps to

Twenty CRM

Custom Object: ConstraintReference

1:1
Fully supported

Timefold's constraint definitions (hard rules like skill matching, soft rules like travel time minimization) cannot auto-enforce in Twenty. We export them as structured JSON into a ConstraintReference custom object — name, type (hard/medium/soft), definition text, and weight — serving as a manual-rebuild guide for Twenty workflow configuration.

Timefold

Planning Solution / Schedule Run

maps to

Twenty CRM

Custom Object: ScheduleRun

1:1
Fully supported

Each Timefold optimization run (solving a planning problem to produce a schedule) maps to a ScheduleRun custom object in Twenty. Fields: runDate, modelName, entityCount, scoreValue, and a link to the generated Shift/Visit/Vehicle assignments. This gives an audit trail of what the optimizer produced historically.

Timefold

Custom Entity Class

maps to

Twenty CRM

Custom Object

1:1
Fully supported

Timefold domain models with custom entity classes (beyond Shift/Visit/Vehicle) map 1:1 to Twenty custom objects. Each entity property becomes a field in Twenty's data model. Relationships between custom entities in Timefold become relation fields or junction objects in Twenty based on cardinality.

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.

Timefold logo

Timefold gotchas

High

Score DRL to Constraint Streams migration is non-trivial

High

Hard constraint enforcement failures reported in production

Medium

Solver migration bugs are upstream-dependent

Medium

Neighborhoods API is preview-only and subject to breaking changes

Low

Commercial tier features are edition-gated without feature-flag documentation

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

  • Timefold's constraint logic cannot be migrated as enforceable rules in Twenty

    Timefold encodes business rules (no overlapping shifts, skill matching, travel time limits) as Java constraint providers scoring each solution. Twenty has no equivalent constraint-satisfaction engine. FlitStack exports every constraint definition as structured reference data in a ConstraintReference custom object, but the actual enforcement logic must be manually rebuilt in Twenty's workflow builder. Teams expecting migrated constraints to behave like Timefold's optimizer will face a gap that requires a manual configuration pass using Twenty's trigger and automation tools.

  • Twenty's import order enforces foreign-key dependency sequencing

    Twenty's CSV import documentation explicitly requires uploading Companies first, then People (linked via companyId), then Opportunities, then custom objects with relations last. Timefold planning entities often have circular or forward references (Visit references Vehicle, Vehicle references Employee). FlitStack resolves these by creating stub records for unresolved foreign keys first, then backfilling the relation fields in a second pass. Skipping this sequencing produces orphan records where Visit.AssignedVehicle__c points to a non-existent Vehicle.

  • Timefold's score output is a string with no native semantic in Twenty

    Timefold's score format is '0hard/-257medium/-6119520soft' — a composite of constraint penalty values. Twenty has no object that parses or displays this format. FlitStack stores the full score string as a text field on each ScheduleRun record, but teams lose the ability to filter or sort by score directly in Twenty's UI without a custom sort formula. Score trends over time require manual spreadsheet analysis of the migrated Score__c text field.

  • Twenty API rate limits cap migration throughput on large planning datasets

    Twenty's API allows 100 requests per minute on Pro and 200 per minute on Organization. A Timefold deployment with 50,000 Shift records, 80,000 Visit records, and 10,000 Vehicle records generates hundreds of thousands of individual record-create API calls when each planning entity and its assignments are loaded individually. FlitStack uses Twenty's batch import endpoint where available and implements request throttling with exponential backoff to avoid rate-limit errors. For datasets exceeding 500,000 total records, we recommend phasing the migration by planning entity type.

  • Custom entity classes in Timefold have no standard CRM analogue to map to

    Timefold domain models can include arbitrary custom entity classes beyond the standard Shift/Visit/Vehicle model set — for example, a manufacturing scheduling domain with Machine, WorkOrder, and SetupTime entities. Twenty's standard People-Companies-Opportunities model offers no home for these. FlitStack creates matching custom objects in Twenty for every custom entity class, but the business logic that connects them in Timefold (e.g., WorkOrder depends on Machine availability) must be manually documented and rebuilt as Twenty custom object relations or workflow triggers.

Migration approach

Six steps for a successful Timefold to Twenty CRM data migration

  1. Audit Timefold domain model and export via API

    FlitStack connects to Timefold's REST API using the provided API key and enumerates all planning entity classes, problem facts, constraint definitions, and historical schedule runs. We capture the full constraint-provider JSON, entity schemas, and relationship graph. This audit produces the migration blueprint: which entities map to standard Twenty objects, which require custom objects, and which Timefold concepts (constraint scoring) have no Twenty equivalent and will become reference data.

  2. Build Twenty custom object schema before data arrives

    Twenty requires custom objects and fields to exist before CSV import or API load. FlitStack creates the Shift, Visit, Vehicle, ScheduleRun, and ConstraintReference custom objects in Twenty via Settings → Data Model, adding all required fields (StartTime__c, AssignedEmployee__c, TimeWindowStart__c, Score__c, etc.). We configure relation fields at this stage so foreign-key lookups are ready when entity records land. Field types are chosen to match the source data semantics — datetime for timestamps, number for scores, multi-select for skills arrays.

  3. Export Timefold entity data and resolve owner/employee matches

    We export all planning entity records (Shifts, Visits, Vehicles, custom entities) from Timefold via its REST API. For entities with assignedEmployee or assignedVehicle planning variables, we match the referenced employee/vehicle records by identifier. Any unresolved references are flagged and escalated — typically because an employee was deleted from Timefold but still referenced in a historical schedule. The export is scoped to read-only access so your team can continue using Timefold normally while migration proceeds.

  4. Run sample migration with field-level diff on planning entities

    A representative slice of Timefold records — typically 100–500 entities spanning Shifts, Visits, Vehicles, and constraint configurations — migrates to Twenty first. FlitStack generates a field-level diff between the source JSON and the Twenty custom object records, verifying that AssignedEmployee__c resolves to the correct People record, TimeWindowStart__c matches the original visit time window, and Score__c captures the full Timefold score string.

  5. Cut over with delta-pickup for in-flight schedule runs

    The full migration commits all Timefold entities to Twenty. A delta-pickup window (24–48 hours) captures any new Shifts, Visits, or constraint configurations created in Timefold during the cutover. FlitStack's audit log records every operation, and one-click rollback is available if Twenty's custom object schema has issues that surface post-migration. Constraint definitions are delivered as a ConstraintReference rebuild guide for the Twenty admin team.

Platform deep dives

Context on both ends of the pair

Timefold logo

Timefold

Source

Strengths

  • Apache 2.0 open-source solver with no licensing cost for self-hosted deployments.
  • Three production-grade pre-built models covering field service, shift scheduling, and vehicle routing.
  • Enterprise Edition enables multithreaded solving and partitioned search for large-scale optimization.
  • REST API with X-API-KEY authentication provides straightforward integration into existing backend systems.
  • Active open-source community on GitHub (1.6k stars) with Stack Overflow support and partner consulting network.

Weaknesses

  • Java/Kotlin-centric architecture excludes non-JVM languages from direct solver embedding without wrapper services.
  • Constraint authoring requires operations-research knowledge; no low-code or visual constraint builder for business analysts.
  • Single G2 review with 4.5/5 rating — very limited third-party validation compared to established FSM platforms.
  • Pricing is not publicly documented on the website, requiring a sales contact for commercial tier costs.
  • Platform is specialized for scheduling optimization and does not function as a general CRM, ERP, or project management tool.
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 Timefold 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

    Timefold: Not publicly documented on the Timefold Platform REST API.

  • Data volume sensitivity

    A

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Timefold-to-Twenty migrations complete in 72–96 hours for under 50,000 planning entity records. Larger datasets with 500,000+ records or complex custom entity schemas extend to 7–14 days. The longest phase is building the Twenty custom object schema to accommodate Timefold's entity model — creating Shift, Visit, Vehicle, and ConstraintReference objects with all required fields before data can land. The schema build also includes configuring relation fields between entities, which requires planning the import sequence to respect Twenty's foreign-key dependencies.

Adjacent paths

Related migrations to explore

Ready when you are

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