Skip to content
Get a quote

Migrate to Acumatica

Acumatica is a cloud-true xRP-platform ERP whose migration model rewards teams that pre-build the chart of accounts, master Import Scenarios, and stage Generic Inquiries before a single GL period is opened.

Short answer

FlitStack AI migrates financial, supply chain, and operational data into Acumatica from 200+ ERPs, including NetSuite. Every field is mapped to Acumatica's objects, history and associations come across, the Acumatica setup is configured alongside, and the whole migration stays reversible in one click.

By

From NetSuite
DestinationAcumatica
NetSuite
200+ sources mapped into Acumatica

Systems we move into Acumatica

The ERPs teams most often move from. Each page shows what moves, the field mapping and what to watch for.

What Acumatica supports, and where its import tools stop

  • Unlimited user licensing lets companies add staff without per-seat billing shocks, making Acumatica cost-predictable at scale.
  • Flexibility and scalability earn consistent praise — users value a platform that adapts to vertical workflows without forcing a redesign.
  • Real-time visibility across financials, inventory, and projects gives mid-market businesses a consolidated operational view previously available only in enterprise-tier ERPs.
  • Cloud-native architecture with automatic updates removes infrastructure management burden from in-house IT teams.
REST onlyOAuth 2.0 (REST Contract-Based API); also supports API key and session-based auth for screen-based SOAP API
Rate limitsLicensed by tier — limits visible in License Monitoring Console (SM604000). Community reports suggest ~100 API calls/minute on standard licenses, with higher limits on Enterprise. Concurrent web service sessions are also license-restricted.
ObjectSupportNote
Business Accounts (Customers)fullBusiness Account is Acumatica's primary CRM and AR entity. Standard fields map cleanly. Custom fields use the UDF extension framework and require explicit field-level mapping during migration.
VendorsfullVendor records include AP settings, tax settings, and payment terms. All standard fields migrate directly; UDFs on Vendor require custom field mapping.
Inventory Items (Stock/Non-Stock)fullItems carry warehouse-specific quantity and availability data. We preserve item categories, units of measure, and stock item attributes. AvailabilityQty is a derived column updated by the system on recalculation.
Chart of AccountsfullGL accounts include account class, type, subaccount mask, and active/inactive status. We map account structures to the destination schema, preserving subaccount segmentation.
ProjectsfullProject records include budgets, tasks, employees, and change orders. We extract the project hierarchy and associated transaction links. Project attributes and custom fields require mapping.
Sales Orders / QuotesmappedSales documents carry line items, fulfillment details, and invoice links. Tax calculation depends on customer and item tax settings. We preserve document status to allow reactivation in the destination system.
Purchase OrdersmappedPO records include vendor, line items, receipts, and amendments. We extract the full PO lifecycle and map document status. Receipts and amendments have separate schemas and are migrated as related records.
AR/AP InvoicesmappedOpen invoices carry payment schedules, terms, and aging data. Historical invoices may reference balance tables and require careful sequencing to preserve GL impact.
Custom Fields (UDFs)mappedUser-defined fields in Acumatica are stored in extension DACs and serialized under a 'custom' namespace in the REST API. Custom fields on Leads, Accounts, and other entities require explicit field discovery before migration.
Notes and AttachmentsmappedNotes are stored in Note and NoteDoc tables linked by NoteID. Files are stored as separate records. We extract note text, related entity references, and binary attachments, then re-link them in the destination system.
EmployeesfullEmployee records include compensation history, department assignments, and timecard data. We preserve employment status, job titles, and earning codes. Effective-dated rows are migrated as separate records.
Warehouses/LocationsfullWarehouse records define physical locations with bin structures. We map warehouse assignments on inventory items and transfer orders. Multi-warehouse configurations are preserved with location-specific availability.
Tax Categories and ZonesmappedTax setup includes categories, zones, and rules. Destination tax engines interpret these differently, so we flag the tax mapping requirement and let the customer decide whether to carry tax configuration records directly.
Users and RolesmappedUser accounts include role assignments, company associations, and tenant scope. We export users as contacts or employees in the destination. Role/permission mappings require manual configuration in most target systems.

The Acumatica migration guide

Why teams migrate to Acumatica

The four shapes an Acumatica migration takes, and what makes the platform easier — or harder — than the category average.

Acumatica, Inc. provides cloud and browser-based enterprise resource planning software for small and mid-sized businesses, headquartered in Bellevue, Washington in the Seattle metropolitan area1. The product is built on the xRP cloud platform and is sold as a consumption-based subscription rather than per-named-user, which materially changes the economics of who you pull into the system.

The typical Acumatica customer runs $5M to $500M of revenue and has outgrown QuickBooks, Sage 50, Dynamics GP or an older NetSuite footprint that no longer fits. Editions cover General Business, Manufacturing, Distribution, Construction, Field Service and Retail-Commerce — each shipping a tuned data model and a tuned Generic Inquiry library, but all sharing the same xRP core and the same Import Scenario engine.

The shapes of migration that actually land on Acumatica tend to fall into four patterns. First, legacy ERP exits — Dynamics GP, SAP Business One, Sage 100/300, Epicor — where the source schema is rigid but the GL discipline is strong, and the project is really about preserving period balances without dragging years of subledger detail into the new system4.

Second, NetSuite exits, where teams move to control total cost of ownership on a consumption-based licence and recover from add-on price creep3. Third, QuickBooks graduations, where a fast-growing distributor or manufacturer outgrows desktop or online accounting and finally needs real inventory, BOM and multi-entity. Fourth, M&A integration, where an acquirer standardises subsidiaries on a single Acumatica tenant and harmonises chart-of-accounts segmentation across the group.

What makes migrating to Acumatica easier than the category average is the Import Scenario framework — a no-code mapping engine that reads CSV or Excel through a configurable data provider, applies formulas and lookups, and writes records through the same business-logic graph that an interactive user would touch, validations and all22.

What makes it harder than the average is the consumption-based licensing model, where transaction volume and resource tier — not user count — drive cost, and a stale data load can silently push you up a tier on the next renewal32. Acumatica also does not allow you to override CreatedDateTime or LastModifiedDateTime on standard imports, so all historical timestamps must be captured in custom user-defined fields if reporting depends on them.

Generic Inquiries, dashboards, Customization Projects, Acuminator extensions and reports do not auto-migrate from any source — they are rebuilt against the destination schema. Teams that scope the rebuild work up front finish on time; teams that assume parity do not.

Teams that scope for the Generic Inquiry, dashboard and Customization Project rebuild up front finish on time; teams that assume parity do not.

The Acumatica data model you need to map into

Objects, custom fields, master-detail relationships, and the keys you'll wire on every load — the destination schema decoded.

Acumatica's data model is organised around Data Access Classes (DACs), each of which is exposed through a screen and a Generic Inquiry inside an industry-versioned package — Default, Manufacturing, Distribution, Construction or Field Service1112. The set of objects you will touch in a migration depends on edition, but a core cluster shows up on every project.

Before you can map a field on the source side, you need to know which destination DAC the row belongs on, what fields are required by the underlying graph, and what the natural key is. The table below summarises the objects you will touch in a financials-plus-distribution migration.

ObjectWhat it storesRequiredTier
Chart of Accounts (Account)GL accounts segmented by Account Class, Type, CurrencyAccount ID, Type, ClassAll editions
SubaccountReporting dimensions concatenated as segmented valueSegmented value, segment identifiersAll editions
BranchLegal entity or reporting branch inside a tenantBranch ID, Company, ledgerAll editions (multi-branch requires Advanced Fin)
Customer (BAccount role)AR master record with terms, locations, contactsCustomer ID, Class, Terms, CurrencyAll editions
Vendor (BAccount role)AP master record with terms, 1099 settingsVendor ID, Class, Terms, CurrencyAll editions
Stock Item / Non-Stock ItemInventory items with UoM, item class, lot/serialInventory ID, Item Class, Base UoM, Posting ClassDistribution / Manufacturing editions
Bill of Material / Production OrderBOM revisions, operations, materialsBOM ID, Revision, Inventory ID, Effective DateManufacturing edition
AR Invoice / AP BillOpen and historical invoices and billsDoc Type, Reference Nbr, Date, Customer/VendorAll editions
Sales Order / Purchase OrderOrder documents with detail linesOrder Type, Order Nbr, Customer/Vendor, Detail rowsDistribution / SO+PO modules
Project (PM)Project header + Task hierarchy + budgetProject ID, Template, Customer, TasksConstruction / Project Accounting

