CRM migration

Migrate from Nookal to Twenty CRM

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

Nookal logo

Nookal

Source

Twenty CRM

Destination

Twenty CRM logo

Compatibility

100%

10 of 10

objects map 1:1 between Nookal and Twenty CRM.

Complexity

BStandard

Timeline

48–72 hours

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Nookal is a practice management system built for allied health: it organises work around clients, practitioners, appointments, clinical notes, and Medicare/DVA claiming workflows. Twenty CRM is a general-purpose CRM with standard objects for People, Companies, Opportunities, Notes, and Tasks. The migration maps Nookal's client-centric healthcare model into Twenty's contact-opportunity model, with several healthcare-specific fields requiring custom fields or manual rebuilds. We extract Nookal data via its export tools, transform each object against Twenty's schema, and load via Twenty's CSV import or GraphQL API. Clinical notes and treatment records from Nookal migrate as Notes attached to People records; appointment history becomes Tasks with original datetime stamps; and invoice data lands in custom fields on the Person record. Nookal's Medicare 2.0 claiming configuration—provider numbers, service types, AIR integration—has no native equivalent in Twenty's workflow engine. We export the claiming workflow definitions as a rebuild reference so your team can reconstruct them step-by-step in Twenty. The migration sequence follows Twenty's import-order requirement: Companies first, then People, then Opportunities, then custom objects.

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

Nookal logo

Nookal

What's pushing teams away

  • Feature scope is narrow; practices needing patient engagement beyond reminders, social messaging, or AI-powered intake chatbots must layer in additional tools.
  • Limited accounting depth — Nookal handles invoicing and payments but does not produce completed accounting records on its own, requiring Xero or QuickBooks to close the loop.
  • Absence of a documented public API means practices with complex custom integrations or developer-dependent workflows hit a ceiling and must migrate manually.
  • Patient engagement features lag competitors; no WhatsApp or social channel integration and no native AI chatbot for handling patient enquiries at scale.
  • Growing practices report outgrowing the platform's customisation surface when they need advanced custom objects, complex automation, or multi-location scalability beyond what Nookal provides.

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

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

Nookal

Client (Nookal patient/contact record)

maps to

Twenty CRM

People

1:1
Fully supported

Nookal Client records map directly to Twenty People. Client name, email, phone, address, and date of birth transfer as standard fields. Each client must have a primary practitioner assigned in Nookal, which we map to the Twenty Workspace Member (user) who owns the Person record after email-matching resolution.

Nookal

Client → practitioner assignment

maps to

Twenty CRM

People → WorkspaceMember relation

1:1
Fully supported

Nookal stores practitioner-client relationships with role labels (e.g., 'primary physiotherapist'). We map these to a custom pick-list field (Practitioner_Role__c) on the Person record and set the Twenty workspace member as the record owner via email lookup. If a practitioner has no Twenty account, records attach to a designated fallback owner and the unresolved practitioner name is preserved in a custom text field.

Nookal

Appointment

maps to

Twenty CRM

Task

1:1
Fully supported

Nookal appointments map to Twenty Tasks with the original start/end datetime preserved. The Task title carries the appointment type (e.g., 'Initial Consultation', 'Follow-up Treatment'). Task status maps from Nookal's appointment status: 'Completed' → Twenty Task 'completed'; 'Cancelled' → 'cancelled'; 'Scheduled' → 'open'. The assigned practitioner maps to the Task assignee via email resolution against Twenty workspace members.

Nookal

Appointment → service type

maps to

Twenty CRM

Task → custom field

1:1
Fully supported

Nookal service types (e.g., 'Physiotherapy - Standard', 'Podiatry - Initial') have no direct Twenty equivalent. We create a custom select field (Service_Type__c) on the Task object and populate it with the Nookal service-type values. Your admin maps which service types are available in Twenty's Settings → Data Model before the full migration runs.

Nookal

Invoice

maps to

Twenty CRM

custom field on Person

1:1
Fully supported

Nookal invoices carry total amount, status (paid/unpaid/overdue), and line items. Since Twenty has no native invoicing object, invoice data migrates as custom fields on the Person record: Invoice_Total__c (Number), Invoice_Status__c (Select: Paid/Unpaid/Overdue), and Invoice_Date__c (Date). Each invoice record in Nookal becomes a separate set of these fields, with invoice ID preserved in Invoice_ID__c for reconciliation.

Nookal

Medicare / DVA Claim

maps to

Twenty CRM

custom field on Person

1:1
Fully supported

