CRM migration

Migrate from e-shot to Twenty CRM

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

e-shot logo

e-shot

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

50%

6 of 12

objects map 1:1 between e-shot and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

e-shot is a contact-centric email marketing platform; Twenty CRM is a relational CRM with Company, Person, and Opportunity objects. These are fundamentally different data models, so migration from e-shot to Twenty is a re-design as much as a data move. We extract e-shot contacts with their custom field definitions and merge-tag fallback rules, then map them into Twenty's Person object with optional Company linking. Automated Series and campaign engagement history do not have native Twenty equivalents — we represent them as custom object records and a written automation rebuild guide for the customer's admin. Preference centre data becomes custom fields on Person. Saved filters and segment logic are documented for manual rebuild in Twenty's views. Landing pages, forms, and website popups are not migrated as functional objects; we deliver a written inventory of these items requiring rebuild in Twenty or a replacement tool.

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

e-shot logo

e-shot

What's pushing teams away

  • Import failures and intermittent system reliability frustrate users — contacts sometimes fail to load and template rendering breaks unpredictably, requiring manual intervention.
  • The analytics interface is widely regarded as dated and unintuitive, prompting teams to export data to external BI tools rather than rely on in-platform reporting.
  • The basic tier caps active Preferences at 25 and Automated Series at 3, which forces growing teams to upgrade or manage within artificially constrained campaign structures.
  • Some users report the platform feels slower than competing email tools during high-volume sends, particularly on the basic tier with lower API rate limits.

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

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

e-shot

Contact

maps to

Twenty CRM

Person

1:1
Fully supported

e-shot Contacts map to Twenty Person records. Every standard system field (email, name, phone, address) maps directly. Custom contact fields defined in e-shot Settings > Contacts Field Manager must be pre-created in Twenty as custom fields on Person before import. We extract the full field schema including field type, required flag, and any picklist options. Tag assignments stored as list membership in e-shot are resolved and written to a tags__c multi-select field on Person.

e-shot

Contact Fields

maps to

Twenty CRM

Person (custom fields)

lossy
Mapping required

e-shot's fully customisable contact field schema requires pre-creation in Twenty before any records load. We extract every field definition (name, type, merge-tag syntax *_fieldname_*) and replicate it in Twenty's Settings > Data Model as custom fields on Person. The mapping document is the critical dependency: without it, imports fail on undefined field references. Field type translation includes date fields, numeric fields, boolean checkboxes, and picklist values.

e-shot

Campaign

maps to

Twenty CRM

Custom Object: Campaign

1:1
Fully supported

e-shot Campaigns do not have a native Twenty equivalent. We create a Campaign custom object in Twenty with fields for campaign name, subject line, send date, open rate, click rate, bounce rate, and unsubscribe rate pulled from campaign report data. Campaign content (HTML body, template assets) is preserved as Notes attached to the Campaign custom object record. This is a re-design decision: the customer chooses whether to migrate historical campaign metrics as audit records or to start fresh with new campaign tracking post-migration.

e-shot

Automated Series

maps to

Twenty CRM

Custom Object: Automated Series (audit) + rebuild guide

lossy
Mapping required

e-shot Automated Series are workflow-based email sequences with trigger conditions and delays. Twenty has no native equivalent to marketing automation sequences. We export the series name, trigger condition, step count, and step content as records in a Campaign Automation custom object for audit purposes. The customer receives a written rebuild guide that documents each series as a step-by-step workflow description with recommended Twenty or third-party automation alternatives (such as n8n, Make, or a custom GraphQL workflow) so the admin can rebuild sequences post-migration.

e-shot

Forms

maps to

Twenty CRM

Note or Custom Object

1:1
Fully supported

e-shot Forms store field definitions, form structure, and contact inputs. We export form field types and labels as a form definition record in a Form custom object in Twenty. Form submission data (actual contact responses) is written to the related Person record where the form field matches a custom field. Form configuration (redirect URLs, thank-you messages) is preserved in the notes field for manual rebuild.

e-shot

Preferences

maps to

Twenty CRM

Person (custom fields)

1:1
Mapping required

e-shot contact preferences track opt-in status and subscription interests. These map to custom fields on the Twenty Person record — one custom field per preference topic. Tier limits on active preferences in e-shot (basic: 25, pro: 50, omni: unlimited) do not apply in Twenty; we create all preference fields within the customer's custom field budget. Preference values migrate as field values, not as a separate preference centre object.

e-shot

Tags

maps to

Twenty CRM

Person.tags__c (multi-select picklist)

lossy
Mapping required