Most master DACs use a CD field (Customer ID, Vendor ID, Inventory ID, Account ID) as the human-readable key, paired with an internal integer ID that the framework uses for joins53. For migration, the CD field is your upsert key — load with a stable, deterministic value (often the source primary key prefixed by a system marker) and let Acumatica generate the internal ID.

Transaction documents use a two-part natural key — (DocType, RefNbr) — and this is the single most-missed detail in beginner Import Scenarios. The Document Type is auto-defaulted on the form, so it does not visually appear in the field order, but it must be mapped as the first key field in the Import Scenario or the scenario will silently fail on the second invoice.

Custom field types in Acumatica are exposed through the Data Class Editor on a Customization Project and broadly cover the catalogue below. Picklists are declared via PXStringList with parallel arrays of internal codes and display values64; the code is what the database stores and what every import path expects, while the display string is purely UI.

Field typeLimitNotes
PXDBStringUp to nvarchar(4000); default 60Use SQL nvarchar; default mask 60 chars and will truncate silently
PXDBDecimalPrecision/scale set on attributeCurrency precision read from Acumatica preferences
PXDBDate / PXDBDateTimeSQL datetime rangeDateTime is UTC; convert at the edge
PXStringList (picklist)1024 chars per list; codes 2–4 chars typicalCodes (e.g. C/E/T/R) — not display labels — are stored64
MultiSelect = trueComma-separated codesPack codes into a single field on the source export
Attributes (UDFs)Per item class / business account classConfigured on Attributes form (CS205000); UDF-style
Custom field (DAC extension)Project-scoped; no per-DAC hard ceilingCreated via Customization Project; persisted as Usr* columns
User-defined field (UDF)1,000s per class, configurablePer-record key/value, surfaced as columns in screens
Note / File attachment25 MB default per file (configurable)File Upload Preferences SM202550 controls cap104

Relationships are modelled as master-detail — one DAC's primary key is referenced as a foreign key on a child DAC via a PXSelector attribute with a SubstituteKey clause53. Acumatica does not auto-cascade deletes; the framework instead fires RowPersisting events with PXDBOperation.Delete so business logic can decide whether to cascade or block131. There is no native junction-object pattern as in Salesforce — many-to-many relationships are built explicitly with a junction DAC and two PXSelector lookups.

Customization Projects (the no-code/low-code customisation framework) are the wrapper for every custom field, screen extension, workflow tweak and DAC modification you make on the destination side, and projects are what you publish from sandbox to production41. Snapshots, captured from System Management → Snapshots, are the binary backup-and-restore unit — they bundle every schema, configuration and data row and can be re-imported into a fresh tenant for staging or rollback123.

Pre-migration prep — the work before you touch Acumatica

What must be true on the source, on the destination tenant, and across the finance team before the first Import Scenario is run.

The single best predictor of a clean Acumatica migration is how much chart-of-accounts and Item Class work the finance team does on the source side before the destination tenant is even provisioned. Acumatica's own Open University F110 Data Migration course is built around that order of operations — master records first, then opening balances, then open documents, then reconciliation97.

The single best predictor of a clean migration is how much chart-of-accounts and Item Class work happens before the destination tenant is provisioned.

Treat the source export as raw material that needs to be shaped to Acumatica's expected formats — segmented Account values normalised to the new segment definition, Inventory IDs uppercased to the chosen mask, currency rates expressed as Acumatica's effective-rate-on-date convention, dates rewritten to a format the CSV Data Provider can parse, owners resolved to Employee IDs.

Source-side prep

  • Audit and dedup the source master data — Customers, Vendors and Inventory IDs — before export. Acumatica's Validation of Records for Duplicates feature finds matches post-import, but it is far cheaper to dedup once on the source than to merge thousands of records inside Acumatica's duplicate-validation workflow91.
  • Lock the chart-of-accounts segment structure — number of segments, segment lengths, allowed values — before the first Account row exports. Once you have posted a single GL transaction in Acumatica, restructuring segments is destructive and requires a re-implementation. Plan Branch, Account and Subaccount segmentation as a single design decision.
  • Normalise picklist codes to Acumatica's PXStringList internal codes for every enumeration field — Customer Class, Vendor Class, Item Class, Account Class. Acumatica stores the 2–4-character code, not the display label64, and Import Scenarios that send labels are rejected silently or generate String or binary data would be truncated errors82.
  • Stamp a stable external ID on every record — a UUID or the source platform's primary key — so re-runs and reconciliation are deterministic and so AP/AR open documents can be tied back to the historical source.
  • Decide what is in scope for historical transactions versus reference-only archive. Most teams migrate only open AR/AP plus 12–24 months of detail and surface older history through a side-by-side viewer or a reporting warehouse rather than pushing it through the GL96.

Destination-side prep

  • Provision a sandbox tenant alongside the production tenant from the start. Acumatica supports multiple tenants in one application instance, and the sandbox is the dry-run target for every Import Scenario before it touches production73.
  • Provision users and roles first — Acumatica ships predefined finance, distribution and CRM roles (AP Admin, AP Clerk, AR Admin, AR Clerk, CA Admin, GL Admin, IN Admin) that you assign to users via the User Roles form before importing owner-stamped records7778. Imports that target a non-existent owner are rejected, not silently nulled.
  • Build the Customization Project shell for every custom field you intend to add — Usr-prefixed columns on Customer, Vendor, Inventory, Stock Item, Sales Order and AP Bill DACs. Publish the project to sandbox first; only after validation publish to production.
  • Configure financial settings — Companies, Branches, Ledgers, fiscal Year and Periods, currency list, exchange-rate types, posting classes, payment methods and Cash Accounts — before the first Account import. The Account import depends on Account Classes existing first.
  • Build Generic Inquiries for reconciliation queries before cutover — Trial Balance by source vs. destination, AR Aging vs. source, AP Aging vs. source, Inventory Quantity on Hand vs. source. Run these against sandbox during dry-runs so they are battle-tested before go-live.

People prep

Cutover only works if finance cooperates. Lock down a source-system freeze window — typically a weekend with the close already through period 12 on the source ledger — and communicate it to every department that touches AP, AR, billing or inventory. Train AP clerks, AR clerks and the controller on Acumatica's workflows, document types, and Cash Sale vs. Invoice semantics before go-live, not after.

A clean ledger-only migration runs one to two weekends; a multi-entity manufacturing migration with BOM, production orders and historical projects runs four to twelve weeks of elapsed time. Build the human runway accordingly.

Import mechanisms: Import Scenarios and staging tools

The load paths in, each with different limits and shapes. Picking the wrong one is how mid-migrations stall at the inventory load.

Acumatica's primary load path is the Import Scenario engine, which covers most one-shot migrations and is the most-recommended option for finance-led teams2250.

Import Scenarios (the recommended default)

Import Scenarios live under Integration → Process → Import Scenarios (screen SM206025) and they read from a configurable Data Provider — CSV, Excel, SQL or a custom provider45. Each scenario maps source columns to target screen fields via the Mapping tab, applies formulas (PadLeft, CStr, LineNbr) for transformation85, and runs the import row-by-row through the same PXGraph business logic that fires when a user types into the screen.

Two critical rules: key fields must be mapped first and in the order they appear on the target form, and the Document Type field must be explicitly mapped on transaction imports even though it auto-defaults visually. Scenarios can be triggered manually from Integration → Process → Import by Scenario, attached to an Automation Schedule to run unattended at 3 AM, or surfaced as menu items inside a workspace using the Make Visible on UI flag48.

The right call: Import Scenario for any migration up to a few hundred thousand records on standard objects, any finance-led project where the controller needs to see and approve the mapping in the UI, and any load you want to re-run on a schedule. The same scenario can be used for cutover, delta-load and ongoing daily-feed.

