CRM migration

Migrate from SellingLane CRM to Twenty CRM

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

SellingLane CRM logo

SellingLane CRM

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

70%

7 of 10

objects map 1:1 between SellingLane CRM and Twenty CRM.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from SellingLane CRM to Twenty CRM is a shift from an auction-specific niche platform to a general-purpose open-source CRM with a modern TypeScript/React interface and full data ownership. SellingLane's buyer lifecycle model (registration through checkout) maps directly into Twenty's Person and Company objects, but auction-specific objects like Lots, Bids, and Auction Events require custom object definitions in Twenty because they have no native equivalent. We discover Lot-level custom field schemas during the audit phase, sequence Lot records before Bid records to preserve Buyer-to-Lot foreign-key relationships, and reconstruct Auction Event groupings as date-anchored custom records or tag-based groupings depending on the customer's reporting needs. Twenty's GraphQL API and /metadata endpoint govern the custom object creation process, and the platform's self-hosted AGPL-3.0 model eliminates the per-seat or per-transaction billing that drives SellingLane customers to look elsewhere. Workflows, automations, and auction event triggers do not migrate; we deliver a written inventory of these for the customer's technical team to rebuild in Twenty or a separate automation layer.

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

SellingLane CRM logo

SellingLane CRM

What's pushing teams away

  • The platform is narrowly scoped to auction workflows, so teams that expand into broader sales, marketing, or service use cases outgrow the feature set.
  • Limited third-party integrations compared to mainstream CRMs forces teams to maintain workarounds for accounting, email, or analytics tools they already use.
  • Small user base and minimal public API documentation make it difficult for technical teams to extend functionality or build custom integrations.
  • Sparse online reviews and a lack of a robust app marketplace signal limited community support and third-party tooling compared to established CRM vendors.
  • Auction-specific terminology and data model require significant re-training when staff transition to a general-purpose CRM.

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

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

SellingLane CRM

Buyer

maps to

Twenty CRM

Person

1:1
Fully supported

SellingLane Buyer records migrate as Twenty Person records. Bidder ID, registration date, and verification status transfer as custom fields on Person. We preserve bidder tier or standing as a custom picklist field. SellingLane's custom Buyer fields are discovered during the audit phase and mapped individually. Email uniqueness is validated before insert to prevent duplicate Person records in Twenty.

SellingLane CRM

Lot

maps to

Twenty CRM

Custom Object (Lot)

1:1
Fully supported

SellingLane Lots map to a Twenty custom object we create via the /metadata API before migration. Lot number becomes the custom object's name field, item description becomes a text field, and reserve price and starting bid transfer as numeric fields. Any reserve-status logic (met, not met, no reserve) migrates as a custom picklist. Custom fields on Lots require schema discovery during audit because SellingLane does not publicly document them; we query the field configuration endpoint, cross-reference against live Lot records, and flag any deprecated or silently dropped custom field definitions before final import.

SellingLane CRM

Bid

maps to

Twenty CRM

Custom Object (Bid)

1:1
Fully supported

Bid records are relational: each bid links a Buyer (Person) to a Lot (custom object) with a timestamp, amount, and bid type (floor, absentee, online). Bids cannot be imported before Lots because the Lot foreign key must be resolved at insert time. We export Lots first, then Bids, and include the lot_id reference in our staging schema before final import to avoid orphaned bid records. Bid type and timestamp migrate as typed fields on the Bid custom object. The bid stack ordering (which bid won the lot) is validated against SellingLane's final sale outcome before import.

SellingLane CRM

Auction Event

maps to

Twenty CRM

Custom Object (Auction Event)

lossy
Fully supported

SellingLane Auction Events group Lots and Bids by sale date, location, and catalog. Twenty has no native Events object, so we create a custom AuctionEvent object via the /metadata API. Events are imported as parent records before Lots, with event metadata (date, location, catalog reference) stored as fields. Lots and Bids then carry a lookup to their parent AuctionEvent. Alternatively, if the customer prefers a lightweight model, we tag Lots with event metadata using Twenty's label/tag capability and anchor event groupings by date range. The customer chooses the model during scoping.

SellingLane CRM

Registration

maps to

Twenty CRM

Custom Object (Registration)

1:1
Fully supported

Registration records include buyer ID, event ID, registration date, and payment method on file. These map to a Twenty custom Registration object with lookups to Person (buyer) and AuctionEvent. We export Registrations after Person and AuctionEvent records are present in Twenty so that the foreign-key lookups resolve at insert time. Payment method on file migrates as a text field or custom picklist depending on SellingLane's picklist configuration.