Nookal Medicare/DVA claiming records contain provider numbers, service dates, item codes, and claim status. These map to custom fields on Person: Claim_Status__c (Select), Claim_Item_Code__c (Text), Claim_Provider_Number__c (Text), and Claim_Date__c (Date). The claiming workflow itself (provider-number mapping, AIR integration) cannot migrate and is exported as a reference document for rebuild in Twenty's workflow builder.

Nookal

Clinical Note / Treatment Note

maps to

Twenty CRM

Note

1:1
Fully supported

Nookal clinical notes and treatment records migrate as Twenty Notes attached to the Person record. The Note body carries the full clinical text. Original note datetime and practitioner author transfer as Note metadata fields. Note that clinical note content from Nookal may be PHI-sensitive—your team controls access permissions in Twenty via workspace roles.

Nookal

Location / Practice Site

maps to

Twenty CRM

custom field on Person or Company

1:1
Fully supported

Nookal multi-location practices store location data per appointment and client. We create a custom select field (Practice_Location__c) on the Person record populated from Nookal's location list. If your Nookal setup stores practice details as separate records, those map to Twenty Companies with location address data.

Nookal

Xero / QuickBooks sync record

maps to

Twenty CRM

custom field on Person

1:1
Fully supported

Nookal's Xero and QuickBooks integration links invoices to accounting records using external IDs. These IDs have no Twenty equivalent since Twenty lacks native accounting sync. We preserve the external accounting reference as a custom text field (Accounting_Reference__c) for manual reconciliation after migration.

Nookal

Custom fields defined by the practice

maps to

Twenty CRM

custom field matching type

1:1
Fully supported

Nookal practices often add custom fields for health-specific data (e.g., 'NDIS Plan Number', 'Allergies', 'Emergency Contact'). Each custom field requires a matching Twenty custom field created in Settings → Data Model before import. We inventory all Nookal custom fields during the audit phase and deliver a field-creation checklist so your Twenty workspace is schema-ready before data lands.

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.

Nookal logo

Nookal gotchas

High

Medicare 2.0 migration deadline is hard-gated

High

No public API forces reliance on built-in exports

Medium

Custom clinical note templates are account-specific

Medium

Medicare claiming groups tied to Provider Numbers restrict bulk migrations

Medium