Third-party staging tools

Tools like Skyvia, Workato, Celigo and Boomi sit between the source and Acumatica. They are commonly used for staging-and-transform — the source is loaded into a warehouse, normalised against the Acumatica chart-of-accounts and Item Class taxonomy, then pushed into Acumatica. Skyvia specifically supports CSV import directly into Acumatica with INSERT, UPDATE, DELETE and UPSERT semantics.

Mapping your data into Acumatica

The longest section — because GL opening balances and inventory cutover are where almost every ERP migration that fails actually breaks.

Mapping is where every ERP migration earns its scars. The schema and sequencing decisions you make in your mapping spreadsheet determine whether the trial balance ties on day two, whether AR aging looks right on day five, and whether the warehouse believes the on-hand counts on day thirty.

Work top-to-bottom of the financial implementation order: Companies and Branches first, then the Chart of Accounts, then Subaccounts, then Customer and Vendor Classes, then Customers and Vendors, then Item Classes and Items, then opening trial balance, then open AR/AP documents, then inventory quantity-on-hand, then historical transactions if in scope97.

Chart of Accounts and Subaccounts

Export the demo Chart of Accounts to Excel as a template, replace the demo rows with your own Account IDs, Types, Classes, Currency and Active flags, and import via the Chart of Accounts form's native upload. Subaccount segments — Department, Cost Center, Branch, Product Line — are defined first on the Segmented Keys form (CS202000) and then the combined values on the Subaccounts form.

Get the segment count and length right before the first GL post; restructuring later is destructive and effectively requires a re-implementation.

Common source → Acumatica GL master mapping
SourceDestinationNote
account_numberAccountThe CD field; uppercased and stripped of spaces; primary key
account_name / descriptionDescriptionFree text; respect 60-char default mask or extend
account_typeTypeMap to Acumatica Account Types: Asset, Liability, Income, Expense — picklist codes only
account_classAccount ClassRequired; must exist before account import
department / cost_centerSubaccount segment valuePre-define segments on CS202000 before mapping
default_currencyCurrencyISO 4217 code; must exist in Currencies

GL opening balances and trial-balance cutover

The standard Acumatica technique is to post a single GL Journal Entry to the closing period of the prior year (e.g. period 12-2025) carrying every balance sheet account's closing balance, with the Income Statement accounts excluded — Acumatica auto-closes those to Retained Earnings when you roll into period 01-2026 and print the trial balance154. Debits must match credits; if they do not, the batch will not release.

Run this entry against a dedicated Migration Branch if multi-entity, and use Migration Mode on the AR, AP and Fixed Asset forms when entering opening subledger balances so those documents post to the subledger only and do not double-up the GL124. After all subledger opening balances are loaded, you turn Migration Mode off, reconcile each subledger to its control account in the trial balance, and only then open period 01 of the live year.

Customers, Vendors, and open AR/AP

Customer and Vendor masters import cleanly through Import Scenarios once Customer Classes and Vendor Classes are pre-created — Class drives the default GL accounts (AR Account, Discount Account, Cash Discount Sub), tax categories, and payment terms.

Missing class defaults are the single most common failure mode: a Vendor import will throw 'Cash Discount Account' cannot be empty. 'Cash Discount Sub.' cannot be empty. and stall until you either fix the Class or hard-code the discount account in the scenario value column84.

Common source → Acumatica AR/AP mapping
SourceDestinationNote
customer_id / vendor_idCustomer ID / Vendor ID (CD)Uppercased, stripped; the primary key — pick the format you can live with
name / company_nameAccount NameRequired
terms_codeTermsMust exist in Credit Terms (CS206500)
currency_idCurrency IDMust exist in Currencies; multi-currency requires Advanced Fin
tax_zoneTax ZoneMust exist in Tax Zones; defaulted from Customer Class if omitted
open_invoice_dateAR Invoice → Doc DateUse Migration Mode; backdated dates allowed and posting suppressed
open_invoice_amountAR Invoice → AmountCurrency precision driven by Acumatica preferences

Inventory items, BOM, and quantity-on-hand

Stock and Non-Stock items are imported through Import Scenarios against the Stock Items (IN202500) and Non-Stock Items (IN202000) forms. Item Class must exist first and drives default valuation method, posting class, base UoM, lot/serial settings and price/cost classes.

Inventory IDs are stored respecting the configured Item Code mask (often 20 unicode characters) and must conform to that mask — cascading 'the record couldn't be imported due to an error in the next record' errors usually trace back to an inventory code containing a forbidden special character that the Class mask rejects83.

Opening quantity-on-hand is loaded after items are created, via the Inventory Receipts form (IN301000) or — historically — via the Initialize Inventory process. Recent Acumatica releases moved the canonical QoH-load path into Inventory Receipts with a special posting class that hits a clearing account rather than the COGS or Inventory account directly, so the GL entry stays neutral159.

Bill of Material rows on the Manufacturing edition are imported through a separate scenario against the BOM form (AM208000) and reference Inventory IDs that must already exist as Stock Items with a Base UoM matching the BOM's operation UoM. Revision and effective-dating come along; production-order history is typically not migrated — only open work orders.

Multi-currency and historical exchange rates

Acumatica stores exchange rates by (CurrencyID, FromCurrency, RateType, EffectiveDate). Historical rates must be loaded for every (date, currency, rate-type) combination referenced by an opening document or the document will be revalued at the current spot rate and produce a translation gain/loss against the trial-balance reconciliation. Export the full historical rate table from the source and import it via the Currency Rates form (CM301000) before the AR/AP open-document load.

Period close and revaluation run on the fiscal calendar configured under Financial → Configuration → Fiscal Year — get the period count, period numbering and adjustment-period flag right before posting starts. Adjustments to closed periods require an explicit reopen by a user with the appropriate finance role.

Historical activities, notes, and attachments

Historical activities (calls, tasks, events, notes) associated with Customers, Vendors and Opportunities import through scenarios against the CRM screens, but they re-stamp the CreatedDateTime to import time on standard paths — the original timestamp must be captured in a UsrLegacyCreatedDateTime custom field if reporting relies on it142.

File attachments are bound to records through the platform-wide attachment subsystem. The default File Upload Preferences (SM202550) cap is 25 MB per file; larger files require either the cap to be raised or external storage104. Acumatica supports Azure Blob, AWS S3 and Google Cloud Storage as external file providers — Acumatica stores a pointer and the binary lives outside the database103.

For large attachment estates (hundreds of GB) the pattern most teams adopt is external storage from day one, with a backfill script that bulk-uploads the binaries into the configured external store before Acumatica pointers are loaded.

Audit trail, ownership and original timestamps

Acumatica's Field-Level Audit feature (Configuration → Audit) tracks per-field before/after values going forward once enabled on a screen, but it does not retroactively reconstruct source-system history. The AuditHistory DAC stores ModifiedFields, user and timestamp, and is queryable through Generic Inquiries with the Field-Level Audit role assigned132.

On bulk import, the standard CreatedDateTime, LastModifiedDateTime, CreatedByID and LastModifiedByID columns are stamped by the framework — they cannot be overridden through Import Scenarios on the standard screens. The mitigation is to add a pair of custom fields (UsrLegacyCreatedDateTime, UsrLegacyCreatedBy) on every DAC where the audit trail matters, populate them from the source export, and rewrite any historical-period reports to use the legacy fields rather than the system columns.

ERP-specific: Customization Projects, Generic Inquiries, Snapshots

Customization Projects do not import from any source — they are rebuilt against the destination DACs. Plan to spend the first sprint of the project enumerating every customisation on the source system (custom fields, screen extensions, automation steps, workflows, custom reports) and triaging them into Migrate / Replace-with-standard / Retire. Acuminator, Acumatica's Visual Studio analyser, is the recommended tool for any C# extension work41.