SellingLane CRM

Payment/Checkout

maps to

Twenty CRM

Custom Object (Payment)

1:1
Fully supported

Post-sale payment records (amount, method, date, buyer association) migrate to a Twenty custom Payment object with a lookup to Person. Where SellingLane tracks trust-account balances, we migrate the most recent balance as a numeric field on the Buyer (Person) record and flag any trust-account carry-forward logic in the migration notes for the customer's admin to verify. Payment method maps to a custom picklist matching SellingLane's active values.

SellingLane CRM

Pipeline Stages

maps to

Twenty CRM

Opportunity Stage

lossy
Fully supported

SellingLane auction workflow stages (Registered, Won, Lost, Paid, Closed) map to Twenty's Opportunities pipeline stages. We configure the stage values in Twenty during workspace setup, mapping each SellingLane stage to a named Opportunity stage with an appropriate probability percentage. Stage names are normalized to align with Twenty's terminology while preserving the original SellingLane stage label in a custom field for audit.

SellingLane CRM

Owner/User

maps to

Twenty CRM

User

1:1
Fully supported

SellingLane staff assigned as lot owners or bidder managers map to Twenty Users. We validate email uniqueness across all owner records before import and flag any duplicate email addresses that would cause import failures. Users without a matching email in the destination are held in a reconciliation queue for the customer to provision before record import proceeds.

SellingLane CRM

Attachment

maps to

Twenty CRM

File (via storage)

1:1
Fully supported

Item photos, condition reports, and registration documents attach to Lots and Buyers. We export attachments from SellingLane's file storage and re-associate them in Twenty using a naming convention that links files to their parent record (Lot or Person). The migration does not include attachment re-upload if SellingLane's file storage API is restricted; in that case, we deliver a file manifest with URLs or storage paths so the customer's team can manually re-associate attachments in Twenty.

SellingLane CRM

Tag/Label

maps to

Twenty CRM

Tag

lossy
Fully supported

Lots and Buyers may carry classification tags in SellingLane. We export all tag sets and apply them as Tags in Twenty, noting that tag-based automations in SellingLane do not transfer and must be documented for rebuild in Twenty's workflow layer or a third-party automation tool.

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.

SellingLane CRM logo

SellingLane CRM gotchas

Medium

Custom fields on lots are not schema-documented

High

Bid history relies on Lot-to-Buyer relational links

Medium

Auction event groupings must be reconstructed

Low

Buyer verification status is a custom field

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

  • Bid history Lot-to-Buyer relational links must be preserved

    SellingLane Bid records are not standalone; each bid links a Buyer to a Lot and carries a timestamp and amount. A flat CSV export of bids loses the Lot context unless Lots are exported first and Bids are re-associated by matching lot_id. We sequence the migration to load custom Lot records before Bid records, include the foreign-key reference in our staging schema, and resolve the Person-to-Lot lookup at insert time. If Lots are not loaded first, bids end up with null Lot references, breaking the auction sale reconstruction that buyers expect to see in the new CRM.

  • Lot custom field schema requires discovery during audit

    SellingLane supports custom fields on auction listings but does not publicly document the schema. We discover custom field definitions during the audit phase by querying the platform's field configuration endpoint, generating a complete field manifest before mapping to Twenty. Any custom field with a deprecated or deleted definition in SellingLane can silently drop values. We cross-reference every custom field against live Lot records to confirm data completeness before committing the migration, and we alert customers if any Lot's custom field values use a deprecated picklist no longer in the active definition.

  • Auction Event groupings require a custom object strategy

    SellingLane organizes Lots by Auction Event (sale date, location, catalog). Twenty has no native Events object, so we map events as date-anchored custom records or tag Lots with event metadata. We flag this gap during the scoping call so the customer decides whether to reconstruct event groupings as parent custom records (with Lots and Bids as children) or treat Lots as independent inventory records tagged by event date. The choice affects reporting and filtering in Twenty post-migration.

  • Twenty requires developer setup for custom objects and self-hosting

    Twenty's custom object creation uses the /metadata GraphQL API and requires a workspaceMember with appropriate permissions to define the object schema before data import. Self-hosted deployments require Docker setup and ongoing maintenance on the customer's infrastructure. We coordinate the /metadata API schema creation during the migration but do not provide ongoing hosting support for self-hosted Twenty instances. Customers choosing the Twenty cloud option can skip self-hosting complexity at $9/user/month.

  • Buyer verification status is a custom field in SellingLane

    Bidder verification status (approved, pending, suspended) is stored as a custom property on the Buyer record in SellingLane rather than a native enumerated field. During migration we flag verification status as a mapped custom field on the Person object and confirm Twenty's schema accommodates the same picklist values. We also alert customers if any buyer's verification status was set to a deprecated value no longer in the active picklist, so the customer can decide whether to normalize or preserve the legacy value.

