CRM migration

Migrate from D-Tools to Twenty CRM

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

D-Tools logo

D-Tools

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

12 of 12

objects map 1:1 between D-Tools and Twenty CRM.

Complexity

CModerate

Timeline

5–10 business days

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

D-Tools organizes around projects, locations, and line items for low-voltage system integrators — it tracks proposals, job costing, and service plans but does not function as a traditional contact CRM. Twenty CRM is a modern open-source CRM built around People, Companies, and Opportunities with Kanban pipeline views, REST/GraphQL API access, and a customizable data model. The migration translates D-Tools' project, client, location, and item structure into Twenty's relational objects while handling the data-model divergence between a project-centric and contact-centric architecture. We export D-Tools data via their REST API (120 requests per minute, 10,000 per day) including custom fields on items and clients. All records, timestamps, and owner emails transfer into Twenty. D-Tools workflow rules, integration connections, invoice records, and service-plan billing logic have no Twenty equivalent — we document these for manual rebuild and flag them in the pre-migration plan. The cutover uses a scoped-read delta window so your team keeps working in D-Tools until 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

D-Tools logo

D-Tools

What's pushing teams away

  • Support response times are slow — customers report delays in resolving queries and slow turnaround on pricing or feature estimates.
  • Steep learning curve for new users, particularly around the integrated product library and change-order workflows, leading to extended onboarding.
  • Small or distributed teams find the platform heavy for their needs, with feature gaps in real-time collaboration across multiple office and field locations.
  • Annual pricing lock-in and limited transparency around renewal increases create billing surprises for long-term subscribers.

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

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

D-Tools

Client

maps to

Twenty CRM

Company

1:1
Fully supported

D-Tools Clients map directly to Twenty Companies. We map Client_Name to Company name, Client_Address fields to address fields, and Client_Phone to the primary phone on the Company record. For Clients with multiple contacts, the primary contact becomes the Company point-of-record and others migrate as related People records.

D-Tools

Contact (under Client)

maps to

Twenty CRM

Person

1:1
Fully supported

D-Tools contacts attached to a Client migrate as Twenty People records linked to the corresponding Company via companyId. D-Tools stores contact name, email, phone, and job title; these map to Twenty's standard name, email, phone, and jobTitle fields. Custom contact fields become custom fields on the Person object in Twenty's data model.

D-Tools

Item

maps to

Twenty CRM

Custom field on Opportunity (or Custom Object)

1:1
Fully supported

D-Tools Items are product-or-service line items used inside proposals and projects. Twenty has no native product catalog object on the free or Pro tiers. We map Item_Name to a custom_text field and Item_Price, Item_Cost, and Item_SKU to custom_number fields on the Opportunity. For complex item catalogs, we create a Product custom object in Twenty linked to Opportunities by item ID.

D-Tools

Proposal

maps to

Twenty CRM

Opportunity

1:1
Fully supported

D-Tools Proposals are scoped to a project and contain line items, pricing, and status. We map Proposal_Name to Opportunity name and Proposal_Value to a custom_number field (Twenty does not have a native deal amount field). Proposal status (Draft, Sent, Accepted, Lost) maps to Opportunity stage name, with a custom field preserving the original D-Tools proposal ID for traceability.

D-Tools

Project

maps to

Twenty CRM

Opportunity

1:1
Fully supported

D-Tools Projects track the full lifecycle of an installation job — scope, locations, items, and status. Projects map to Twenty Opportunities where Project_Name becomes Opportunity name and Project_Value becomes a custom_number deal-amount field. Project status (In Progress, On Hold, Completed) maps to Twenty's opportunity stage values, which are configurable in Settings → Data Model before import.

D-Tools

Location

maps to

Twenty CRM

Custom Object (Location)

1:1
Fully supported

D-Tools Locations organize items and scope within a project — a site address or room in a building. Twenty has no native Location object. We create a Location custom object with fields for name, address, and a relation to the Company (or Opportunity). Locations attach to Opportunities through a custom junction relation so project-level location context is preserved in Twenty's Kanban view.

D-Tools

Service Plan

maps to

Twenty CRM

Custom Object (Service Plan)

1:1
Fully supported

D-Tools Service Plans track recurring service agreements with billing frequency and price. Twenty has no native recurring-billing object. We create a ServicePlan custom object with fields for plan name, billing frequency, monthly/yearly price, and a relation to the associated Company record. Service plan IDs and original terms are preserved as custom fields.

D-Tools

Invoice / Payment Record

maps to

Twenty CRM

Custom Object (Invoice) or Note

1:1
Fully supported

D-Tools Invoice records (generated from projects and proposals) have no direct equivalent in Twenty CRM. We preserve invoice data — invoice number, amount, date, and status — as a custom Invoice custom object linked to the Opportunity or Company. If the invoice count is low, we attach invoice summaries as Notes on the relevant record instead of creating a full custom object.

D-Tools

Workflow Rule

maps to

Twenty CRM

Twenty Workflow Builder

1:1
Fully supported