Generic Inquiries (SM208000) — the platform's no-code data-view builder — are the foundation of dashboards, OData feeds and many ad-hoc reports. Plan to rebuild key GIs in sandbox during cutover prep so finance has a working trial balance, AR aging and inventory valuation report from day one. Snapshots (System Management → Snapshots) are the standard way to clone a sandbox tenant for training, parallel testing or rollback; deleted snapshots are gone permanently unless exported to a workstation first123.

The pitfalls that derail Acumatica migrations

Nine specific failure modes — ranked by impact, each tied to the exact Acumatica mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between Import Scenarios completing and finance being allowed to post into the live ledger. Acumatica's own F110 Data Migration course recommends three validation stages: a sandbox dry-run with 10 percent of records and stakeholder spot-checks, the full load with real-time reconciliation against source counts and balances, and a 30-day post-go-live data-quality audit including the first month-end close97.

Build a reconciliation pack using Generic Inquiries — one per object — that compares source totals against destination totals on each of these dimensions. Anything outside a tolerance you agreed with the controller in advance (typically zero for cash, $1 for AR/AP balances, $50 for inventory valuation) gets investigated before users get login access.

  • Trial balance by account by period vs. source — debits and credits must tie to the cent on every Branch and every Currency.
  • AR aging by customer by bucket vs. source — opening AR balance per customer per aging bucket, summed and compared.
  • AP aging by vendor by bucket vs. source — opening AP balance per vendor per aging bucket, summed and compared.
  • Inventory quantity on hand by warehouse by item vs. source — units and valuation must reconcile, with cost layers (FIFO, average, standard) explained.
  • Customer and Vendor master record count vs. source — minus deliberately excluded rows (inactive accounts older than retention threshold, dedup merges).
  • Open Sales Orders and Purchase Orders with header totals and line counts — by status, owner and date bucket.
  • Currency rates per (CurrencyID, RateType, EffectiveDate) present for every date referenced by an open document — missing rates cause silent revaluation at spot.

On top of GI-driven reconciliation, run a manual spot-check protocol: pick 30 random records across Customers, Vendors and Items, and verify each field against the source UI. Pick five high-value AR invoices and five high-value AP bills and trace the full document — header, lines, taxes, applications. If a non-trivial discrepancy shows up in three or more of the 30, halt the cutover, fix the root cause in the Import Scenario, restore the snapshot, and re-run.

Acumatica's native rollback is the Snapshot subsystem. The standard pattern: take a Snapshot of the empty configured tenant before any data load, run the full import, validate, and if catastrophe strikes restore the Snapshot and re-run123. Export the Snapshot to a workstation before deleting it.

There is no native row-level undo for an Import Scenario — you either restore the Snapshot or build a delete Import Scenario keyed on an UsrImportBatchID custom field stamped on every loaded row.

Cutover sequencing: (1) source goes read-only at end-of-business on Friday; (2) source closes its final period; (3) final delta export captures everything that changed during the dry-run window; (4) configured Acumatica tenant snapshot is taken; (5) Import Scenarios run in the documented order — Accounts → Subaccounts → Classes → Customers → Vendors → Items → opening trial balance → open AR → open AP → on-hand inventory → optional historical detail.

Then: (6) reconciliation GIs run; (7) Migration Mode flags flipped off; (8) controller signs off; (9) users get login access Monday morning with a 48-hour hyper-care window; (10) source system kept in read-only mode for 90 days, then decommissioned.

Migration partners and tools

Gold-certified partners, ETL vendors, specialist migration shops — what each is good for and how to choose.

Acumatica is sold and implemented exclusively through a channel of VARs, ISVs and consultancies — there is no direct-sales motion. Partners are tiered Gold, Silver and Bronze by certification and revenue, with edition specialisations (Manufacturing, Distribution, Construction, Field Service). For finance-heavy migrations specifically, partners with a published Sage 300 → Acumatica, Dynamics GP → Acumatica or NetSuite → Acumatica practice tend to ship cleaner than generalist implementers because they have already met the specific subledger mapping gotchas.

Named Gold-certified partners visible in the public partner directory include Blytheco, NexTec Group, Cortekx HGL, PC Bennett Solutions, Cloud 9 ERP Solutions, Prometheus Technology Services and Revive ERP — each offers fixed-scope migration packages alongside ongoing managed services and edition-specific add-ons. ISV partners on the Acumatica Marketplace add depth in narrow verticals (process manufacturing, e-commerce connectors, payroll, document management) that often get woven into the migration scope.

On the ETL and iPaaS side, Skyvia, Workato, Celigo, Boomi, MuleSoft, Fivetran and Airbyte all have Acumatica connectors. Their role in a migration is rarely the migration itself — it is the staging layer that lands source data into a warehouse, the transformation layer that converts picklist codes and resolves Customer Classes, and the ongoing-sync layer that takes over post-migration.

Skyvia is the most commonly cited tool for direct CSV-into-Acumatica loads with full INSERT, UPDATE, DELETE and UPSERT semantics.

Managed-migration cost ranges vary widely. Acumatica's own consulting rate ranges from $150 to $300 per hour, with integrations costing $1,000 to $15,000 depending on complexity and number of source systems. A clean QuickBooks-to-Acumatica financials-only migration of under 25,000 records often lands in the $10,000–$25,000 range with a fixed setup fee plus per-object pricing.

A Dynamics GP-to-Acumatica project with multi-entity GL, open AR/AP, inventory cutover and three years of historical drilldown typically runs $40,000–$200,000, with the upper end driven by record count, custom-field complexity, historical-data depth and the number of integrations rebuilt rather than re-pointed.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Acumatica migrations and handles the chart-of-accounts mapping, GL opening-balance design, Import Scenario authoring, picklist code conversion, multi-currency rate-history load, and reconciliation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on record count, source platform and edition, with separate line items for Custom DAC extensions, Generic Inquiry rebuilds and historical-data depth so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want a Gold-certified partner with edition specialisation, an iPaaS-first approach, an ISV bundled with the implementation, or a specialist migration vendor. [Explore FlitStack →](/contact)

Acumatica migration checklist

An exhaustive, phased punch list for moving master, transactional, and historical data into Acumatica Cloud ERP without breaking the general ledger or subledger reconciliation. Typical timeline: 12–28 weeks.

0. Decide & Plan10 tasks
  • Confirm the Acumatica edition and deployment model under contract. Document whether the target is SaaS, Private Cloud Subscription (PCS), or Private Cloud Perpetual (PCP), and which industry edition applies (General Business, Manufacturing, Distribution, Construction, Field Service, Retail-Commerce). Edition controls which modules and Import Scenarios ship in the tenant.If skipped: Building a migration plan against the wrong edition surfaces missing forms and DACs only after data is staged.
  • Confirm the licensed resource level and transaction-per-hour ceiling. Acumatica SaaS resource levels (Small through 4X-Large) cap concurrent users, transactions per hour, and commercial transactions per month per the Licensing Guide Supplement. Size the cutover plan against the ceiling that is actually licensed.If skipped: Bulk-loading above the licensed transactions-per-hour ceiling degrades performance for everyone on the tenant and can stretch cutover beyond the window.
  • Define migration scope by module and object. Document every in-scope object explicitly: GL accounts, subaccounts, branches, customers, vendors, employees, stock items, non-stock items, item classes, units of measure, BOMs, sales orders, purchase orders, AR/AP open documents, projects, fixed assets, attachments. Mark each as full-history, open-only, or out-of-scope.If skipped: Undocumented scope creep around historical AR/AP and project transactions is the single biggest cause of cutover slippage.
  • Decide how many years of historical transactions migrate. Pick a cutoff (commonly 1–3 fiscal years of closed activity, all open documents). Document the cutoff date and the rationale; anything older stays in the legacy system as read-only reference.If skipped: Migrating decades of closed transactions inflates database size, slows snapshots, and stretches reconciliation with no operational payoff.
  • Decide the cutover date relative to the fiscal calendar. Anchor go-live to a period boundary — typically the first day of a new fiscal year or the first day of a clean period. The opening-balance journal is simpler when the cutover lands on a period boundary.If skipped: A mid-period cutover forces partial-period journals and double-counts revenue and expense across the legacy and new ledgers.
  • Identify compliance and data-residency constraints affecting tenant placement. Capture GDPR residency, SOC2 evidence retention, HIPAA log requirements, and industry-specific retention rules that govern where the Acumatica database may live and how long snapshots must be retained.
  • Assign a single accountable owner for the migration. Name one DRI plus named leads for finance, distribution, manufacturing, projects, IT, and end-user enablement. Every cross-team decision routes through the DRI.
  • Document explicit success criteria for go-live. Write down what must be true to declare cutover complete — trial balance ties to source within a defined tolerance, AR/AP aging matches by customer/vendor, inventory quantity-on-hand reconciles by warehouse, open sales and purchase orders all loaded.
  • List out-of-scope items in writing. Examples: historical email threads, legacy custom reports, terminated employee records older than retention, closed projects beyond cutoff. Circulate the list to all stakeholders.If skipped: Items not explicitly out-of-scope reappear as last-minute demands during sandbox testing.
  • Set and communicate the source-system freeze window. Pick the date and time after which no new transactions post in the legacy system. Broadcast it to every team that writes to the legacy.If skipped: Late writes to the source after final export create a delta no one reconciles until users notice missing transactions post-cutover.
