CRM migration

Migrate from Dashcord to Twenty CRM

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

Dashcord logo

Dashcord

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

50%

6 of 12

objects map 1:1 between Dashcord and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Dashcord to Twenty CRM is a cross-platform data migration with a structural twist: all Dashcord data lives inside a Salesforce org as standard CRM objects and custom Dashcord package objects. We authenticate into your Salesforce org via OAuth, introspect the active metadata via the Tooling API to discover Dashcord-specific custom fields and picklist values, then transform and load into Twenty's Company, People, and Opportunity model. Dashcord's lifecycle stages, lead scores, event records, and campaign attribution data require field-level mapping because neither Dashcord nor Twenty documents these mappings publicly. We do not migrate automations, event triggers, or campaign workflow rules; we deliver a written inventory of every active Dashcord workflow and event automation requiring rebuild in Twenty's Settings → Workflow section.

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

Dashcord logo

Dashcord

What's pushing teams away

  • The interface is consistently described as not visually pleasing and not user-friendly, with a steeper learning curve than alternatives despite the on-platform positioning.
  • Small vendor risk concerns — the company has only 2 employees according to LinkedIn and RocketReach data, raising questions about long-term support and product roadmap stability.
  • Pricing is not publicly listed and requires contacting sales, which frustrates buyers evaluating Dashcord against transparent SaaS competitors.
  • Customers report difficulty finding documentation or support beyond direct vendor contact, making troubleshooting and onboarding harder than expected.
  • Lack of public API documentation means technical teams cannot self-serve integration work or automated exports, driving teams to platforms with better developer access.

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

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

Dashcord

Contact

maps to

Twenty CRM

People

1:1
Fully supported

Dashcord Contacts map to Twenty People records. We read Contact records via the Salesforce API with all standard fields (Name, Email, Phone, Title, Address) plus any Dashcord-specific custom contact properties discovered during metadata introspection. The Twenty People record is created first so that any related Activities, Notes, or Tasks can be linked at migration time. Email serves as the dedupe key.

Dashcord

Account

maps to

Twenty CRM

Company

1:1
Fully supported

Dashcord Accounts map to Twenty Companies. The Account Name becomes Company name, Billing Address migrates to the Company address fields, and Industry and Annual Revenue become custom or standard Company fields as applicable. Account is created before any related People import so the relationship is satisfied on insert.

Dashcord

Lead

maps to

Twenty CRM

People

1:1
Fully supported

Dashcord Leads map to Twenty People records with a type distinction. We preserve the Lead Status and any Dashcord custom lead fields on the People record and flag the record source in a custom field for segmentation. The customer's team reviews the Lead-to-People boundary during scoping because Twenty has no separate Lead object; unqualified prospects live as People with a status property.

Dashcord

Campaign

maps to

Twenty CRM

Custom Object (Campaign equivalent)

lossy
Fully supported