D-Tools workflow rules fire notifications or actions when entity criteria are met. Twenty's Workflow Builder handles automations but the logic cannot be migrated automatically. We export D-Tools workflow definitions (criteria, actions, triggers) as a rebuild-reference document for your Twenty admin. Workflows must be manually recreated in Twenty's Settings → Workflows after migration.

D-Tools

Owner / Creator (user reference)

maps to

Twenty CRM

WorkspaceMember

1:1
Fully supported

D-Tools stores a user reference (owner, creator) on Projects, Proposals, and Items. Twenty WorkspaceMembers are matched by email — the Owner_Email field on each D-Tools record is resolved against Twenty's member list. Unmatched owners are flagged before migration so your team can invite them to Twenty first or assign a fallback owner. No record lands in Twenty without a resolved owner.

D-Tools

Custom Field (Item-level)

maps to

Twenty CRM

Custom field on Product or Opportunity

1:1
Fully supported

D-Tools supports custom fields on Items, Clients, Projects, and Locations. Each custom field must be pre-created in Twenty's Settings → Data Model before import. We export the custom field schema from D-Tools, map field types (text, number, date, select) to Twenty field types, and include the creation step in the migration plan. Fields that do not yet exist in Twenty are created first; then the import runs.

D-Tools

Attachment / File

maps to

Twenty CRM

Custom field (URL) or Note attachment

1:1
Fully supported

D-Tools files attached to projects, items, or clients migrate as Twenty Notes attached to the corresponding record. File names and storage URLs are preserved in the Note body. Inline images and embedded documents are downloaded and reattached as Note files in Twenty. D-Tools' native file storage is not transferred — URLs stored as text fields point to D-Tools-hosted files until you migrate file storage separately.

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.

D-Tools logo

D-Tools gotchas

High

Dual product API split (Cloud vs. SI) requires product identification first

High

i3 Product Library is a platform resource, not user data

Medium

GetClients API caps at 500 records per request with pagination required

Medium

Service plan dynamic pricing rules must be manually reconstructed

Low

Custom report definitions do not transfer between D-Tools instances

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

  • Workflow rules and automation sequences have no migration path to Twenty's Workflow Builder

    D-Tools workflow rules are event-driven triggers defined in the Control Panel — they fire on entity create/update actions and send notifications or update fields. Twenty's Workflow Builder handles automations through a separate UI (Settings → Workflows) with different trigger-and-action semantics. No D-Tools workflow definition can be imported or converted automatically. We export your D-Tools workflow definitions (criteria, entity, trigger, action) as a numbered rebuild-reference document your Twenty admin uses to recreate each rule in Twenty's Workflow Builder. This is disclosed upfront in the pre-migration plan so your team budgets time for the rebuild.

  • Custom fields must exist in Twenty's data model before the import can run

    D-Tools supports custom fields on Items, Clients, Projects, and Locations — these export via the D-Tools API. Twenty's CSV import creates records, not fields; fields must be created first in Settings → Data Model. If your D-Tools setup has 10+ custom fields per entity, the migration plan includes a field-creation phase where we create each D-Tools custom field as a Twenty field (with matching type: text, number, date, select) before importing data. Fields that do not exist in Twenty when the import runs are silently skipped, which means data in those columns is lost — we guard against this by pre-creating all custom fields and validating the schema before data lands.

  • D-Tools Locations require a custom object in Twenty — import order matters

    D-Tools Locations are a first-class entity scoped to projects and sites — they store address, description, and item associations. Twenty has no native Location or Site object. We create a Location custom object in Twenty (Settings → Data Model → Add Object) with a relation to the Company or Opportunity. Because Twenty requires the 'one' side of a one-to-many relationship to exist before you can reference it, the import order is strict: Companies first, then Locations (linked to Companies), then Opportunities. If you import Opportunities before Locations, the Location relation cannot be resolved and those Opportunities land without a site link — this requires a post-migration correction pass. We enforce the correct order in the migration script.

  • D-Tools API rate limits cap bulk extraction at 10,000 calls per day

    D-Tools' Cloud API enforces 120 requests per minute and 10,000 requests per day per API key. For D-Tools accounts with 50,000+ records across Clients, Contacts, Items, Projects, and Locations, a single full extraction can exceed the daily limit. We handle this by splitting the extraction into day-staggered batches with a cursor/pagination token, pausing at the daily limit and resuming the next day. The delta window (24–48 hours post cutover) also runs under the same rate limit, which can extend the final pickup by one additional day. We surface this constraint in the scoping call and confirm your D-Tools API key limits before committing to a timeline.

  • Integrations and third-party connections (accounting, payments, PSA) cannot migrate

    D-Tools integrates with accounting platforms, payment processors, and PSA tools via OAuth connections or middleware — these are external credentials, not data. Twenty does not carry over OAuth tokens, webhook subscriptions, or integration endpoints from D-Tools. Your team must rebuild each integration in Twenty's connected apps or via the Twenty REST/GraphQL API. Common rebuilds include: D-Tools Payments connections, QuickBooks or Xero sync, and RMM or PSA integrations for IT/MSP shops. We provide an integration inventory list from your D-Tools setup as part of the pre-migration audit so your team has a complete rebuild checklist before go-live.

