ERP migration
Field-level mapping, validation, and rollback between etEngine and Acumatica. We move data and schema; workflows are rebuilt natively in Acumatica.
etEngine
Source
Acumatica
Destination
Compatibility
11 of 11
objects map 1:1 between etEngine and Acumatica.
Complexity
CModerate
Timeline
5–10 business days
Overview
Teams move from etEngine to Acumatica when their business has outgrown the flexibility or scalability of a smaller accounting platform — multiple warehouse locations, multi-entity reporting requirements, or the need for integrated project accounting and manufacturing. The migration carries everything etEngine stores natively (customers, vendors, inventory items, open sales orders, purchase orders, and their associated line items) into Acumatica's web-service-driven schema. The harder problems are mapping etEngine's custom fields and pick-list values to Acumatica UDFs and segmented keys, preserving GL-posting dates during import, and sequencing transactional records so foreign-key dependencies resolve correctly on the Acumatica side. FlitStack AI sequences the migration so master data loads first (Customers, then Vendors, then Inventory Items), followed by transactional headers, then line items — matching Acumatica's API insert order requirements. Workflows, automations, and scheduled tasks in etEngine do not migrate; they require a manual rebuild using Acumatica's automation engine or external workflow tools. We export the definitions as a reference package to support that rebuild work.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a etEngine object lands in Acumatica, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
etEngine
Customer
Acumatica
Customer (AR301000)
1:1etEngine customers map directly to Acumatica customers. The mapping extracts customer name, address, contact details, and tax registration from etEngine's customer record and inserts via Acumatica's Customer master screen. Duplicate customer names are flagged for de-duplication before insertion — Acumatica enforces unique CustomerCD per tenant.
etEngine
Vendor
Acumatica
Vendor (AP303000)
1:1etEngine vendors map 1:1 to Acumatica vendors. Address, payment terms, and tax ID fields transfer directly. etEngine's vendor type classification (domestic vs. international) maps to Acumatica's VendorClass, which gates tax calculation behavior and AP aging reports. Additional fields like 1099 reporting requirements, payment hold status, and primary contact information also map to corresponding Acumatica vendor fields. If etEngine stores multiple payment addresses per vendor, FlitStack maps these to Acumatica's Address sub-records with the primary payment address flagged appropriately.
etEngine
InventoryItem
Acumatica
InventoryItem (IN202500)
1:1etEngine inventory items map to Acumatica inventory items. ItemID becomes InventoryCD, Description maps directly, and ItemType (stock vs. non-stock vs. service) maps to Acumatica's ItemClass hierarchy. etEngine's cost layer information transfers to Acumatica's cost bucket if the migration preserves historical valuation.
etEngine
SalesOrder
Acumatica
SalesOrder (SO301000)
1:1Open sales orders from etEngine migrate as Acumatica sales orders. Order number becomes OrderNbr, customer lookup resolves via email-to-CustomerCD matching, and order date maps to Acumatica's OrderDate. Order statuses are mapped value-by-value so 'Open' maps to 'Open', 'Fulfilled' to 'Completed', etc.
etEngine
SalesOrderLine
Acumatica
SOLine (SOOrderLine DAC)
1:1Sales order lines migrate as sub-records of the Acumatica sales order. Each line links to the parent order via OrderNbr, pulls the InventoryCD from etEngine's item reference, and maps quantity and unit price. Line-level discount amounts transfer as a separate discount detail row in Acumatica.
etEngine
PurchaseOrder
Acumatica
PurchaseOrder (PO301000)
1:1Open purchase orders migrate to Acumatica's PO module. Vendor lookup resolves against the vendor mapping, and PO date transfers as the OrderDate. Acumatica requires the vendor record to exist before the PO can be inserted — this dependency is resolved in the sequencing step.
etEngine
PurchaseOrderLine
Acumatica
POLine (POOrderLine DAC)
1:1PO lines map similarly to sales order lines, linking to the parent PO via OrderNbr. The inventory item reference maps to Acumatica's InventoryCD. Extended cost and quantity transfer as-is; branch-specific warehouse assignments are set based on etEngine's location field or a default branch configuration.
etEngine
GLAccount
Acumatica
GLAccount (GL202500)
1:1etEngine GL accounts map to Acumatica chart of accounts. Account code structure (segment count) is preserved — if etEngine uses a 4-segment account code, FlitStack configures Acumatica's account segments to match so GL account combinations remain valid after migration. Subaccount segments are also mapped to maintain the full account combination hierarchy. FlitStack validates that all etEngine account codes exist in Acumatica's chart before transactional records insert, flagging any accounts that require creation in the target system first.
etEngine
CustomField (UDF)
Acumatica
UDF (User-Defined Field via DAC Extension)
1:1etEngine user-defined fields attached to customers, vendors, or inventory items require Acumatica UDF creation before data can populate. FlitStack generates the DAC extension definition (PXString, PXInt, PXDecimal, etc.) based on the etEngine field type, and creates the UDF in Acumatica's customization project before inserting records.
etEngine
Attachments / Documents
Acumatica
FileAttachments (NoteDoc DAC)
1:1Documents and file attachments linked to customer or order records in etEngine are extracted and reattached to the corresponding Acumatica entity via the NoteDoc DAC. Files are re-uploaded to Acumatica's file storage. The original file name and MIME type are preserved for reference.
etEngine
etEngineUser / Owner
Acumatica
Users (Contact + User DAC)
1:1etEngine user and owner IDs are resolved by email match against Acumatica's user list. If an Acumatica user account does not exist for a matched email, FlitStack flags the record for owner assignment — records can be assigned to a default Acumatica user or held for manual assignment.
| etEngine | Acumatica | Compatibility | |
|---|---|---|---|
| Customer | Customer (AR301000)1:1 | Fully supported | |
| Vendor | Vendor (AP303000)1:1 | Fully supported | |
| InventoryItem | InventoryItem (IN202500)1:1 | Fully supported | |
| SalesOrder | SalesOrder (SO301000)1:1 | Fully supported | |
| SalesOrderLine | SOLine (SOOrderLine DAC)1:1 | Fully supported | |
| PurchaseOrder | PurchaseOrder (PO301000)1:1 | Fully supported | |
| PurchaseOrderLine | POLine (POOrderLine DAC)1:1 | Fully supported | |
| GLAccount | GLAccount (GL202500)1:1 | Fully supported | |
| CustomField (UDF) | UDF (User-Defined Field via DAC Extension)1:1 | Fully supported | |
| Attachments / Documents | FileAttachments (NoteDoc DAC)1:1 | Fully supported | |
| etEngineUser / Owner | Users (Contact + User DAC)1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
etEngine gotchas
No public API — migration relies on vendor extracts
Shop-floor automation data is tightly coupled to the source system
Pricing and rate card are not public
Dynamic material planning calculations are ERP-specific
Acumatica gotchas
API user licenses cap concurrent sessions and request throughput
Multi-tenant filtering requires CompanyID awareness
Custom fields require separate discovery before field mapping
Notes and attachments use a separate linked table structure
Implementation timelines frequently run 3–9 months end-to-end
Pair-specific challenges
Migration approach
Assess etEngine schema and Acumatica destination configuration
FlitStack reads etEngine's API schema and identifies all active entities, custom fields, and pick-list value sets in use. We simultaneously assess the target Acumatica tenant to confirm which modules are activated (AR, AP, Inventory, PO, SO) and whether UDF DAC extensions need to be created. The output is a pre-migration checklist: custom fields to create, pick-list values to pre-populate in Acumatica configuration screens, and any Acumatica migration mode prerequisites.
Export master data from etEngine in dependency order
FlitStack exports etEngine Customers, Vendors, and InventoryItems first, as these are prerequisites for transactional records. The export pulls all active records plus any with open order references, using etEngine's REST API with pagination to handle large datasets. Each record is enriched with the etEngine record ID for traceability and de-duplication logic is applied to flag records with duplicate CustomerCD or VendorCD values.
Create UDFs and pre-populate Acumatica value sets
Before any data inserts, FlitStack deploys DAC extensions for etEngine custom fields and populates Acumatica's CustomerClass, VendorClass, and ItemClass value sets using Acumatica's configuration API. This step runs against the Acumatica tenant directly and must complete before the data migration begins — any custom field created mid-migration will be empty on records that inserted before the field existed, creating data gaps that are difficult to backfill after the fact.
Load master data and resolve owner assignments
Customers load first, then Vendors, then InventoryItems. Owner resolution maps etEngine user and owner email addresses to Acumatica user accounts — unmatched owners are flagged and assigned to a fallback Acumatica user or held for manual assignment. After each master data phase, FlitStack generates a record count and sample validation against Acumatica's API to confirm inserts succeeded. Validation includes checking for duplicate CustomerCD or VendorCD values, verifying required field completeness, and confirming that foreign-key references resolve correctly before proceeding to the next phase.
Run a sample migration with field-level diff
A representative slice of orders — typically 50 to 200 records spanning sales orders, purchase orders, and line items — migrates first. FlitStack generates a field-level diff showing each source field value against the corresponding Acumatica field after insertion. This validates status value mapping, foreign-key resolution, and custom field population before the full run commits. Any mapping gaps are corrected and the sample is re-run until the diff is clean.
Execute full migration with delta-pickup window and rollback plan
The full dataset migrates in the sequenced phases. A delta-pickup window of 24 to 48 hours captures any new records or modifications made in etEngine during the cutover. FlitStack enables Acumatica Migration Mode for the duration of the bulk insert and disables it with a post-insert GL consistency check. The audit log captures every record operation, and one-click rollback is available if reconciliation identifies unexpected gaps — the rollback restores the Acumatica tenant to its pre-migration state for a clean retry.
Platform deep dives
etEngine
Source
Strengths
Weaknesses
Acumatica
Destination
Strengths
Weaknesses
Complexity grading
Moderate ERP migration. 5 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Moderate migration
Derived from compatibility, mapping clarity, API constraints, and data volume across etEngine and Acumatica.
Object compatibility
5 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
etEngine: Not publicly documented.
Data volume sensitivity
etEngine doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during etEngine to Acumatica migration scoping. Not seeing yours? Book a call.
Walk through your etEngine to Acumatica migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave etEngine
Other ways to arrive at Acumatica
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.