Dashcord wraps Salesforce Campaigns for marketing automation. We export Campaign records and create a corresponding custom object in Twenty named Campaign (or the customer's preferred label) with fields for Campaign Name, Status, Type, Start Date, and Budget. Campaign Members map separately (see below). If the customer does not require campaign history preservation, we exclude Campaigns from migration scope to reduce complexity.

Dashcord

Campaign Member

maps to

Twenty CRM

Custom Object (CampaignMember equivalent)

lossy
Fully supported

Campaign Members link Contacts and Leads to Campaigns with status and response tracking data. We create a Campaign Member custom object in Twenty with a Lookup to the Campaign custom object and a Lookup to the People record, plus fields for Status and Member Status. The relationship is resolved at migration time by loading Campaigns first, then People, then Campaign Members last so both parent lookups exist.

Dashcord

Opportunity

maps to

Twenty CRM

Opportunity

1:1
Fully supported

If the Dashcord Salesforce org includes Opportunities (Enterprise tier or custom), we map them to Twenty Opportunities. Stage, Amount, Close Date, and Description migrate directly. The Pipeline and Stage values require a configuration step in Twenty's Settings to whitelist the imported stage names before migration, per Twenty's requirement that fields exist before CSV import.

Dashcord

Lifecycle Stage

maps to

Twenty CRM

Custom Field on People

lossy
Fully supported

Dashcord assigns lifecycle stage values (subscriber, lead, MQL, SQL, customer, etc.) stored as custom picklist or number fields on Lead and Contact. These have no direct Twenty equivalent — Twenty has no native lifecycle stage concept. We create a custom picklist field named Lifecycle Stage on the People object, populate it with the distinct Dashcord lifecycle values discovered during schema introspection, and migrate the raw stage value for each record.

Dashcord

Lead Scoring

maps to

Twenty CRM

Custom Field on People

lossy
Mapping required

Dashcord stores numeric or tiered lead scores as custom fields on Lead records. We create a custom number field Score on the People object, migrate the raw score value, and note the scoring model name or rule reference if stored in a separate Dashcord custom object. The scoring model itself (the rules that produced the score) is not migratable and must be rebuilt in Twenty or via an external scoring tool.

Dashcord

Event (Dashcord custom object)

maps to

Twenty CRM

Custom Object (Event)

lossy
Fully supported

Dashcord's event management module stores records as Salesforce custom objects whose schema varies by Dashcord package version. We discover the active event object name and field definitions during pre-flight metadata introspection, export the records, then create a matching custom object in Twenty named Event with fields for Name, Date, Type, Location, and any Dashcord-specific properties. Relationships to People (attendees) migrate as multi-select or linked records depending on the event model.

Dashcord

Email Activity

maps to

Twenty CRM

Task

1:1
Fully supported

Dashcord tracks email sends, opens, and clicks via Salesforce Task and Email records. We export Tasks linked to Contacts and Leads where the Subject or Type indicates email activity, preserving the original timestamp, subject line, and body. The migrated Tasks attach to the corresponding Twenty People record via the email address match. Note that Dashcord's email marketing attribution (which campaign drove the send) requires a separate Campaign Member mapping if the customer needs campaign-level attribution preserved.

Dashcord

Attachment / ContentDocument

maps to

Twenty CRM

Attachment via custom field or link

1:1
Fully supported

File attachments on Contact, Account, or Campaign records are stored in Salesforce ContentDocument and ContentDocumentLink. We export the file binary data and store it as a link or file reference on the corresponding Twenty People or Company record. Large file attachments (over 10 MB) require the customer's chosen Twenty hosting method to support the storage size; self-hosted deployments may need additional storage configuration.

Dashcord

Custom Dashcord Properties

maps to

Twenty CRM

Custom Fields

lossy
Fully supported

Any custom fields added by Dashcord or created on top of the package are Salesforce custom fields. We read field metadata via the Salesforce Tooling API during pre-flight, enumerate all active custom properties on each object, create matching custom fields in Twenty's Data Model, then map the values during data migration. Undocumented or renamed Dashcord custom fields require manual enumeration during scoping because no public schema reference exists.

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.

Dashcord logo

Dashcord gotchas

High

No publicly documented API endpoint for Dashcord

High

Dashcord data model not independently documented

Medium

Salesforce Edition gating may restrict API access

Medium

No public pricing tiers means migration scoping has no self-serve reference

Low

Small vendor elevates product discontinuation risk

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

  • Dashcord has no public API or documented data model

    Dashcord does not publish API documentation or a data dictionary for its custom objects. All data access happens through the Salesforce REST or Bulk API against the host org. We authenticate via OAuth into the customer's Salesforce org and query Salesforce objects directly, then discover the active Dashcord custom schema by introspecting the org's metadata via the Tooling API before migration. Schema drift between Dashcord package versions affects what we find in a given org. This pre-flight discovery step adds 3-5 business days to the timeline and must complete before we can finalize the field mapping.

  • Twenty requires custom fields and objects created before import

    Twenty's CSV import creates records, not fields. Per Twenty's documentation, all custom fields and custom objects must exist in Settings → Data Model before any data import begins. Dashcord's undocumented custom fields (lifecycle stages, lead scores, event properties) require us to first discover the active schema, then pre-create matching fields in Twenty before loading data. If the customer has a large number of custom Dashcord fields, field creation in Twenty becomes a manual step that must complete before migration proceeds. We cannot skip this step or automate it without the schema inventory.

  • Salesforce Edition API gating may restrict export method

    Dashcord customers on Salesforce Group or Professional Edition have capped API usage, which can limit bulk data export via the Salesforce REST API. We check the org's edition during scoping. If API access is insufficient, we fall back to Salesforce Data Loader exports (CSV) which are API-free. Data Loader exports lack relationship metadata and require us to reconstruct the parent-child relationships (Account-Contact, Campaign-CampaignMember) from IDs during transformation, adding transformation complexity and timeline.

  • Dashcord automations and event triggers do not migrate

    Dashcord stores event management triggers and lifecycle automation rules inside its Salesforce package. These automations have no documented export mechanism and do not map to Twenty's workflow engine. We deliver a written inventory of every active Dashcord automation (event triggers, lifecycle stage-change actions, lead scoring rule sets) for the customer's admin to rebuild in Twenty's Settings → Workflows section. The rebuild scope is not included in the migration engagement. Campaign workflows and event attendance triggers are particularly likely to require redesign rather than direct translation.

  • Twenty has no native Campaign object or Marketing automation

    Twenty CRM does not include a native Campaign or marketing automation object in its standard data model. Teams migrating Dashcord's marketing automation features (campaigns, campaign members, event triggers) must decide whether to recreate these as custom objects in Twenty or move marketing automation to a separate tool. We create Campaign and Campaign Member as custom objects during migration, but the workflow layer above them (automated enrollment, stage-change triggers, drip sequences) must be rebuilt manually in Twenty's Workflow engine or addressed through a separate marketing automation tool selection.

Migration approach

Six steps for a successful Dashcord to Twenty CRM data migration

  1. Salesforce org authentication and metadata discovery

    We authenticate into the customer's Salesforce org via OAuth using an API-enabled user account. We run a metadata introspection using the Salesforce Tooling API to enumerate all active Dashcord package custom objects, custom fields, and picklist values in the org. This discovery step identifies the event custom object (schema varies by Dashcord version), lifecycle stage field name and values, lead score field and any associated scoring model objects, and any custom properties added by the customer's Salesforce admin on top of the Dashcord package. The discovery output is a written schema inventory we use to design the Twenty destination schema.

  2. Twenty workspace provisioning and schema design

    We provision a Twenty workspace (self-hosted or cloud, per the customer's choice) and design the destination schema based on the discovered Dashcord Salesforce schema. This includes creating custom objects for Campaign and Campaign Member, creating custom fields for Lifecycle Stage and Score on the People object, creating the Event custom object with fields matching the discovered Dashcord event schema, and configuring Opportunity stage values if Opportunities are in scope. We configure picklist values for Lifecycle Stage using the distinct values found during Salesforce metadata discovery. Fields must exist in Twenty before any import begins; we complete this step before production migration.

  3. Sandbox migration and schema validation

    We run a full migration into a staging environment using production-like data volume extracted from the Salesforce org. The customer's team reconciles record counts (People, Companies, Opportunities, Events, Activities), spot-checks 25-50 records against the Salesforce source for field-level accuracy, and validates that the Lifecycle Stage and Score values populated correctly. Any field mapping corrections, picklist value mismatches, or custom object relationship issues surface here. We do not proceed to production migration until the customer signs off on the sandbox validation report.

  4. Owner and user reconciliation

    Dashcord stores record ownership through Salesforce User records. We extract every distinct OwnerId referenced on Contact, Account, Opportunity, and Activity records and match by email against the Twenty workspace's Members list. Any Dashcord owners without a matching Twenty user go to a reconciliation queue. The customer creates Twenty accounts for all active owners before the production migration begins. OwnerId references on imported records must resolve at insert time; unresolvable owners default to the migrating admin or are held for post-migration assignment.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Companies (from Salesforce Accounts) first, then People (from Contacts and Leads with the lifecycle stage transform applied), then Opportunities, then Campaign and Campaign Member custom objects, then Event records, then Activity history (Tasks via Salesforce Bulk API 2.0 with chunking and parent-record resolution), then any remaining custom Dashcord properties. Each phase emits a row-count reconciliation report before the next phase begins. Dashcord lifecycle stage values and lead scores land in their corresponding Twenty custom fields during the People phase.

  6. Cutover, validation, and automation inventory handoff

    We freeze Salesforce org writes during cutover, run a final delta migration of any records modified during the migration window, then designate Twenty as the system of record. We deliver the Automation and Workflow Inventory document listing every active Dashcord automation (event triggers, lifecycle change actions, lead scoring rules) with a description of current behavior and a recommended Twenty Workflow rebuild approach. We do not rebuild Dashcord automations as Twenty Workflows inside the migration scope. We support a one-week post-cutover reconciliation window to address record-level issues raised by the customer's team.

Platform deep dives

Context on both ends of the pair

Dashcord logo

Dashcord

Source

Strengths

  • Fully native AppExchange package — installs inside Salesforce with no separate login or middleware layer.
  • Provides lead scoring, lifecycle automation, event management, and analytics in a single Salesforce-native tool.
  • Removes manual Salesforce sync work for organizations already invested in the Salesforce ecosystem.
  • Bidirectional data flow with Salesforce org means marketing and sales data remain consistent without manual intervention.
  • Supports mass email and email marketing directly within the Salesforce platform.

Weaknesses

  • Small vendor with only 2 employees — limited support capacity and elevated long-term product continuity risk.
  • No publicly documented API — technical teams cannot build external integrations or automated exports.
  • Interface consistently described as visually underwhelming and harder to navigate than competing tools.
  • Pricing is opaque — no public tier information, requiring a sales call for any evaluation.
  • Extremely limited public presence (130 LinkedIn followers, minimal review volume) makes independent due diligence difficult.
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 Dashcord 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

    Dashcord: Salesforce API limits apply — determined by Salesforce Edition (Group/Professional editions are capped; Enterprise and above have higher limits).

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Dashcord migrations complete in three to five weeks for orgs under 10,000 Contacts, 2,000 Accounts, and 500 Events with no complex custom Dashcord field sets. Migrations requiring extensive metadata discovery (undocumented Dashcord custom objects), Salesforce Group/Professional Edition API fallback to Data Loader, or preservation of large engagement histories (over 200,000 activity records) extend to six to ten weeks. The pre-flight metadata discovery step alone takes 3-5 business days because Dashcord does not publish its Salesforce schema.

Adjacent paths

Related migrations to explore

Ready when you are

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