Migration approach

Six steps for a successful D-Tools to Twenty CRM data migration

  1. Audit D-Tools data model and export all entities via REST API

    We connect to your D-Tools Cloud REST API using your API credentials and extract every entity: Clients, Contacts, Projects, Proposals, Items, Locations, and Service Plans. We pull the custom field schema per entity so we know every field that needs to exist in Twenty before import. If your D-Tools account has more than 10,000 records, we split extraction into day-staggered batches respecting the 120 req/min and 10,000 req/day rate limit. The output is a set of CSVs organized by entity, plus a schema JSON describing each custom field's type, label, and pick-list values.

  2. Map owners by email to Twenty WorkspaceMembers

    D-Tools stores an owner or creator user reference on Projects, Proposals, and Items — these are email addresses or user IDs. Twenty WorkspaceMembers are the equivalent of users. We run an email-match against your Twenty workspace: any D-Tools user whose email corresponds to an active Twenty WorkspaceMember gets their records assigned to that member. Unmatched owners are flagged and reported — your team either invites them to Twenty first or assigns a fallback owner. No record lands in Twenty without a resolved owner or a documented fallback.

  3. Create custom objects and fields in Twenty's data model before import

    Before any data moves, we create the schema that does not yet exist in Twenty: a Location custom object (linked to Companies), a ServicePlan custom object (linked to Companies), and any custom fields on Person, Company, and Opportunity that correspond to D-Tools custom fields (Item IDs, Proposal IDs, project values, billing frequency, and similar). This step follows Twenty's documented process: Settings → Data Model → Add Field, selecting the correct type (text, number, date, select). We create all fields first, then validate the schema against the D-Tools field list before running the import.

  4. Import in dependency order: Companies → People → Opportunities → Custom objects

    Twenty requires the 'one' side of relationships to exist before the 'many' side can reference them. We sequence the import as: (1) Companies — because People and Opportunities link to them; (2) People — linked to Companies via companyId; (3) Opportunities — linked to Companies and People via companyId and personId; (4) Location and ServicePlan custom objects — linked to Companies. Items are stored as custom fields on Opportunities rather than as separate objects. D-Tools workflow rules and integration connections are not imported — we export them as a rebuild-reference document for your Twenty admin.

  5. Run sample migration with field-level diff and validate mapping

    A representative slice of records (typically 100–300 across all entity types) migrates first. We generate a field-level diff: for each record, we compare every source field value against the corresponding Twenty field value and flag any fields that were skipped, truncated, or mapped incorrectly. The diff report is shared with your team for verification. You confirm that D-Tools custom fields are rendering correctly, that owner resolution by email is accurate, and that Opportunity stage mapping matches your configured Twenty pipeline. No full migration runs until you sign off on the sample results.

  6. Execute full migration with scoped-read delta window and rollback hold

    The full D-Tools dataset migrates into Twenty with all field mappings, custom objects, and owner resolution applied. During cutover, FlitStack AI holds scoped read access to D-Tools — your team continues working in D-Tools without interruption. A delta-pickup window (24–48 hours) captures any records created or modified in D-Tools after the full migration snapshot runs. An audit log records every operation. One-click rollback is available for 48 hours after go-live if reconciliation reveals mapping errors or data gaps.

Platform deep dives

Context on both ends of the pair

D-Tools logo

D-Tools

Source

Strengths

  • Purpose-built for low-voltage system integrators with industry-specific terminology and workflows.
  • i3 Integrated Product Library delivers real-time manufacturer pricing for accurate proposals.
  • Cloud and on-premises (SI) products cover both SMB and enterprise deployment needs.
  • Field-first mobile experience for technicians reduces office-to-field communication gaps.
  • Service plan management supports recurring revenue and monitoring agreement billing.

Weaknesses

  • Two distinct products (Cloud vs. SI) with separate APIs complicate cross-product migrations.
  • Support responsiveness is a recurring pain point in customer reviews, especially for pricing estimates.
  • Limited third-party integrations outside of QuickBooks and common accounting tools.
  • Custom report definitions do not export — customers must rebuild dashboards at the destination.
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?

Moderate CRM migration. 1 of 8 objects need a mapping; the rest are 1:1.

C

Overall complexity

Moderate migration

Derived from compatibility, mapping clarity, API constraints, and data volume across D-Tools 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

    C

    D-Tools: 120 API calls per minute and 10,000 API calls per day per key.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

D-Tools to Twenty migrations typically run 5–10 business days for under 5,000 total records across Clients, Contacts, Projects, Items, and Locations. Accounts with 50,000+ records or heavy custom-field usage extend to 3–4 weeks, driven by the time needed to create Twenty custom objects, validate field-level mapping, and manage D-Tools API rate limits (10,000 calls/day). The pre-migration schema setup phase — creating custom objects in Twenty before data lands — typically takes 2–3 days and runs in parallel with the data audit.

Adjacent paths

Related migrations to explore

Ready when you are

Move from D-Tools.
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