1. Pre-Migration Prep28 tasks
  • Run a dedup pass on customers using legal name and tax ID as match keys. Resolve duplicates in the source before export so Acumatica Customer IDs map one-to-one.If skipped: Duplicate customers carry duplicate open AR invoices into Acumatica and break customer-level aging reconciliation.
  • Run a dedup pass on vendors using tax ID and remit-to bank account. Merge duplicates in the source so vendor open AP and 1099 totals consolidate cleanly.
  • Run a dedup pass on stock items using primary identifier and UPC. Resolve duplicates before the Inventory ID mask is finalized in Acumatica.If skipped: Duplicate stock items split on-hand quantities across two IDs and break inventory valuation.
  • Standardize address fields, country codes, and state/province codes to ISO values. Acumatica validates country and state values against its country/state lookups; non-standard codes fail on import.
  • Standardize phone-number and email formatting in source records. Normalize phone to E.164 where possible and lowercase emails to avoid case-sensitive dedup mismatches.
  • Identify and resolve records with missing required fields. Acumatica enforces required fields at the DAC level (PXDefault and PXUIField Required attributes). A row missing a required value fails the entire Import Scenario step.If skipped: Missing required values surface as cryptic errors mid-import and stall the load.
  • Export a baseline record count per object from the source system. Capture row counts for customers, vendors, items, open AR invoices, open AP bills, open SOs, open POs, GL accounts, subaccounts. These become the Phase 6 reconciliation targets.
  • Archive or purge legacy records that fall outside the documented retention scope. Removing out-of-scope data at the source is cleaner than filtering it out of every transform.
  • Provision the production Acumatica tenant. Confirm the tenant URL, login tenant name, and admin credentials. For SaaS, confirm the deployment region matches the residency decision from Phase 0.
  • Provision a sandbox tenant mirroring production config. Use the Acumatica Snapshot feature to keep the sandbox aligned with production configuration. Snapshots capture configuration plus data and can be restored into the sandbox.If skipped: Sandbox config drift from production means sandbox test results do not predict production behavior.
  • Configure company-level settings: base currency, fiscal year start, decimal precision, time zone. These settings drive how Acumatica interprets every imported amount and date. Lock them before any data lands.If skipped: Changing base currency or fiscal year after data loads requires a full tenant reset.
  • Define the fiscal calendar through the year of cutover plus one year forward. Create financial periods so that opening-balance journals and historical documents can post to the correct period.If skipped: Posting to a period that has not been generated throws an error and aborts the import.
  • Build the chart of accounts in Acumatica before any subledger import. Create GL account IDs, account classes, and account groups. Decide active/inactive status per account.
  • Build the subaccount structure and segment definitions. Define each subaccount segment, its length, and its lookup table. Subaccounts are a financial dimension separate from the main account.If skipped: Reworking the subaccount segment structure after transactions post requires reposting every affected journal.
  • Configure branches and ledgers. Define each legal entity or operating branch. Branch is a required dimension on most financial transactions.
  • Configure currencies, exchange-rate types, and translation methods if multi-currency is in scope. Create each ISO currency, define daily/monthly rate types, and set the translation method per account class.
  • Create user accounts and assign predefined roles. Use Acumatica predefined roles (AP Admin, AR Clerk, GL Admin, CR Sales Representative, Internal Employee, Internal User) plus any custom roles. Assign Field-Level Audit role to anyone who needs to view AuditHistory.
  • Create custom fields and User-Defined Fields (UDFs) on each affected DAC before import. Use the Customization Project tooling to add custom fields as DAC extensions, with PXDBString/PXDBDecimal/PXDBDate type attributes matching the source data type so they are visible to the import path.If skipped: Importing into a field that does not yet exist in the destination silently drops the data with no error.
  • Configure PXStringList picklist fields with both internal code and display label. Acumatica picklist fields store an internal code (e.g. 'C', 'E', 'T', 'R') and display a label (e.g. 'Call', 'Email', 'Standard', 'At Risk'). Imports must supply the internal code, not the label.If skipped: Importing the human-readable label into a PXStringList field fails validation row by row.
  • Publish the Customization Project to the tenant. Custom fields and DAC extensions take effect only after the project is published.
  • Configure File Upload Preferences (form SM202550) for file type and size limits. Default attachment size cap is 25 MB. Raise it if scanned PDFs or images in scope exceed that, and add any non-default file extensions you must accept.If skipped: A 25 MB upload cap rejects oversized attachments silently during attachment migration.
  • Configure external file storage (Azure Blob or equivalent) if attachment volume warrants it. Acumatica supports external storage providers; the DB stays lean and storage scales independently. Test the round trip in sandbox before flipping production.
  • Configure Audit History on every audited form. Enable field-level auditing on master tables (Customers, Vendors, Items, Employees, GL accounts) so post-cutover changes are tracked from go-live forward.
  • Pause every outbound integration and email automation in the destination. Disable Commerce Connectors, Outlook integration, push notifications, and any auto-emailing workflow until cutover validation completes.If skipped: Loading 50,000 customers with email automation enabled spams every record with welcome emails on import.
  • Take a baseline snapshot of the empty configured tenant. Use the Snapshot feature to capture the pristine, configured-but-empty state. This is the rollback target if Phase 5 needs a full restart.
  • Broadcast the source-system freeze window to all users. Send the freeze date and time at least two weeks ahead, repeat the week before, and post a banner on the source system if possible.
  • Schedule role-based Acumatica training sessions before cutover. Segment by role: AP clerks, AR clerks, GL accountants, inventory clerks, sales reps, project managers. Use Acumatica Open University course paths as the curriculum spine.
  • Designate first-responders for the first 48 hours post-cutover. Name one person per functional area to triage user issues, with a shared inbox or ticket queue.