Migration approach

Six steps for a successful SellingLane CRM to Twenty CRM data migration

  1. Discovery and SellingLane schema audit

    We audit the SellingLane CRM environment across Buyer records, Lot catalogs, Bid histories, Auction Events, Registrations, Payments, custom field definitions, and owner assignments. We query SellingLane's field configuration endpoint to discover custom field schemas on Lots and Buyers that are not publicly documented. The audit output is a complete field manifest and a written migration scope covering record counts, schema dependencies, and any deprecated picklist values that require normalization before import.

  2. Twenty workspace setup and custom object creation

    We provision the Twenty workspace and create custom objects (Lot, Bid, AuctionEvent, Registration, Payment) via the /metadata API before any data import. Standard objects (Person, Company, Opportunity, Task) are mapped from SellingLane equivalents. We configure Opportunity pipeline stages to match SellingLane's auction workflow stages, and we set up Tag definitions to match SellingLane's classification tags. The customer chooses between self-hosted (Docker, AGPL-3.0) or the Twenty cloud workspace during this phase.

  3. Staged export and relational sequencing

    We export SellingLane records in dependency order: AuctionEvent (parent) first, then Person (Buyer) records, then Lot records, then Registrations, then Payments, then Bids last. Each export phase includes foreign-key references (lot_id, buyer_id, event_id) that we preserve in our staging schema. We validate foreign-key integrity before each import phase to ensure no orphaned records. Attachments are exported separately with naming conventions that allow re-association in Twenty.

  4. Sandbox migration and reconciliation

    We run a full migration into the customer's Twenty workspace (or a staging environment if self-hosted) using production-like data volume. The customer's team reconciles record counts across all objects, spot-checks 25-50 records against SellingLane source data, and validates that Bid-to-Lot and Registration-to-Person lookups resolved correctly. Any mapping corrections are applied before production migration begins. This phase is where schema discovery findings (custom field gaps, deprecated picklist values) are confirmed or corrected.

  5. Production migration and cutover

    We run production migration in staged dependency order with each phase emitting a row-count reconciliation report. After the final phase, we freeze SellingLane writes, run a delta migration of any records modified during the migration window, then declare Twenty the system of record. We deliver a written inventory of SellingLane automations, workflow triggers, and event-based actions that do not migrate, with recommendations for rebuilding in Twenty's workflow layer or a third-party automation tool. We support a one-week post-cutover window for reconciliation issues.

Platform deep dives

Context on both ends of the pair

SellingLane CRM logo

SellingLane CRM

Source

Strengths

  • Flat monthly pricing without per-transaction or per-lot billing charges.
  • Integrated buyer lifecycle from registration through checkout in one platform.
  • Custom fields supported on auction listings for lot-specific attributes.
  • Built-in buyer verification and trust-account management for auction compliance.
  • No hidden fees for CRM hosting, streaming, or website features.

Weaknesses

  • Narrow feature scope limited to auction-specific workflows and not general CRM use cases.
  • Minimal public API documentation limits custom integrations and automation extension.
  • Sparse third-party app ecosystem compared to mainstream CRM platforms.
  • Very small review base makes competitive evaluation difficult.
  • Auction-specific terminology requires significant re-learning when migrating to general CRM platforms.
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. 2 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 SellingLane CRM and Twenty CRM.

  • Object compatibility

    B

    2 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

    SellingLane CRM: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Straightforward migrations with under 10,000 Buyers, 5,000 Lots, and 50,000 historical bids land between three and five weeks. Migrations with large Lot catalogs, complex custom field schemas, post-sale payment records with trust-account carry-forward logic, or buyer trust-account balance histories extend to six to ten weeks because of custom object schema design, staged import sequencing, and relational validation across Bid, Lot, and AuctionEvent.

Adjacent paths

Related migrations to explore

Ready when you are

Move from SellingLane CRM.
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