CRM migration
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
Source
Twenty CRM
Destination
Compatibility
7 of 10
objects map 1:1 between SellingLane CRM and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
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.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
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
Twenty CRM
Person
1:1SellingLane 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
Twenty CRM
Custom Object (Lot)
1:1SellingLane 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
Twenty CRM
Custom Object (Bid)
1:1Bid 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
Twenty CRM
Custom Object (Auction Event)
lossySellingLane 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
Twenty CRM
Custom Object (Registration)
1:1Registration 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
Twenty CRM
Custom Object (Payment)
1:1Post-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
Twenty CRM
Opportunity Stage
lossySellingLane 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
Twenty CRM
User
1:1SellingLane 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
Twenty CRM
File (via storage)
1:1Item 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
Twenty CRM
Tag
lossyLots 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.
| SellingLane CRM | Twenty CRM | Compatibility | |
|---|---|---|---|
| Buyer | Person1:1 | Fully supported | |
| Lot | Custom Object (Lot)1:1 | Fully supported | |
| Bid | Custom Object (Bid)1:1 | Fully supported | |
| Auction Event | Custom Object (Auction Event)lossy | Fully supported | |
| Registration | Custom Object (Registration)1:1 | Fully supported | |
| Payment/Checkout | Custom Object (Payment)1:1 | Fully supported | |
| Pipeline Stages | Opportunity Stagelossy | Fully supported | |
| Owner/User | User1:1 | Fully supported | |
| Attachment | File (via storage)1:1 | Fully supported | |
| Tag/Label | Taglossy | Fully supported |
Gotchas + challenges
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 gotchas
Custom fields on lots are not schema-documented
Bid history relies on Lot-to-Buyer relational links
Auction event groupings must be reconstructed
Buyer verification status is a custom field
Twenty CRM gotchas
Import order is enforced and critical
Export limited to 20,000 records and visible columns only
Soft-deleted records count toward uniqueness and trigger restores
API rate limits cap at 200 req/min on Organization tier
No native email sequences — follow-up cadences require external tools
Pair-specific challenges
Migration approach
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.
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.
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.
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.
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
SellingLane CRM
Source
Strengths
Weaknesses
Twenty CRM
Destination
Strengths
Weaknesses
Complexity grading
Standard CRM migration. 2 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across SellingLane CRM and Twenty CRM.
Object compatibility
2 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
SellingLane CRM: Not publicly documented.
Data volume sensitivity
SellingLane CRM doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during SellingLane CRM to Twenty CRM migration scoping. Not seeing yours? Book a call.
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 consultationAdjacent paths
Other ways to leave SellingLane CRM
Other ways to arrive at Twenty CRM
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.