e-shot tags are stored as field values or list memberships, not as a separate tag management object. We extract every distinct tag value across all contacts and create a multi-select picklist field tags__c on the Person object in Twenty. Tag assignments per contact are written as pipe-delimited values in the field. If more than 200 distinct tags exist, we recommend a separate Tags custom object with a many-to-many relationship to Person via a junction table.

e-shot

Saved Filters

maps to

Twenty CRM

Twenty Views (manual rebuild)

lossy
Mapping required

e-shot Saved Filters define dynamic contact segments using field conditions. We export the filter name and full condition logic (field, operator, value) for each active saved filter as a written specification document. Twenty Views replicate saved filter functionality using field-based filtering. The customer's admin rebuilds each view in Twenty using the exported filter specification. Filter logic does not migrate as code.

e-shot

Campaign Reports

maps to

Twenty CRM

Campaign custom object records

1:1
Fully supported

e-shot campaign analytics (opens, clicks, bounces, unsubscribes, delivery health) are exportable from the analytics dashboard. We pull historical report snapshots per campaign and write them as custom fields on the Campaign custom object records created during migration. This preserves campaign performance data for historical reference and reporting in Twenty's analytics views.

e-shot

Templates

maps to

Twenty CRM

Note (attached to Person or Campaign)

1:1
Fully supported

e-shot email templates store reusable HTML content blocks with embedded styles and merge tags. We export templates as HTML files and attach them as Notes to the relevant Person or Campaign record in Twenty. Merge tag syntax (*_fieldname_*) is preserved as-is in the template body for manual reactivation in a template tool post-migration. If the customer uses Twenty's note-based template system, we provide a template mapping guide.

e-shot

Landing Pages

maps to

Twenty CRM

Written inventory for rebuild

lossy
Mapping required

e-shot Landing Pages are tier-gated (basic: 0, pro: 25, omni: 100) and hold published content with form elements. Twenty has no native landing page builder. We export landing page content as HTML files and form field mappings as a written inventory. The customer's admin rebuilds landing pages in a dedicated landing page tool (Twenty compatible or standalone) and maps form submissions to Twenty Person records using the exported field mapping.

e-shot

Website Popups

maps to

Twenty CRM

Written inventory for rebuild

lossy
Mapping required

e-shot Website Popups are campaign-triggered web overlays tied to contact identification. Tier limits apply (basic: 0, pro: 25, omni: 100). Twenty has no native popup or website overlay feature. We export popup configurations, trigger rules, and display logic as a written inventory. The customer rebuilds popup functionality in a website overlay tool compatible with Twenty's tracking (e.g., OptinMonster, Privy) and maps new submissions to Twenty Person records.

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.

e-shot logo

e-shot gotchas

Medium

File attachments blocked in bulk email sends

Low

Tier limits apply to active (live) objects only

Medium

Merge-tag fallback values must be replicated

Low

No dedicated bulk export endpoint documented

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

  • e-shot and Twenty have fundamentally different data models

    e-shot is contact-centric with campaign tracking as the primary data dimension. Twenty is a relational CRM built around Company, Person, and Opportunity with custom objects for extensions. There is no native Campaign, Series, or Preference Centre object in Twenty. Migration from e-shot to Twenty is a re-design: contacts map to Person, but campaign engagement history, automation sequences, and preference centre data require custom object creation or manual rebuild. Teams that expect a record-for-record copy without re-design work will encounter data model gaps at cutover validation.

  • No bulk export endpoint in e-shot; pagination required

    e-shot's REST API does not publish a dedicated bulk-export endpoint. High-volume contact exports require paginated API calls within the per-hour rate limit (500 on basic, 2,000 on pro, 5,000 on omni). We implement throttled pagination with resume logic to extract large contact lists without exceeding the plan's hourly cap. Migrations over 50,000 contacts on a basic or pro plan require multiple extraction sessions scheduled across hours to stay within the rate limit. We flag this during scoping so the extraction window does not conflict with active campaign sends.

  • Merge-tag fallback values must be replicated in Twenty

    e-shot's personalisation uses a *_fieldname=fallback('text')_* syntax for contacts that lack a field value. If fallback values are not set on the destination, contacts without that field populated display raw merge tags to recipients. We extract every fallback definition from e-shot's contact field manager and create equivalent default-value rules in Twenty custom fields before loading contacts. This step is done in the schema design phase, not during data load, because Twenty does not support inline fallback syntax the way e-shot does.

  • Twenty requires custom fields to exist before CSV import

    Twenty's CSV import creates records but does not create fields. All custom fields (for custom contact fields, preference fields, and any campaign tracking fields) must be created in Twenty Settings > Data Model before any data import begins. We create the full field schema in Twenty before any records load, using the e-shot field definition export as the source of truth. Fields created after initial import require a second import pass for those records; we avoid this by completing schema design in the sandbox validation phase.

  • Landing pages, forms, and website popups do not migrate as functional objects

    e-shot Landing Pages, Forms, and Website Popups are tier-gated features with no direct Twenty equivalent. We do not migrate these as functional objects. We deliver a written inventory for each item (content export, form field mapping, trigger logic) so the customer's admin can rebuild them in a compatible replacement tool and reconnect form submissions to Twenty Person records via the API or CSV import.