2. Source Export16 tasks
  • Export the full chart of accounts as CSV. Include account ID, description, account class, account type (asset/liability/income/expense), active flag, and any custom analytical attributes.
  • Export the full subaccount list as CSV. Include subaccount code, segment values, description, and active flag.
  • Export the closing trial balance at the cutover period as CSV. One row per GL account plus subaccount plus branch plus currency. Debits and credits must net to zero.If skipped: An unbalanced trial-balance export silently corrupts opening balances and forces a full reload to fix.
  • Export the customer master as CSV with all standard and custom fields. Include customer ID, legal name, billing/shipping addresses, tax ID, payment terms, credit limit, statement cycle, default branch, salesperson.
  • Export the vendor master as CSV with all standard and custom fields. Include vendor ID, legal name, remit-to addresses, tax ID, default expense account, payment terms, 1099 box, AP cash account.
  • Export the employee master as CSV. Include employee ID, name, department, position, default branch, default cash account, expense approval workflow assignment.
  • Export the stock item master, item classes, and units of measure as separate CSV files. Include inventory ID, description, item class, base UoM, sales UoM, purchase UoM, conversion factors, lot/serial control flags, valuation method, price classes, posting class.
  • Export open AR invoices, credit memos, and unapplied payments. One row per document including document type, reference number, customer, currency, document date, due date, amounts, tax, and open balance.
  • Export open AP bills, debit adjustments, and prepayments. One row per document including document type, reference number, vendor, currency, document date, due date, amounts, tax, and open balance.
  • Export open sales orders and open purchase orders with line detail. Header and lines as separate files; preserve order-to-line linkage via order number.
  • Export inventory quantity-on-hand by warehouse and location as of the freeze date. One row per item per warehouse per location with quantity, base cost, last cost, and lot/serial number where controlled.
  • Export historical multi-currency exchange rates by date. Pull daily rates for the full historical window so historical document revaluations match the source.
  • Export attachment metadata and binary files. Metadata CSV must include source record key, file name, MIME type, file size, and original upload timestamp. Binary files exported to a directory structure that mirrors the metadata.
  • Export legacy security and role configuration as reference. Capture which users had which permissions; this informs Acumatica role assignment but does not import directly.
  • Capture screenshots and configuration exports of legacy reports, automations, and dashboards. These are rebuilt by hand in Acumatica's Report Designer, Generic Inquiry, and Dashboard tools later. Treat them as reference, not import payloads.
  • Stamp every export file with the exact extract timestamp. Embed it in the filename and in a footer row. Phase 5 needs this to compute the delta from the final export.
3. Transform & Map30 tasks
  • Build a master mapping spreadsheet, one row per source field. Columns: source object, source field, source type, destination DAC, destination field, destination type, transformation rule, nullability, required-on-import flag, sample value.If skipped: Without a single mapping spreadsheet, the team rebuilds field decisions in transform scripts and validation queries inconsistently.
  • For every transactional object, mark the two-part key (DocType, RefNbr). Acumatica keys most transactional records as (Document Type, Reference Number). The DocType is the very first field on the Acumatica form and is usually auto-defaulted — easy to omit in scenarios.If skipped: Forgetting to map DocType causes import scenarios to misroute every transaction line into the wrong document.
  • Confirm the substitute key (CD) per master object. Customers, Vendors, Stock Items, Branches, and similar DACs expose both a numeric ID and a CD (the human-readable key) via PXSelector with SubstituteKey. Imports must reference the CD, not the underlying numeric ID.
  • Decide the upsert key for every Import Scenario. Usually the CD field for masters and (DocType, RefNbr) for transactions. Mark the key fields first in the scenario mapping — Acumatica requires keys to appear in the order they sit on the form.If skipped: Key fields mapped out of form order cause the scenario to fail silently or duplicate rows.
  • Document the strategy for source fields with no Acumatica equivalent. Three options: drop, concatenate into a Notes/Description field, or create a custom DAC extension. Decide explicitly per field.
  • Resolve every picklist value mismatch between source and destination. Map source picklist labels to Acumatica internal codes (PXStringList values). Document each mapping inline in the spreadsheet.
  • Convert every date and datetime value to ISO-8601 with timezone. Acumatica expects ISO date format on import; ambiguous DD/MM vs MM/DD strings get misparsed.
  • Normalize numeric values to the destination's decimal precision. Match the precision configured at the company level. Excess decimals on import get truncated or rounded in ways that break subledger ties to GL.
  • Re-encode every text field as UTF-8. Acumatica's SQL Server backend stores nvarchar columns. Non-UTF-8 source data produces mojibake on import.
  • Truncate or split source values that exceed Acumatica column length caps. Inventory ID, Customer ID, document Reference Number, and many other CD fields have hard length caps. The error message 'String or binary data would be truncated' is the symptom.If skipped: A single truncation in a key field corrupts every transaction referencing that key.
  • Strip or escape commas, double quotes, and newlines inside CSV fields. Acumatica's CSV provider misparses unescaped delimiters. Use RFC-4180 quoting consistently.
  • Avoid special characters in master record codes (Inventory ID, Customer ID, etc.). Unicode codes work on master creation but break referencing imports with errors like 'the record couldn't be imported due to an error in the next record', cascading through every subsequent row.If skipped: Special-character codes pass the master import but cause subledger imports to fail in chains hundreds of rows long.
  • Pad and prefix auto-generated codes using a deterministic formula. Use the Acumatica Import Scenario formula engine (PadLeft, CStr, LineNbr) to generate stable codes for migrated records — e.g. ='C' + PadLeft(CStr(125+LineNbr()), 9, '0').
  • Validate every CSV file parses cleanly with the chosen tool. Use a scripting tool of your choice to round-trip parse and re-emit. Any row that does not round-trip cleanly will not import.
  • Decide the strategy for original document timestamps. Option A: post historical documents with their original document date inside Migration Mode so AR/AP aging is correct. Option B: capture the original timestamp in a custom field and let the system stamp today. Pick one per object.If skipped: Re-stamping AR/AP document dates to cutover day collapses aging into a single bucket and breaks customer dunning.
  • Decide the strategy for record ownership. Best-match imported records to existing user logins by email, or assign every imported record to a single 'data migration' service user. Document the choice per object.
  • Decide the strategy for file attachments. Option A: re-upload binaries and attach them to the new record. Option B: leave binaries in legacy storage and store a URL in a custom field. Option C: configure external file storage and stage files there pre-import.
  • Decide ON DELETE behavior for any custom parent/child DACs. Custom DACs with PXSelector references need explicit cascade or restrict behavior in the RowDeleting/RowPersisting event with PXDBOperation.Delete checks. Document the rule before loading parent data.
  • Build the Acumatica chart of accounts, subaccount segment values, and branch list as importable CSVs. Master GL data loads first. Validate that every subaccount segment value referenced by any transactional file exists in the subaccount CSV before loading transactions.If skipped: Loading a journal that references a subaccount segment value not yet created fails the entire batch.
  • Prepare the opening-balance journal entry, excluding the YTD Net Income account. Acumatica auto-derives YTD net income from the period-close mechanism. Including a YTD Net Income line in the opening journal double-counts it. Verify debits equal credits before posting, release the batch to the final period of the prior fiscal year (for example period 12-2025), then print a trial balance for the first period of the cutover year to confirm Acumatica auto-closed prior-year income and expense into Retained Earnings.If skipped: Including a YTD Net Income line double-counts income from the migration date forward; reconciliation requires a reversing journal and a reposting.
  • Turn on Migration Mode in each subledger (AR, AP, Inventory) before loading historical open documents. Migration Mode lets you post AR invoices, AP bills, and inventory transactions with original document dates without re-posting to GL. Master data and balances already live in GL via the opening journal, so subledger posting is suppressed.If skipped: Loading historical AR/AP outside Migration Mode double-posts to GL and inflates account balances by every migrated open document.
  • Build the Item Class master, Units of Measure with conversion factors, and the Inventory ID segmented key mask. Inventory ID mask defines length and segment structure; reworking it after stock items load is destructive. Item Class drives default GL accounts on inventory transactions.If skipped: Changing the Inventory ID mask after stock items are loaded breaks every downstream document referencing the old key.
  • Load inventory quantity-on-hand as physical inventory transactions or via the dedicated migration form. Post quantities per warehouse and per location, with lot/serial numbers on controlled items. Confirm IN Preferences flags around posting to GL match the chosen migration approach so inventory values do not double-post.
  • Stage the historical multi-currency exchange-rate table. Load daily rates for every currency pair in use across the historical window. Without these, historical document revaluations and translations will not match the source.If skipped: Missing historical rates cause translated balances in reporting currency to diverge from source and break audit trail.
  • Confirm fiscal periods are generated through the cutover year plus one full year forward. Use the financial-period generation form. Documents posted into ungenerated periods fail.
  • Prepare AR open invoices, credit memos, and unapplied payments for Migration Mode load. Set Document Date to the original date, set the document amount to the original document amount, and set the open balance to the current open balance. For unreleased AR retention, enter the AR Invoice with $0 AR Amount and the retainage amount filled, in Migration Mode, then use Release Retainage to finalize.
  • Prepare AP open bills, debit adjustments, and prepayments for Migration Mode load. Mirror the AR pattern: original document date, original document amount, current open balance. Verify Cash Discount Account and Cash Discount Subaccount default values are configured at the vendor or scenario level; missing values throw 'Cash Discount Account cannot be empty' and 'Cash Discount Sub. cannot be empty' errors.If skipped: Empty default discount accounts halt the AP open-bills load and require a tenant-level configuration fix mid-cutover.
  • Reconcile prepared subledger open balances against the GL opening journal before loading. AR open total must equal the AR control account balance from the opening journal. Same for AP, inventory, and other subledger-backed accounts.If skipped: Subledger-to-GL drift detected after load forces reversal of the entire load and a redo.
  • Decide whether to migrate closed historical AR/AP documents or surface them via read-only inquiry from the legacy system. Migrating closed history inflates DB size and reconciliation effort. Many teams migrate only open documents plus current-fiscal-year closed activity, leaving older closed history in the legacy as reference.
  • Turn Migration Mode off in every subledger before users transact. Migration Mode suppresses GL posting; leaving it on after go-live causes net-new transactions to skip the ledger silently.If skipped: Forgetting to disable Migration Mode lets live transactions bypass GL — the ledger silently diverges from operations.