Accounting sync does not export raw ledger data

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

  • Medicare claiming workflows have no native Twenty equivalent

    Nookal's Medicare/DVA 2.0 claiming integration maps provider numbers to service item codes, submits claims via the Medicare Easyclaim channel, and syncs claim status back to the client record. Twenty CRM has no native claiming module and no Easyclaim integration. Claiming automation must be rebuilt from scratch in Twenty's workflow builder. We export your Nookal claiming workflow definition (provider numbers, item-code mappings, AIR setup) as a reference document so your admin can reconstruct the logic step-by-step. Claim history data—status, item codes, provider numbers—migrates as custom fields on the Person record for historical reference.

  • Appointment scheduling is not a native Twenty feature

    Nookal has a full practitioner calendar with appointment types, service durations, and recurring booking rules. Twenty CRM has no native scheduling engine—appointments become Tasks with datetime stamps and assignee links. Your team will need to either use Twenty Tasks as a lightweight appointment log or connect a third-party scheduling tool (Calendly, Acuity, or a custom integration via Twenty's GraphQL API). We map Nookal appointment history to Tasks with original datetime and practitioner ownership, but going forward, the scheduling workflow must be built outside Twenty or via a developer-built integration on top of Twenty's open API.

  • Invoice and payment records require manual reconciliation after migration

    Nookal's invoicing module tracks invoice status (Paid/Unpaid/Overdue), total amounts, line items, and Xero/QuickBooks sync references. Twenty CRM has no invoicing object. We migrate invoice totals, status, and date as custom fields on the Person record, but invoice line items do not have a natural home in Twenty's data model. Line-item data can be stored as a formatted text block in a custom field or attached as a Note. Your accounting team will need to reconcile Twenty's custom invoice fields against your Xero or QuickBooks records post-migration, using the Nookal invoice IDs we preserve in Invoice_ID__c.

  • Nookal's Xero and QuickBooks sync links break at migration

    Nookal's integration with Xero and QuickBooks stores external accounting system IDs on invoice records, linking Nookal invoices to accounting transactions. Twenty CRM has no native accounting integration and does not store external accounting IDs. We preserve the external accounting reference in a custom text field (Accounting_Reference__c), but the live link between Nookal invoices and your accounting software cannot be maintained. After migration, any new invoices created in Twenty must be manually reconnected to Xero or QuickBooks, or rebuilt via a custom integration using Twenty's GraphQL API.

  • Clinical note access controls must be rebuilt in Twenty's permission system

    Nookal stores clinical notes as part of the client record with role-based visibility (practitioners see all notes, administrative staff may have restricted access). Twenty's permission system is workspace-wide and object-level: you can restrict access to Notes at the workspace-role level but not at the record-content level. If your practice requires granular note visibility controls (e.g., only the assigned practitioner can view clinical notes), Twenty's standard permission model will not enforce that without custom development. We flag this gap in the migration plan and recommend reviewing Twenty's workspace roles and settings before go-live.

Migration approach

Six steps for a successful Nookal to Twenty CRM data migration

  1. Audit Nookal data export and inventory custom fields

    We pull the full Nookal data export using your account's built-in export tools, covering clients, appointments, invoices, Medicare claims, clinical notes, and custom fields. During this phase we inventory every custom field your practice has added to Nookal and map each to a Twenty field type (text, number, select, date, etc.). We also extract your Medicare claiming workflow definition—provider numbers, item-code mappings, AIR settings—as a rebuild reference document. This audit produces the field-creation checklist your admin uses to pre-build the Twenty schema before any data is loaded.

  2. Build Twenty workspace schema from the field-creation checklist

    Before data moves, your Twenty admin creates all custom fields identified in the audit: Invoice_Total__c, Invoice_Status__c, Claim_Status__c, Service_Type__c, Practice_Location__c, NDIS_Plan_Number__c, Allergies__c, and any other practice-specific fields. We also create the pick-list options for select fields (e.g., invoice status values, service types, claiming statuses) so Twenty's import validation accepts the incoming values. This step must complete before the CSV import runs, because Twenty's CSV import creates records but not fields.

  3. Resolve Nookal practitioners to Twenty workspace members

    Nookal appointment history and Medicare claims carry practitioner assignments. We resolve each Nookal practitioner email against your Twenty workspace members list. Practitioners with matching Twenty accounts become Task assignees and Note authors. Practitioners without Twenty accounts are flagged before migration—your admin either invites them to Twenty first or we assign their records to a fallback owner. No appointment Task lands without a resolved assignee or a flagged fallback.

  4. Run a sample migration with field-level diff on 100–500 records

    A representative slice migrates first: 100–500 Nookal clients spanning multiple practitioners and locations, with their appointment history, invoices, and clinical notes. We generate a field-level diff comparing source values in Nookal against the loaded values in Twenty so you can verify that dates, statuses, amounts, and note content arrived correctly. Any mapping errors get corrected before the full run. This sample phase is also where you confirm that invoice data, Medicare claiming fields, and custom health fields landed in the right places.

  5. Execute full migration with delta-pickup window and rollback plan

    The full migration runs against Twenty using CSV import or the GraphQL API, sequenced in Twenty's required import order: Companies first (for location data), then People, then Tasks (for appointments). After the initial load, a delta-pickup window (typically 24–48 hours) captures any Nookal records modified or added during the cutover period so Twenty reflects Nookal's final state at go-live. We maintain a full audit log of every record operation. If reconciliation fails, one-click rollback reverts to the pre-migration state.

Platform deep dives

Context on both ends of the pair

Nookal logo

Nookal

Source

Strengths

  • Per-practitioner pricing scales cost-effectively for small-to-mid allied health clinics with one to ten practitioners.
  • Native Medicare and DVA Online Claiming 2.0 eliminates the need for a separate claiming middleware for Australian health practices.
  • Accounting sync with Xero and QuickBooks keeps financial records up to date without manual re-entry.
  • Built-in diary, clinical notes, and practice reporting cover the core allied health workflow in a single platform.
  • Australian-focused product design includes My Health Record integration and Australian Immunisation Register support.

Weaknesses

  • No documented public REST API limits programmatic data extraction and makes automated migration more complex.
  • Accounting depth is shallow; Nookal handles invoicing and payments but relies on Xero or QuickBooks for completed financial records.
  • Feature set is narrower than multi-feature competitors; practices needing patient engagement, AI chatbots, or social messaging must layer in additional tools.
  • Custom field definitions and clinical note templates are not exposed in a public schema, requiring manual discovery during scoping.
  • Integration ecosystem beyond Xero, QuickBooks, and Medicare claiming is limited compared to larger practice management 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 Nookal 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

    Nookal: Not publicly documented.

  • Data volume sensitivity

    B

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

Estimator

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

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

Can't find your answer?

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

Book a free 30 minute consultation

Most Nookal-to-Twenty migrations complete in 48–72 hours of clock time for practices with under 25,000 records. Larger practices with 25,000–100,000 records (clients, appointments, invoices, claims) extend to 5–10 days. The longest planning step is building the Twenty custom field schema—your admin should create all custom fields in Settings → Data Model before the import runs, because Twenty's CSV import creates records but not fields.

Adjacent paths

Related migrations to explore

Ready when you are

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