CRM migration
Field-level mapping, validation, and rollback between HoneyBook and Twenty CRM. We move data and schema; workflows are rebuilt natively in Twenty CRM.
HoneyBook
Source
Twenty CRM
Destination
Compatibility
4 of 11
objects map 1:1 between HoneyBook and Twenty CRM.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from HoneyBook to Twenty CRM is a data-centric migration from a clientflow platform to a relationship-focused CRM. HoneyBook organizes around client-centric Projects that bundle inquiries, contracts, invoices, and pipeline stages together; Twenty CRM uses a normalized People-and-Companies model with Opportunities, Tasks, and Notes as first-class objects. We extract HoneyBook data through CSV exports and web-interface scraping, then map Projects to Opportunities with linked People records, preserve Invoice and Contract metadata as custom field blocks on the Opportunity, and flag HoneyBook's Automations as non-migratable since Twenty explicitly requires manual rebuild of workflows and views post-import. HoneyBook Balance (the checking account product) falls outside migration scope and requires direct coordination with HoneyBook support to close or transfer.
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 HoneyBook 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.
HoneyBook
Contact
Twenty CRM
Person
1:1HoneyBook contacts export as a CSV from Clients > Contacts and include name, email, phone, address, notes, and creation date. We ingest this CSV and map each row to a Twenty Person record, preserving the original HoneyBook contact ID in a custom field hb_contact_id__c for audit and cross-reference. Any contact records with duplicate emails are flagged during scoping for manual resolution before import.
HoneyBook
Project (Inquiry)
Twenty CRM
Opportunity
1:1HoneyBook projects represent client inquiries and contain pipeline stage, custom fields, associated contacts, and project metadata. We extract project metadata from HoneyBook's pipeline view and map each project to a Twenty Opportunity record. The HoneyBook pipeline stage becomes the Opportunity stage, with a custom field hb_project_id__c and hb_pipeline_stage__c preserving the original HoneyBook stage name and move timestamp for historical accuracy.
HoneyBook
Project Pipeline Stages
Twenty CRM
Opportunity Stage
lossyHoneyBook's configurable pipeline stages (Inquiry, Follow Up, Proposal Sent, Booked, etc.) with stage-move timestamps are mapped to Twenty Opportunity stage values. We configure Twenty's opportunityPipeline setting to mirror HoneyBook's stage names and probabilities, and we preserve the stage history as a JSON array in a custom field hb_stage_history__c on the Opportunity.
HoneyBook
Invoice
Twenty CRM
Custom Object: Invoice (linked to Opportunity)
1:manyHoneyBook invoices include line items, payment status, amounts, and client associations. We extract invoice records via CSV export or HoneyBook's invoice list view, then create a custom Invoice object in Twenty with fields for invoice_number, amount, status, line_items (JSON), and linked_hb_project_id. Each invoice links to the corresponding Opportunity via a custom lookup field. Open invoices requiring continued payment processing are flagged separately.
HoneyBook
Contract
Twenty CRM
Custom Field Block on Opportunity
lossyHoneyBook contracts are template-based documents with client associations and e-signature status. We extract contract metadata (client, template name, status, date, signature status) and store it as a structured custom field block on the linked Twenty Opportunity: hb_contract_status__c, hb_contract_template__c, hb_signed_date__c, hb_signature_provider__c. The actual contract PDF requires separate file handling (see Files note).
HoneyBook
Proposal
Twenty CRM
Custom Field Block on Opportunity
lossyHoneyBook proposals are project-level documents combining scope, pricing, and terms. We extract proposal records and map them to the linked Opportunity's custom fields: hb_proposal_status__c, hb_proposal_amount__c, hb_proposal_sent_date__c, hb_proposal_response__c. Proposal documents themselves require separate file migration handling.
HoneyBook
Payment
Twenty CRM
Custom Field Block on Invoice
lossyHoneyBook payment records include amount, method, status, and processing date. We extract payment history and map to the custom Invoice object with fields for amount, method, status (Completed, Pending, Refunded), and processing_date. We preserve the original HoneyBook timestamp for bank transfers (which carry a 7-8 day clearing window) rather than the settlement date to avoid conflating Payment Attempted with Completed status.
HoneyBook
Custom Fields
Twenty CRM
Custom Fields on Person and Opportunity
lossyHoneyBook supports custom fields on contacts and projects. We identify all active custom fields during discovery, export their values alongside the parent record, and create matching custom fields in Twenty via Settings → Data Model before import. Custom fields must exist in Twenty before CSV import begins; import will reject records referencing non-existent fields.
HoneyBook
Team Members
Twenty CRM
WorkspaceMember
1:1HoneyBook distinguishes collaborators (external, limited project access) from team members (internal). We export team member records including roles and permissions, then map internal team members to Twenty WorkspaceMembers. Collaborators without a Twenty user account are mapped to a custom field hb_collaborator__c on the relevant records. The customer provisions Twenty users before migration so that Owner and assignee lookups are satisfied at import time.
HoneyBook
Automations
Twenty CRM
Not Migrated
1:1HoneyBook automations (email triggers, questionnaire flows, booking confirmations) are rule-based and stored server-side with no export mechanism. Twenty CRM's own migration documentation explicitly states that views, workflows, and permissions must be recreated manually after import. We do not migrate automations as code. We deliver a written inventory of every active HoneyBook automation with its trigger conditions, actions, and recommended manual rebuild steps for Twenty. This inventory is provided as a handoff document for the customer's admin.
HoneyBook
Files and Attachments
Twenty CRM
Custom Field (file references)
lossyHoneyBook stores files in a library (images, PDFs, brand assets) and attaches them to projects and contracts. File URLs are session-bound and not publicly accessible. We handle file migration by downloading attachments during an authenticated session and storing them in a customer-provided storage location (S3, Google Drive, Dropbox), then recording the file URL in a custom field on the relevant Twenty record. File migration is scoped separately from record migration.
| HoneyBook | Twenty CRM | Compatibility | |
|---|---|---|---|
| Contact | Person1:1 | Fully supported | |
| Project (Inquiry) | Opportunity1:1 | Fully supported | |
| Project Pipeline Stages | Opportunity Stagelossy | Fully supported | |
| Invoice | Custom Object: Invoice (linked to Opportunity)1:many | Fully supported | |
| Contract | Custom Field Block on Opportunitylossy | Fully supported | |
| Proposal | Custom Field Block on Opportunitylossy | Fully supported | |
| Payment | Custom Field Block on Invoicelossy | Fully supported | |
| Custom Fields | Custom Fields on Person and Opportunitylossy | Mapping required | |
| Team Members | WorkspaceMember1:1 | Mapping required | |
| Automations | Not Migrated1:1 | Not supported | |
| Files and Attachments | Custom Field (file references)lossy | 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.
HoneyBook gotchas
No public bulk API forces manual data export
Payment processing fees apply to every transaction
Bank transfers take 7–8 days to process
HoneyBook Balance is a separate banking product
Limited international availability affects data residency
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 data audit
We audit the HoneyBook account for record volume across contacts, projects, invoices, contracts, proposals, pipeline stages, team members, and custom fields. We assess which HoneyBook export paths are available (contact CSV confirmed; project and invoice data requires web-interface extraction) and document any HoneyBook Balance checking account that requires separate handling. We confirm the customer's intended Twenty deployment (self-hosted or Cloud Pro) and provision a Twenty workspace for migration with custom objects and fields pre-created per our schema design.
Schema design and custom field creation
We design the Twenty destination schema based on the HoneyBook data audit. This includes creating custom fields on Person (for contact-level HoneyBook custom fields and collaborator flags), creating the custom Invoice object with all required fields and a lookup to Opportunity, and configuring the Twenty opportunityPipeline to mirror HoneyBook's pipeline stage names and probabilities. We also create the hb_contact_id__c, hb_project_id__c, hb_pipeline_stage__c, hb_stage_history__c, and other audit fields. The customer provisions Twenty users before import so that Owner lookups are satisfied.
Data extraction from HoneyBook
We run an authenticated extraction session against the HoneyBook account. Contacts export as a direct CSV download. Project metadata is scraped from the pipeline view in batches to avoid interface timeouts. Invoice records are extracted from the invoice panel, and contract and proposal metadata are scraped from their respective list views. We flag any records with missing required fields (e.g., contacts without email) for the customer's review before import. File attachments are downloaded during the authenticated session and staged in a customer-provided storage location.
Data transformation and staging
We transform the extracted HoneyBook data into staging CSVs compatible with Twenty's import format. Contact records are deduplicated by email, and any duplicates are written to a reconciliation report for the customer to resolve. Project records are mapped to Opportunities with the original HoneyBook stage history preserved as hb_stage_history__c. Invoice records are created as custom Invoice objects with a lookup to the parent Opportunity. We validate field formats (phone numbers, dates, currency codes) against Twenty's requirements and flag any records that require format correction.
Staging migration and reconciliation
We run a full migration into a Twenty staging environment (or the production instance if self-hosted) using the transformed staging CSVs. The customer reconciles record counts and spot-checks 25-50 records against the HoneyBook source. Any mapping corrections, custom field additions, or stage configuration adjustments happen in this phase. We do not proceed to production migration until the customer signs off on the staging reconciliation.
Production cutover and automation handoff
We freeze writes in HoneyBook during cutover and run a final delta migration of any records created or modified during the migration window. We enable Twenty as the system of record and deliver the automation inventory document listing every HoneyBook automation with its trigger, conditions, and recommended manual rebuild steps for Twenty. We support a one-week hypercare window for reconciliation issues. We do not rebuild HoneyBook automations or configure Twenty workflows as part of the standard migration scope.
Platform deep dives
HoneyBook
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 HoneyBook 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
HoneyBook: Not publicly documented.
Data volume sensitivity
HoneyBook 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 HoneyBook to Twenty CRM migration scoping. Not seeing yours? Book a call.
Walk through your HoneyBook 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 HoneyBook
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.