4. Sandbox Test Migration14 tasks
  • Restore a fresh snapshot of the configured-but-empty tenant into the sandbox. Start from a known clean state so the test result is reproducible.
  • Load a 1–5% representative sample of each master object via Import Scenarios. Use the Import Scenario form (SM206025); map keys first and in form order. Validate each scenario before scaling up.
  • Confirm every Import Scenario maps the DocType key for transactional records. DocType is auto-defaulted on the form and easy to skip; without it, every line lands on the wrong document.If skipped: An entire transactional import can succeed numerically but be silently misrouted because DocType was unmapped.
  • Spot-check 10 random sandbox records per object field-by-field against the source. Open each record in the Acumatica UI; verify every standard, custom, and PXStringList field arrived with the correct internal code and label.
  • Stress-test special characters, long strings, and Unicode in stock item and customer codes. Load a deliberately gnarly batch to confirm encoding holds across the full pipeline.If skipped: Unicode in Inventory ID codes silently breaks downstream transactional imports in chains.
  • Test the relationship integrity of master-detail loads (SO header to lines, AR document to lines). Confirm that detail rows attached correctly under the right header reference number.
  • Test the Migration Mode flow end-to-end on a sample of AR and AP open documents. Toggle Migration Mode on, load samples, validate aging report, toggle Migration Mode off, post a fresh transaction, and confirm GL receives it correctly.If skipped: Discovering the Migration Mode toggle is broken at production cutover is a hard stop.
  • Test the opening trial-balance journal in the sandbox with a non-trivial subset of accounts. Post the journal, print the trial balance and balance sheet for the first period after cutover, and confirm prior-year income and expense rolled to Retained Earnings.
  • Test attachment migration on a sample of records. Upload binaries from staged storage, link them to the right parent record, and confirm File Upload Preferences (SM202550) accepts every file type and size.
  • Time the sample run and extrapolate to full production volume. If the 5% sample takes 4 hours, full volume will not fit in an 8-hour cutover window. Use this number to decide whether to shorten cutover scope or extend the window.If skipped: Discovering the cutover window is too short at hour 6 of cutover is a recoverable but costly mistake.
  • Have a finance owner spot-check 10 customer accounts, 10 vendor accounts, and the trial balance. Domain experts catch reconciliation mistakes that field-level QA does not.
  • Have an inventory owner spot-check on-hand totals by warehouse. Inventory clerks notice missing lot/serial control or wrong UoM conversions immediately.
  • Capture every defect from sandbox testing in a tracked list with owner and target fix date. No defect carries forward to production cutover unfixed without explicit sign-off.
  • Get written sandbox sign-off before scheduling production cutover. Sponsor, finance lead, and IT lead all sign. Sign-off references the defect list and the sandbox snapshot ID.If skipped: Skipping sign-off means cutover happens with unresolved sandbox defects and no record of who approved them.
5. Production Cutover14 tasks
  • Confirm the source-system freeze; verify zero writes in the last hour. Pull a final transaction-count report from the source and compare to the freeze-announcement count. Any delta becomes the final-delta export.
  • Take a final delta export from the source system. Re-export every object that may have changed since the Phase 2 baseline. Stamp the export timestamp.
  • Take a fresh snapshot of the production tenant pre-load as a rollback target. If catastrophic failure occurs partway through cutover, this snapshot is the restore point.If skipped: Without a pre-load snapshot, partial-load corruption is unrecoverable except by manual cleanup of every imported record.
  • Confirm every outbound integration and email automation is disabled. Recheck the Phase 1 pause list. Anything missed will fire on every imported record.
  • Load master data in dependency order: branches, ledgers, currencies, chart of accounts, subaccounts, item classes, UoMs, customers, vendors, employees, stock items, non-stock items. Master records must exist before any transaction that references them. Validate each step's row count before moving to the next.
  • Post the opening-balance journal to the prior period. Excluding the YTD Net Income line. Confirm debits equal credits. Release the batch. Print the trial balance for the first period of the cutover year and confirm Retained Earnings reflects auto-closed prior-year income and expense.If skipped: An unbalanced opening journal blocks every subsequent load that posts to GL.
  • Turn on Migration Mode in AR and load open AR documents. Load invoices, credit memos, unapplied payments, and unreleased retention. Validate AR aging by customer ties to source totals.
  • Turn on Migration Mode in AP and load open AP documents. Load bills, debit adjustments, prepayments. Confirm AP aging by vendor ties to source totals.
  • Load inventory quantity-on-hand by warehouse and location. Confirm IN Preferences posting flags match the plan from Phase 3. Verify on-hand quantity by item ties to source.
  • Load open sales orders and open purchase orders with line detail in dependency order. Header first, then lines keyed off the header reference number.
  • Load attachments, linking each to the correct parent record. Verify File Upload Preferences (SM202550) accepts every file size and type. Failed uploads should be logged and retried, not skipped silently.
  • Capture the import job ID, row counts, and error logs at every step. These become the cutover audit trail and the input to Phase 6 reconciliation.
  • Turn Migration Mode off in every subledger. Final step before re-enabling live transactions. Verify by posting a single test invoice and confirming GL receives it.If skipped: Migration Mode left on means live transactions skip GL posting and the ledger silently diverges.
  • Re-enable integrations and email automations only after validation in Phase 6 passes. Hold integrations off through validation so reconciliation isn't polluted by outbound noise.
