The right Acumatica integration approach depends on the workflows you must run, the exceptions you must resolve, and who will own changes after launch. A native connector may fit a supported storefront and standard process. A Marketplace app can provide a specialized workflow with a vendor responsible for its product. Custom integration can address unusual requirements, but it also creates design, testing, and maintenance obligations. This guide gives a practical selection process so teams can compare options against evidence rather than a feature list.
Key points: Start with the business events and ownership boundaries. Confirm the exact product, Acumatica version, connector version, and supported entities. Test exceptions and upgrades as carefully as normal orders. Compare total lifecycle cost, including monitoring and support. Use a small proof of concept with real workflows before committing to a path.
Table of Contents
- What are the three integration approaches?
- Start with the workflow, not the connector category
- Define systems of record and event direction
- Assess fit for native Acumatica commerce integration
- Assess a Marketplace or partner app
- Assess custom integration
- Compare data coverage and mapping depth
- Compare exception handling and observability
- Compare security, upgrades, and support ownership
- Build a decision matrix that reflects your business
- Run a focused proof of concept
- Calculate lifecycle cost
- Plan implementation and acceptance
- Common selection mistakes
- Frequently asked questions
- Next step
- Sources and further reading
What are the three integration approaches?
A native connector is functionality delivered within Acumatica for supported commerce platforms and entities. Its setup, processing screens, and release compatibility follow Acumatica’s product documentation. A Marketplace or partner app is a product supplied by another vendor to connect Acumatica with a particular platform or business workflow. A custom integration is built for a specific organization’s requirements using APIs, events, import/export scenarios, or other supported interfaces. These labels describe ownership, not guaranteed quality. Each option must be evaluated in its installed version and configuration.
Some implementations combine the approaches. A standard connector may handle orders and inventory while a small custom service handles a special fulfillment event. That can be sensible if the boundary is clear. It can also create duplicate logic if the team does not document which path owns each entity. The objective is a reliable, supportable flow, not ideological purity about where the code lives. Acumatica’s Marketplace and Biz-Tech’s solution catalog show the breadth of available products; neither catalog proves fit for a particular workflow.
Start with the workflow, not the connector category
Write the events the business must exchange: product creation, price and availability publication, order import, customer matching, payment, tax, fulfillment, tracking, cancellation, refund, and settlement. For each event, specify direction, latency, data fields, validation, volume, and the business owner. Include how partial shipments, split orders, bundles, marketplace fees, and backorders should behave. If a requirement cannot be described as an observable event and expected result, it is too vague to score against a vendor claim.
Rank requirements as essential, desirable, or optional. A store may need a quick order import but tolerate a slower catalog refresh; another operation may require strict near-real-time availability. Ask the sales, operations, finance, and IT teams to agree on the same requirements. When stakeholders use “integration” to mean different things, product demos can appear successful while critical work remains manual. The resulting workflow map becomes the basis for a proof of concept and acceptance criteria.
Define systems of record and event direction
Every shared field needs a source of truth. Decide whether Acumatica or the commerce platform owns product descriptions, SKU identities, prices, inventory, customer addresses, shipping choices, tax amounts, and payment state. A connector can technically write in both directions, but bidirectional updates without ownership rules can create loops and silent overwrites. Define what happens when an event is delayed or changed after the receiving system has progressed.
The native Acumatica commerce documentation illustrates why direction matters. Its data synchronization process prepares and processes entities, and its Shopify guidance describes dependencies among items, customers, orders, and shipments. These are native-feature examples, not a specification for every third-party app. Review native synchronization concepts. Use them as questions to ask every candidate: What comes first? What is the matching key? What gets retried? What can be changed after an order is created?
Assess fit for native Acumatica commerce integration
Native integration is a strong candidate when the storefront and required entities are supported, the process follows the documented model, and the team wants the setup and troubleshooting experience inside Acumatica. Verify the exact Acumatica release, edition, feature licensing, platform version, and supported entity behavior. Do not assume that a feature described for Shopify applies to WooCommerce, Amazon, or another channel. Where multiple stores are involved, confirm store limits and licensing in the installed version; the Enable/Disable Features reference describes related features, but entitlements can vary by contract.
Walk through native processing screens with the actual operations team. Acumatica’s Sync History shows statuses, errors, and attempts for the Retail Commerce feature. Ask whether that evidence answers the team’s daily triage questions. Test tax, promotions, shipping, partial fulfillment, cancellations, and refunds against your configuration. A native connector that covers the platform but requires substantial manual work for a critical workflow may not be the best overall fit.
Assess a Marketplace or partner app
A Marketplace app can offer a platform-specific or industry-specific workflow, vendor support, and a release path that differs from the native feature. The useful question is not whether the app has a Marketplace listing, but whether the product’s documented scope matches the organization’s operational requirements. Review entity coverage, field mapping, multiple-store support, error handling, replay, monitoring, and the vendor’s version compatibility policy. Ask for a demo with your own exception cases, not only the prepared happy path.
Biz-Tech’s Shopify connector and WooCommerce connector are examples of partner products with specific flow and setup claims. Review the installed version and configuration before treating those claims as production behavior. Read the support terms: who diagnoses an error at the boundary between store, connector, and Acumatica? Who fixes it? Who tests the next Acumatica upgrade? A good app should make those answers easier to obtain.
Assess custom integration
Custom integration can be justified when critical workflows are unsupported, business rules are distinctive, or existing products would require so many workarounds that the combined process becomes fragile. It also requires discovery. The team must design the data contract, authentication, error handling, retry and idempotency rules, monitoring, deployment, testing, and ongoing support. Acumatica offers APIs and import/export mechanisms, but access to an interface does not by itself solve the business semantics. Acumatica’s integration overview outlines available paths.
Specify a support owner before building. Decide how source and target versions will be tracked, how schema changes are detected, how secrets are rotated, and how failures are replayed without duplicate orders. Budget for tests and documentation, not just development. Custom code may be the best choice for a narrow differentiating workflow; it is a poor choice when it merely recreates supported commodity behavior without a clear benefit.
Compare data coverage and mapping depth
Score every candidate against a field-level checklist. For order import, include external ID, customer, address, SKU and variant, quantity, unit of measure, warehouse, price, discount, tax, shipping method, payment status, and notes. For fulfillment, include split shipments, packages, carrier, service, tracking, and partial quantities. For catalog and inventory, include item status, images, price lists, locations, reservations, and backorder policy. Mark each requirement as standard, configurable, custom, manual, or unsupported.
The distinction matters. “Supports orders” may mean only header and line creation, while the business needs gift-card allocation or marketplace commission data. Ask the vendor to show the exact field mapping and an example source payload through to the Acumatica record. Acumatica publishes field-mapping preparation guidance for its native integrations; use that level of specificity as a benchmark for discussions. Review an Acumatica field-mapping reference.
Compare exception handling and observability
Every option should answer five operational questions: How do we know a record failed? What exact record and step failed? Who is alerted? What correction is required? Can it be replayed safely? Ask to see logs and processing screens for a deliberate bad SKU, expired token, invalid address, and failed shipment update. A vendor’s dashboard screenshot is less useful than watching an operator resolve a real case.
Check whether failures are retained long enough for audit, whether automatic retries mask persistent data errors, and whether the connector distinguishes filtered records from failed ones. Document the location of evidence for each integration. If several products are combined, their logs may be separate; a shared case process can coordinate them without implying a single technical queue. Our order-exception guide covers the ownership and recovery questions to ask across multiple storefronts.
Compare security, upgrades, and support ownership
Integration credentials should have the access required for the defined flows, with a documented owner and rotation process. Ask how secrets are stored, what data is retained outside Acumatica, and how access is revoked. Review logging for personal or payment information. For a partner app, confirm the vendor’s support process and compatible Acumatica versions. For custom work, define who runs regression tests against Acumatica and platform updates and who has authority to deploy fixes.
Upgrade readiness belongs in the selection decision. A connector that works today but has an unclear release process creates future risk. Ask for a recent upgrade example: which versions were supported, how long validation took, what changed, and what customers had to do. Acumatica Marketplace listings can identify third-party solutions and validation information, but a listing is not a substitute for a compatibility commitment for your environment. Browse the Acumatica Marketplace.
Build a decision matrix that reflects your business
Use a simple scoring sheet rather than a generic “native versus custom” verdict. Give each requirement a weight based on business impact, then score demonstrated fit, exception handling, operational ownership, upgrade path, time to value, and lifecycle cost. Record evidence next to every score: a document, a configured demo, a proof-of-concept result, or a contract term. Do not award full credit for an untested roadmap promise.
For example, a retailer with standard Shopify order and inventory flows may place the highest weight on supportability and quick deployment. A distributor with complex warehouse allocation and marketplace settlement may weight mapping control and exception recovery more heavily. The same connector can be the right choice for one business and a poor fit for another. A decision matrix makes that tradeoff visible and gives procurement a defensible basis for comparing proposals.
Run a focused proof of concept
Choose a small set of representative records that cover the hardest requirements, not just the easiest sale. Include a standard order, an unmatched SKU, a customer change, tax and discount edge case, partial shipment, cancellation after allocation, refund, inventory change, and a temporary API failure. Capture the expected result before testing. For each candidate, observe the same evidence: records created, fields mapped, status returned, errors surfaced, correction path, and safe replay.
Keep the proof of concept bounded in time and success criteria. A vendor should show what is configuration, what requires development, and what is outside scope. Include a sample upgrade or configuration change if upgrade resilience is a major concern. At the end, list unresolved gaps and their proposed owner and cost. A successful demo is not an acceptance test until the business can operate the failure path.
Calculate lifecycle cost
Add license and implementation cost to the people and processes required after launch. Include mapping changes, new store onboarding, monitoring, exception triage, upgrades, support response, and potential downtime. A lower initial price can be offset by ongoing manual corrections; a custom build can be economical if it replaces extensive recurring work, but only if its maintenance is funded. Compare costs over a realistic horizon, with assumptions written down.
Quantify the operational pain where possible: average exception volume, time to resolve, orders delayed, and finance adjustments. Avoid invented return-on-investment percentages. The decision should rest on measured workload and the proof of concept. Procurement should request a clear scope of included support and change requests so that later invoices do not surprise the operations team.
Plan implementation and acceptance
Once a path is chosen, establish the owner of each field, flow, and exception. Confirm environments, data cleanup, credentials, schedule, training, rollback, and launch monitoring. Test the mappings with representative products, customers, and orders. Reconcile a pilot period between the commerce platform and Acumatica, accounting for known filters and cancellations. Define an acceptance threshold for both successful processing and exception recovery.
Use a staged release when possible. Begin with a controlled store or order subset, then expand after the team can locate and resolve errors. The handoff to operations should include a runbook with screenshots, record IDs, escalation contacts, and the procedure for safe replay. Acceptance is not merely “the connector is installed”; it is proof that the business can run the process.
Common selection mistakes
The most common mistake is selecting by platform logo alone. A connector that supports Shopify may still lack the exact tax, partial shipment, or refund behavior required. Another is treating customization as free flexibility: every special rule needs tests, deployment, and ownership. A third is ignoring failure handling because the sales demo showed only success. Finally, teams sometimes mix two products on the same entity without a clear system of record, leading to duplicate or conflicting updates.
Prevent these problems by asking for field-level evidence, deliberate exception demonstrations, version commitments, and an explicit support boundary. Keep a short list of nonnegotiable outcomes. If a candidate fails one, document the workaround and its cost before moving on. A neutral selection process protects both the buyer and the implementation team from promises that the real operation cannot sustain.
Frequently asked questions
Is native integration always cheaper?
No. License, setup, workflow gaps, support, and ongoing effort determine total cost. Native integration can be efficient when the process fits its supported model. A partner app or focused custom service may be more economical for requirements that otherwise demand manual work.
Does an Acumatica Marketplace listing guarantee compatibility?
A listing is a useful starting point, but verify the product’s supported Acumatica release, platform version, features, and vendor support terms for your environment. Request written compatibility details and test critical flows.
When should we consider custom integration?
Consider it when essential requirements are unsupported or workarounds create unacceptable cost or risk. Complete discovery first and budget for security, monitoring, testing, and upgrades. A narrow custom extension can coexist with a standard connector if ownership is clear.
Can two connectors operate against the same storefront?
They can, but their entity and field ownership must be separated. Two processes writing the same orders or inventory without coordination can create duplicate or conflicting data. Test combined behavior and document the boundary.
What should the proof of concept include?
Use real products and representative orders, including failure cases. Check field mapping, error visibility, correction, replay, partial fulfillment, cancellations, and financial reconciliation. Record expected and observed results for each candidate.
Who should make the selection decision?
An integration architect, Acumatica solution consultant, ecommerce operations lead, finance representative, and procurement lead should contribute. One accountable sponsor should approve the final tradeoffs and support model.
How do we compare support quality?
Ask who owns issues at each boundary, response and resolution expectations, escalation path, release compatibility policy, and examples of recent upgrades. Include those commitments in the agreement where appropriate.
Should every integration be near real time?
No. Set latency based on business risk, volume, platform limits, and processing capacity. Some events need faster updates than others. Test the chosen schedule under realistic load and during bulk catalog changes.
Next step
If you are choosing an Acumatica integration approach, begin with your actual workflows and exception cases. Request an integration fit assessment from Biz-Tech Services to compare native, partner, and custom options against your requirements and ownership model.