Migration approach

Six steps for a successful e-shot to Twenty CRM data migration

  1. Discovery and schema audit

    We audit the source e-shot account across tier (basic/pro/omni), active contact count, custom contact field definitions, active Automated Series count, landing page count, form definitions, preference centre structure, saved filter definitions, and campaign report history. We pair this with a Twenty workspace readiness check: custom object creation permissions, available custom field slots, and self-hosted vs SaaS deployment choice. The discovery output is a written migration scope with object-level row counts and a Twenty schema design document.

  2. Schema design in Twenty

    We design the destination schema in Twenty's Settings > Data Model. This includes creating the Campaign custom object (if campaign history is in scope), the Campaign Automation custom object for Series audit records, and any custom fields on Person for contact fields, preferences, and tags. We pre-create all fields before any import begins to avoid the CSV import rejecting records on undefined field references. Schema is validated in a Twenty sandbox or secondary workspace before production migration.

  3. Paginated extraction from e-shot API

    We extract contacts via paginated e-shot REST API calls, throttled to the account's per-hour rate limit. For basic and pro plans with large contact lists, extraction runs across multiple sessions to avoid hitting the hourly cap during active campaign windows. Custom field values, tag assignments, and preference data are included in each contact record export. Campaign report data is pulled from the analytics dashboard export function in parallel. We implement resume logic so a session interruption does not require restarting from record one.

  4. Data transformation and merge-tag fallback replication

    We transform e-shot contact records into Twenty Person records, mapping standard fields (name, email, phone, address) directly and writing custom field values to the corresponding Twenty custom fields created in schema design. Every merge-tag fallback definition from e-shot is written as a default value on the corresponding Twenty custom field. Tag assignments are consolidated into the tags__c multi-select field. The transformation output is a set of CSV files organised by object type, ready for Twenty import.

  5. Sandbox validation and reconciliation

    We run a full migration into a Twenty sandbox workspace or secondary instance using production-like data volume. The customer's admin reviews record counts (Persons in, Companies linked, preference fields populated, tags assigned), spot-checks 25-50 random Person records against the source e-shot contact data, and validates that custom field types and picklist values are correctly set. Schema corrections and mapping adjustments happen here before production migration begins.

  6. Production migration and cutover

    We run production migration in dependency order: custom fields (already created), Persons (from e-shot contacts), Companies (extracted from contact domain or company field), Company-to-Person linking, preference data, tag assignments, Campaign custom object records (if in scope), Campaign Automation audit records, and campaign report data. We freeze e-shot writes during the cutover window, run a final delta extraction of any records modified during migration, then mark Twenty as the system of record. We deliver the automation rebuild guide, landing page inventory, and form inventory documents to the customer's admin team.

Platform deep dives

Context on both ends of the pair

e-shot logo

e-shot

Source

Strengths

  • Tiered pricing from £200/month provides a clear upgrade path without per-seat licensing on any plan.
  • Unlimited users across all tiers means whole teams can access the platform without incremental cost.
  • Dedicated deliverability tooling for Microsoft contacts, important for UK enterprise senders on Microsoft 365.
  • Contact field manager and merge-tag fallback syntax give non-technical users granular personalisation control.
  • Open API with JSON REST endpoints and tiered rate limits up to 5,000 calls per hour on omni.

Weaknesses

  • Analytics UI is repeatedly described as dated and difficult to navigate compared to modern email platforms.
  • Import reliability issues and intermittent system downtime affect campaign and contact loading.
  • Landing page and automation features are tier-gated, requiring upgrades as team complexity grows.
  • Basic tier has hard limits on live preferences, series, filters, and popups that constrain active campaigns.
  • Template design tools lack some drag-and-drop flexibility found in newer email builders.
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 e-shot 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

    e-shot: 500–5,000 requests per hour depending on tier (basic: 500, pro: 2,000, omni: 5,000).

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most migrations land between three and five weeks for accounts under 20,000 contacts with no campaign history carry-over and straightforward custom field mapping. Migrations that include Automated Series as custom object records, historical campaign report imports, preference centre re-design, and saved filter documentation extend to eight to twelve weeks because of the schema re-design work, custom object creation, and manual rebuild documentation. Self-hosted Twenty deployments require additional time for infrastructure provisioning before migration begins.

Adjacent paths

Related migrations to explore

Ready when you are

Move from e-shot.
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