6. Validate19 tasks
  • Reconcile the Acumatica trial balance to the source trial balance at cutover period. Every account, every subaccount, every branch. Document any tolerance threshold and investigate every difference above it.If skipped: Unexplained GL deltas at go-live cascade into every downstream financial report for the rest of the year.
  • Reconcile AR aging by customer between Acumatica and the source. Total open balance per customer must match. Mismatches typically trace to missed open documents or wrong document dates.
  • Reconcile AP aging by vendor between Acumatica and the source. Total open balance per vendor must match. Same diagnosis pattern as AR.
  • Reconcile inventory quantity-on-hand by item by warehouse. Run a Generic Inquiry (form SM208000) on quantity-on-hand and compare to source.
  • Reconcile inventory valuation by item class. Confirm valuation method (average, FIFO, standard) produced the expected total value per item class.
  • Compare record counts per object against the Phase 1 baseline. Use Generic Inquiries to pull counts directly from Acumatica. Investigate any delta.
  • Cross-check 25–50 randomly selected master records field-by-field against the source. Mix of customers, vendors, items, employees. Look for silent field drops in custom fields and PXStringList values.
  • Verify open sales orders link to the correct customer and ship-to address. Sample at least 20 orders across customer types.
  • Verify open purchase orders link to the correct vendor and remit-to address. Sample at least 20 POs.
  • Verify attachments are accessible and linked to the right parent record. Sample 25 attachments across customers, vendors, AR documents, AP documents.
  • Verify lot- and serial-controlled inventory items show the right lot/serial values. Open the Inventory Lookup form and inspect a sample by warehouse and location.
  • Confirm AuditHistory is recording field changes post-cutover. Make a known change on a sample audited record, open Tools > Audit History on the form, and confirm the change appears with user, timestamp, before-value, and after-value.
  • Verify original document dates on historical AR and AP documents. Open a sample of migrated documents and confirm Document Date matches source. Re-stamping to cutover day means the Migration Mode strategy did not hold.If skipped: If document dates landed on cutover day, every aging bucket is wrong and the migration must be partially redone.
  • Run the compliance check appropriate to your residency obligations. GDPR confirmation of tenant region, SOC2 evidence capture of cutover logs, HIPAA log retention configuration as required.
  • Confirm the cutover snapshot is archived to long-term storage. The pre-load and post-load snapshots become the forensic record. If they are deleted from the tenant they are deleted permanently; export them off-tenant before deletion.
  • Walk 3–5 power users through their day-to-day workflows in the migrated tenant. Have a finance lead run a sample AP payment, a sales rep create a sales order, an inventory clerk receive a PO, a project manager post a time card.
  • Document every UAT-surfaced data issue in a tracked list. Categorize as block, must-fix-before-go-live, or post-cutover cleanup.
  • Confirm key reports and Generic Inquiries produce reasonable numbers. Run the trial balance, AR aging, AP aging, inventory summary, and at least one operational dashboard. Outputs that look wildly off must be investigated before sign-off.
  • Get written go-live sign-off from the migration sponsor and finance lead. Sign-off references the reconciliation reports, the UAT issue list, and the open-defect carry-forward list.If skipped: Skipping written sign-off leaves no record of who approved the state of the data at go-live.
7. Post-Migration Cleanup12 tasks
  • Send a go-live communication to every end user. Include the tenant URL, login instructions, where-to-get-help contact, and the read-only date for the legacy system.
  • Run role-based training for end users in the first week post-cutover. Hand off the Acumatica Open University course paths and schedule live walkthrough sessions per functional area.
  • Set the legacy source system to read-only. Disable write access for all users. Announce the read-only date in advance so any last reference pulls happen before lockdown.
  • Rebuild reports in Acumatica Report Designer or as Generic Inquiries. Most legacy reports do not transfer. Use the Phase 2 reference screenshots as the spec.
  • Rebuild dashboards using Acumatica's Dashboards module. Populate widgets from Generic Inquiries built on the migrated data.
  • Rebuild automations, workflow rules, and notification templates. Acumatica automation steps, business events, and notification templates replace legacy equivalents. Test each before turning on broadly.
  • Re-enable third-party integrations one at a time. For each integration (Commerce Connector, payment gateway, payroll, BI tool), confirm credentials, test in sandbox first, then enable in production with monitoring.
  • Schedule a 30-day post-cutover retrospective. Capture what went well, what nearly broke, and what should change for the next migration.
  • Set the legacy system's decommission date. Typically 90 days post-cutover, after the final reconciliation pass and audit cycle.
  • Archive source-system exports and snapshots to long-term storage. Acumatica deletes snapshots permanently if removed without export. Move them off-tenant for forensic and audit retention.If skipped: Deleted snapshots cannot be recovered; later audit requests have no source-of-truth record.
  • Document the final migration project closure. Final status report, the defect carry-forward list with owners, lessons learned, formal project closure with sponsor.
  • Set a 90-day calendar reminder to delete the data-migration service user if used. If a single service user took ownership of imported records, reassign or archive it after the migration project closes.

Questions, answered

Migrating to Acumatica: questions

How long does migration to Acumatica take?

A clean financials-only migration with under 5,000 master records and no inventory runs four to eight weeks end-to-end. A mid-market Manufacturing or Distribution project with open subledgers, BOM, multi-entity GL and historical detail runs three to six months of elapsed time including sandbox dry-runs, parallel testing, training and a hyper-care window.

Can I migrate from NetSuite to Acumatica?

Yes — NetSuite is one of the most common Acumatica migration sources. The typical pattern is to extract NetSuite data into SQL Server via a tool like Skyvia, reshape the chart of accounts and Item Classes against the Acumatica taxonomy, then load via Import Scenarios. Saved Searches and SuiteScript do not transfer.

Can I migrate from Dynamics GP to Acumatica?

Yes, and Dynamics GP-to-Acumatica is a well-trodden path with ISV-supported tooling. Most teams migrate only opening balances plus 12–24 months of detail and surface older history through a side-by-side viewer rather than pushing decades of legacy transactions through the new GL. Plan the segment redesign before any data movement.

Does Acumatica preserve original timestamps on import?

No on standard screens. CreatedDateTime, LastModifiedDateTime, CreatedByID and LastModifiedByID are framework-managed and stamped to import time. The standard mitigation is to add custom UsrLegacyCreatedDateTime and UsrLegacyCreatedBy fields on every DAC where the trail matters, populate them from the source export, and rewrite reports to use the legacy fields.

Can I migrate custom tables and DACs to Acumatica?

Yes, but custom DACs require a Customization Project that creates the database table, the DAC and a Screen or Generic Inquiry over the table. Plan the multi-step extension work before any custom-table import.

What happens to open AR and AP invoices during migration?

Open AR Invoices and AP Bills are loaded via Import Scenarios against the AR Invoice and AP Bill forms with Migration Mode enabled so the documents post to the subledger only and do not double-up the GL trial balance. Turn Migration Mode off only after every subledger ties to control accounts.

Is there an undo or rollback for Acumatica imports?

Yes via Snapshots. Take a System Management snapshot of the configured tenant before any import, validate, and if catastrophe strikes restore the snapshot and re-run. Export snapshots to a workstation before deletion — deleted snapshots are permanently gone. There is no row-level undo unless you stamp an UsrImportBatchID column.

Sources

  1. Acumatica — Wikipedia
  2. NetSuite to Acumatica migration via SKYVIA — r/Netsuite
  3. Best manufacturing ERP systems in 2026 — r/ManufacturingStack
  4. Acumatica Web Services and Integration Best Practices
  5. I330 Data Manipulation with Web Services — Acumatica Open University
  6. How to do bulk array upload — Acumatica Community
  7. Develop Integrations with Web Services — Acumatica Community
  8. Exposing a Custom table to integrations — Acumatica Community
  9. Acumatica Licensing Guide Supplement
  10. No-Code Customizations Guide — Acumatica Blog
  11. To Create a CSV Data Provider — Acumatica Help
  12. How to add Import Scenario to menu — Acumatica Community
  13. I100 Integration Scenarios — Acumatica Open University
  14. T210 Customized Forms and Master-Detail Relationship — Acumatica Open University
  15. Custom Field combo box list creation — Acumatica Community
  16. Acumatica Upgrades — Sandbox and Post-Upgrade Support — Acumatica Community
  17. User Roles: Predefined Roles — Acumatica Help
  18. User Roles: Predefined Roles (finance roles) — Acumatica Help
  19. SQL Server String or binary data would be truncated — Stack Overflow
  20. Special Characters in Codes — Acumatica Community
  21. Error processing Import Scenario on Vendors — Acumatica Community
  22. Integration Scenarios Training — Acumatica Open University (formulas)
  23. Validation of Records for Duplicates in Acumatica ERP
  24. Seeking Advice on Transferring Historical Data from Sage 300 to Acumatica — Acumatica Community
  25. F110 Data Migration 2025 R2 — Acumatica Open University
  26. External File Storage — Acumatica Community
  27. The file exceeds the maximum allowed size (25000 KB) — Acumatica Community
  28. FAQ (Snapshots) — Acumatica Cloud ERP
  29. How to migrate unreleased AR retention — Acumatica Community
  30. What is the best practice for doing cascading deletes? — Acumatica Community
  31. Audit Trail Reports and GIs — Acumatica Community
  32. Import and Export Scenarios (timestamps) — Acumatica Community
  33. Migration of Financial legacy Data into Acumatica — Acumatica Community
  34. Is Inventory Migration after 2021R1 be different? — Acumatica Community

Get a quote

Moving to Acumatica?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Acumatica setup with you, then send a quote.

Get a quote