Optimize integration app performance during high-volume periods

This article outlines the best practices and readiness steps for managing e-commerce integrations during high order volumes. It includes a readiness checklist and an action plan to help you prepare before, during, and after the holiday season. You'll find general and advanced best practices that apply across all integrations, along with app-specific recommendations to address high order volumes, prevent bottlenecks, and ensure smooth operations.

Holiday readiness checklist

Review and validate flows

• Audit active flows (orders, billing, fulfillments, returns, and payouts).
• Confirm that active flows do not depend on deprecated APIs, legacy authentication methods, retired product flows, or outdated field mappings.
  • For the Shopify - NetSuite integration app, verify GraphQL refund-flow readiness and replace deprecated transaction fields such as authorization where required.
  • For the Walmart - NetSuite integration app, verify that OAuth-enabled HTTP connections are in place and that product listings use the separate Walmart - NetSuite Product Flow (ItemSpec 5.X) template.
  • Complete migration, authentication, and field-mapping changes before promotional launch windows, not during peak order volume.
• Test field mappings and settings for discounts, gift options, shipping methods, and tax fields.
• Check flow schedules (real-time vs. batch) to match peak demand.
• For global promotions and marketplaces across regions, review schedule and data-transformation time zones. Use UTC schedules where appropriate to keep processing windows consistent through daylight-saving changes.
• Run sample test orders in the staging/sandbox environment, before the rush.
• Validate NetSuite connector compatibility before peak. For flows that use a NetSuite WSDL, confirm that the configured version is supported. If you use NetSuite JDBC, verify that queries use NetSuite2.com, not the deprecated NetSuite.com data source. Test critical order, fulfillment, inventory, payout, and reporting flows after connector, schema, or connection changes.

Monitor API and rate limits

• Review platform API limits.
• Stagger or throttle flow runs to avoid hitting rate limit errors.
• Enable concurrency controls and retry logic in the integration app. (Also, see Monitor and manage retries for details on tracking and managing retry runs.)
• For failed API calls, use the Auto-recover rate limit errors setting under the Advanced section of the connection.
• Keep the NetSuite concurrency recommendation at 15 or less, within the available NetSuite account allocation. A higher Celigo connection ceiling does not increase NetSuite's account-wide concurrency allowance.
• For HTTP 2.0 connections in integration apps, including the Shopify HTTP OAuth 2.0 connection, review concurrency under Advanced. Align the setting with the application's rate limits and the expected order volume; test increases before production use.
• For eligible subscriptions, higher connection concurrency is available: Enterprise accounts and Professional accounts with the applicable add-on can configure a maximum of 50. Use only the capacity that both your subscription and downstream systems support; 50 is a ceiling, not a recommended target for every connection.
• When Auto-recover rate limit errors is enabled, review Target concurrency level and the current concurrency separately. The platform adjusts current concurrency as it recovers from rate limits. Do not treat this as additional marketplace or NetSuite API capacity.

Increase visibility and alerts

• Enable integration flow dashboards for real-time monitoring. For more information, see Monitor and manage your flows within an integration.
• Set up email alerts for flow errors.
• Define alert thresholds for error spikes, throughput drops, or latency.
• Confirm that execution logs are enabled at an appropriate level for critical order, fulfillment, inventory, refund, payout, and custom flows. Check the actual setting rather than assuming that a new-account logging default applies to an existing account.
• Use Run history for historical, in-progress, and retry runs, and Run console for current processing, including in-progress retries.
• In the Errors page, use Trace Key, Error ID, assignees, tags, and search to group and prioritize failures. Use bulk Retry, Resolve, Assign, and Tag actions for the relevant records. Use inline retry-data editing only with the required permissions and after validating the correction; marking an error resolved does not itself reprocess the record.

Data quality and inventory sync

• Confirm real-time inventory sync (ERP - marketplaces) to avoid overselling.
• Ensure consistency of SKU, pricing, and promotions across all systems.
• Validate holiday SKUs and promotional items sync correctly.
• For the Shopify - NetSuite integration app with NetSuite Units of Measure enabled, update the required item receipt and Return Authorization saved-search formulas and validate quantities before peak. See Units of Measure validation.
• For custom flows that use lookup caches, confirm that critical caches are registered, identifiable, and populated with current item, customer, inventory, or order reference data. Use lookup cache aliases so references remain stable across clones, snapshots, and lifecycle-management operations. Refresh or purge stale data only when needed, with a tested repopulation plan, and validate dependent flows after cache or alias changes.

Capacity and scaling prep

• Tune Celigo concurrency and throughput settings for peak traffic.
• For custom flows that gather data from multiple exports, evaluate Export execution mode. Parallel exports can improve throughput within a flow; test the setting before production and confirm that the exports do not depend on sequential execution and that downstream systems can handle the increased processing rate.
• Optimize schedules and review logging overhead. Keep diagnostic evidence needed for support; use detailed connection debugging for a bounded investigation rather than leaving it on for large production runs. See performance and logging guidance.
• If flows use an on-premise agent, verify capacity, uptime monitoring, and version readiness. Test private-network FTP transfers, local file access, and OAuth token exchange through the agent where those capabilities are used. Update the agent to a version that supports private-endpoint OAuth before relying on that authentication path.

Business rule alignment

• Update flows with holiday promotions (gift wrapping, free shipping thresholds).
• Validate tax, duty, and compliance rules for marketplaces.
• Test order, fulfillment, inventory, return, exchange, refund, payout, customer-deposit, and reconciliation flows end to end before peak.
  • For the Shopify - NetSuite integration app, include native returns, even/upsell/downsell exchanges, Return Authorizations, GraphQL refunds, store credit and original-payment refunds, restocking fees, and return-shipping adjustments.
  • For the Payout to Reconciliation Automation for NetSuite app, validate payout matching and transaction-ID mappings before finance-close deadlines.

Support and escalation plan

• Submit a support ticket.
• Document fallback procedures for critical flows.
• Assign on-call coverage with at least one admin for urgent fixes.

Post-holiday planning

• Prepare reports on errors, API usage, and processing times during the peak. For more information, see Investigate errors and Error classifications.
• Review Account > Subscription usage before, during, and after peak. Compare API-call usage and flow, endpoint, and agent consumption with your entitlements. Use run history and execution logs to assess processing volume and duration; subscription endpoint counts are not throughput or latency measurements.
• Test flows for post-holiday returns surge.
• Before closing seasonal operations, validate Shopify - NetSuite integration app Return Authorizations, exchange orders, refunds, restocking fees, return-shipping fees, and store credit outcomes. Review reconciliation results and transaction-ID errors in the Payout to Reconciliation Automation for NetSuite app.
• Compare order, fulfillment, refund, payout, and product-sync error trends before, during, and after peak. Document temporary mapping, schedule, concurrency, and customization changes. Restore normal settings only after the post-holiday return/refund volume and related backlogs have normalized.

• Archive or disable seasonal/holiday-specific flows to prevent future errors.

See also: Best practices to manage errors – part 1 and Best practices to manage errors – part 2.

Customer action plan (before, during, and after peak)

Here's a stage-wise plan with clear responsibilities and timelines.

Apply deferral and disabling recommendations only to flows that your business has classified as non-critical. Preserve order, inventory, shipping, payment-capture, and refund commitments. Record normal schedules before making temporary changes so they can be restored accurately.

Stage-wise action plan

Note: After the holiday season, process any backlogs, reset flow frequencies to normal, and reconcile transactions to ensure data completeness.

General best practices for holiday season (all e-commerce integrations)

General best practices

• Use multiple connections in your integration apps for better throughput.
• Configure connections to optimize throughput and governance:
  • Leverage multiple connections for better throughput
  • Optimize multiple connections to improve throughput
• Configure flow steps to maximize performance and governance:
  • Exports and listeners
  • Imports
• Create a separate integration app tile (and clear naming) per brand/marketplace to simplify troubleshooting and isolate the load.
• Avoid bulk retries for low-priority flows.
• Do not retry old errors in Inventory, Item, or Pricing flows, because the data may be outdated.
• Avoid changing key settings or mappings right before the holiday season.
• For high-volume Marketplace accounts, use distinct NetSuite customer records per marketplace/account to avoid approaching the 10,000-transactions limit on a single customer.

Webhook readiness for custom flows

For custom e-commerce flows that receive order, fulfillment, inventory, payment, shipment, or return events, test webhook handling before peak:

• Confirm that each listener accepts the provider's actual payload format and media type. Use Override media type only when the declared content type does not match the supported payload format.
• Configure Path to records in webhook request body for large, multi-record payloads so records can be split into pages. Use Include parent data when downstream mappings require header-level data in _PARENT.
• Configure the CSV or XML parser when the provider sends those formats, and test the resulting records and mappings.
• Verify HMAC signatures, token location, and challenge-response rules against the provider's requirements. Do not weaken authentication to bypass a failed test.
• Test realistic event volumes, provider retry behavior, and downstream error recovery. Confirm that failed or retried events produce the expected records without duplicate business transactions.

Protect custom-flow changes before peak

For custom integrations that use Integration Lifecycle Management (ILM), save a known-good revision before peak changes and test revisions in a non-production environment before promoting them. Validate lookup cache aliases after cloning, taking snapshots, or merging. For managed integration apps, use the supported settings and upgrade process; do not assume that custom-flow editing or ILM procedures apply to managed assets.

NetSuite performance

For custom record-based NetSuite imports and exports, the API Type > REST APIs option supports SuiteTalk and Custom RESTlets. Before changing an existing flow, validate record operations, mappings, lookups, and any SuiteScript-hook dependencies in a test environment. Compare representative processing times and errors before production rollout; this is not a requirement to migrate every managed integration app. REST APIs is not available for file-type NetSuite imports. See Export data from NetSuite and Import data into NetSuite.

• Concurrency limits: To raise concurrency across NetSuite connections beyond your account limit, contact NetSuite Support. For more information, refer to Govern concurrency of NetSuite connections.
  • Check limits in Setup > Integration > Integration Management > Integration Governance.

• Script logging: Set all Celigo scripts' Log Level = Error.
  • Path: Customization > Scripting > Scripts > locate Celigo scripts (by bundle ID prefix) > open Deployments > set Log Level = Error.
• Optimize scripts and workflows:
  • Go to Customization > Scripting > Scripting Records to identify how many scripts/workflows are deployed on a record.
  • Heavy user event scripts or workflows can slow down record creation. Work with NetSuite Support to optimize or reduce them. (Refer to the typical data provided by NetSuite support.)
• Measure record creation time:
  • Run an on-demand flow to import a single record into NetSuite.
  • Check how long it takes to complete. This helps identify performance bottlenecks.
• Resubmission impact:
  • To avoid order failures due to missing customers, enable the Default NetSuite customer if missing on Shopify order under: Integration app > Settings > Order > Customer subtab.

Shopify - NetSuite integration app

Critical actions for holiday season

• Switch to batch order sync (multiple orders per page) instead of real-time. Set Filter order by to Creation time, with a minimal lag offset.
• Turn off the real-time order flow before you turn on the batch order flow. The two cannot run at the same time.
• Pre-load items before peak; use delta mode; disable Always sync inventory levels for the entire catalog.
• Set NetSuite concurrency to 15 or less within the account's allocation. For additional Shopify throughput, add Shopify OAuth connections to the same store from within the integration app, in the same integrator.io account and region, and see the connection concurrency guidance.
• Disable Shopify to NetSuite customer flow; use the Default NetSuite customer if missing on Shopify order.
• Run refunds/payout reconciliation off-peak; set fulfillment page size 100 to 500 and refund page size 100 to 250.
• Reduce the batch size for high-volume or resource-intensive flows, such as Order and Refund imports, to improve performance and reliability.

Detailed best practices

Concurrency and API limits

• In the Shopify HTTP OAuth 2.0 connection, review the configurable concurrency settings under Advanced and test them against your store's API allowance and NetSuite capacity. The integration app creates the Shopify connection at concurrency 1. Raise it under Advanced after testing.
• For additional Shopify throughput, set up additional Shopify OAuth connections to the same store before peak and verify their authentication and flow compatibility.
• Review Shopify's REST API rate limit for any remaining REST operations and GraphQL API rate limits for GraphQL flows. Query costs and the store's plan govern available GraphQL throughput; increasing connection concurrency does not raise that allowance.

Order sync

• Use real-time flows (cash sale or sales order) when you need up-to-date data, as they process one order per page.
• During peak, switch to batch flows, which process multiple orders per page for better performance.
• Outside peak times, revert to real-time flows for freshness, and run batch flows once or twice a day as needed.
• During peak, set Filter order by to Creation time so that orders updated after creation are not exported again. Outside peak, Last updated time is recommended.
• Set Lag for the next flow run and Sync orders created prior to carefully to avoid missing/duplicate orders.
• Run Sync Shopify order on-demand to NetSuite flow for specific imports.
• Provide default NetSuite SKU/item values to reduce lookup errors.
• Undeploy unnecessary NetSuite scripts if safe.
• For premium users: enable Buy online, pick up in-store only if needed.
• For Shopify Markets: enable Sync records in local currency.
• Map each province to the corresponding non-inventory item for state taxes.

Tax setup

• Configure tax codes properly or use integrator.io tax config.
• Options:
  • Add total tax as a single line item.
  • Overwrite taxes with Shopify amounts + assign default tax code.
• Ensure GST/VAT settings match across Shopify and NetSuite.

Customer sync

• Shopify to NetSuite:
  • Use the Default NetSuite customer if missing on Shopify order.
  • Run customer sync flows before peak to update data.

Important: Do not run Shopify to NetSuite customer flows during the holiday season.

• NetSuite to Shopify:
  • Run sync before peak.
  • Set batch size/concurrency logically.
  • Set the Shopify Store custom field on addresses.
• Avoid scheduling customer syncs in both directions at the same time.

Transaction sync

• Disable Shopify order transaction to NetSuite custom transaction record (add) if not needed.

Inventory sync (NetSuite to Shopify)

• For high-volume flows, consider additional Shopify OAuth connections to the same store.
• Run Shopify product ID to NetSuite item (mass update) before peak.

Item/matrix item sync

Note: The REST flows are no longer supported. You must configure and start using the corresponding GraphQL flows instead.

• Load all items/matrix items before the peak.
• During the season, lower exports to once/day.
• Run bulk/mass updates off-peak.
• For Shopify Markets: confirm markets and price lists are set up.
• Ensure metafields are defined/validated properly.
• Validate the tracked inventory mapping in both NetSuite item to Shopify product (add or update) and NetSuite matrix item to Shopify product (add or update).
• Remove deprecated taxCode mappings where configured, and confirm that explicitly supplied Shopify product handles are unique.
• For updated integrations, verify the dedicated Post metafields to Shopify import. Allow enough runs before launch for all variants' metafields to synchronize: for products with 100 or more variants, variant metafields sync in the run after the product is created.
• Test product publishing and unpublishing on every required Shopify sales channel before promotions begin. Include variant visibility where your installation supports it, and validate the result in Shopify rather than relying only on a successful flow status.

Fulfillment sync

Note: The REST version of the NetSuite to Shopify fulfillment flow is no longer supported. You must configure and start using the corresponding GraphQL flow instead.

• Shopify to NetSuite: schedule off-peak; set export page size 100 to 500.
• NetSuite to Shopify: schedule off-peak with lower frequency.
• For multi-location and buy online, pick up in-store (BOPIS) orders, verify that the assigned location and delivery method sync to NetSuite at line level. Test orders spanning multiple fulfillment locations.
• Validate exports containing multiple tracking numbers and their corresponding tracking URLs, including carriers Shopify does not recognize.
• During peak, review carrier and tracking-export errors before they affect customer notifications.

GraphQL flows considerations (item/matrix item sync and fulfillment sync)

• Shopify GraphQL APIs use cost-based rate limits. Check the current allowance for your store plan and the actual cost of product, metafield, and fulfillment requests.
• If throttling errors occur, reduce Shopify Connection concurrency to stay within rate limits.

Note: Avoid bulk retries on throttling errors. Allow the system to back off or retry later to prevent additional failures.

Units of Measure validation

For the Shopify - NetSuite integration app, when Units of Measure is enabled in NetSuite, update the following saved-search formulas before the next sync:

• Celigo Shopify Item Receipt Lookup Search: Set the Quantity formula to ABS({quantityuom}).
• Celigo Shopify Return Authorization Search: Set the Quantity Fulfilled/Received formula to NVL({quantityshiprecv}, 0) * NVL({quantityuom}, 0) / NULLIF({quantity}, 0).

Test fulfillment, refund, Return Authorization, and item receipt flows afterward. Include partial fulfillment, full return, and refund scenarios; verify transacted quantities, remaining quantities, and per-unit rates. See Support for Shopify Native Exchanges and Returns.

Refund sync

• Shopify to NetSuite: schedule off-peak; set export page size appropriately; ensure GST/VAT settings match.
• NetSuite to Shopify: schedule off-peak; select substitute items for adjustments.

Prepare native returns, exchanges, and GraphQL refunds

Before peak and the post-holiday returns surge, validate these paths in the Shopify - NetSuite integration app:

• Enable and test the GraphQL-based Shopify refund to NetSuite refund (add) flow, and disable its deprecated REST counterpart. The returns flows depend on the GraphQL refund flow.
• For native exchanges, verify Settings > General > Sync native exchanges as separate sales orders or cash sales. Test even, upsell, and downsell exchanges, and confirm that replacement items create the expected separate NetSuite orders.
• Confirm that Shopify returns create the expected NetSuite Return Authorization (RA) records. Test the approval, item receipt, and refund stages; an RA must be Pending Refund for the integration app to create a refund against it.
• Validate restocking fees, return-shipping adjustments, and refunds to store credit or the original payment method. For partial refunds, confirm that the Shopify return is Closed. A refund can use the original payment method or store credit, but cannot be split across the two methods.
• Review and test custom workflows or scripts that depend on legacy REST refund behavior.

See Sync order refunds between Shopify and NetSuite.

Review payment transaction identifiers

For the Shopify - NetSuite integration app, replace deprecated authorization mappings with paymentId where required. The eTail Transaction Id(s) field uses Shopify paymentId.

For stores using Stripe Card Payments with the Payout to Reconciliation Automation for NetSuite app, also validate the order and refund transaction-ID mappings described in Payout and marketplace tax readiness. These mappings are configured in the Shopify - NetSuite order and refund flows. Test scheduled and real-time processing and trace a payment from its order through its deposit, refund, and payout.

Validate GraphQL billing and payment capture

If the Shopify - NetSuite integration app captures payments from NetSuite, test the GraphQL-based NetSuite billing to Shopify billing (add) flow before peak. Under Flows > Billing, disable [Deprecated] NetSuite billing to Shopify billing (add) before enabling the new flow. Verify Settings > Billing > Capture order payments in and test representative captures. Do not enable both billing flows simultaneously, because duplicate payment processing can result. See Configure the GraphQL billing flow.

Shopify payout reconciliation add-on

Before moving to Shopify payout to NetSuite payout and deposit, manually configure Settings > Payout > Business entity transaction type to account mapping for every business entity that processes payouts, including the primary entity. Map Charge, Refund, Adjustment, and Variance (catch-all), plus applicable additional transaction types. Values from the deprecated account settings are not copied automatically.

Test payout custom records, deposits, variance transactions, and GL-account postings before moving the production schedule and disabling the two deprecated payout flows. Review variances even when a deposit is created successfully. See Configure the GraphQL payout flow and Payout and marketplace tax readiness.

• Avoid large lag offsets in payout flows.
• Review the Different store and payout currency settings.
• Run payout-to-deposit flows the day after order sync to avoid accumulating open deposits.
• Set the Duration to reconcile transactions setting to limit the retrieval of older transactions and prevent over-fetching, which can slow down flow runs.
• Adjust flow schedules/offsets to avoid exceeding NetSuite's 10,000 transaction limit.

Important: Do not run reconciliation during peak; sync payouts after load reduces.

Optimize performance by configuring mappings (applicable for fulfillment and refund flows)

The recommended mappings unlock Celigo's optimized import process for fulfillments and refunds, allowing the integration app to process high volumes more efficiently during peak.

For setting up these mappings, see Optimize performance by configuring fulfillment mappings and Optimize performance by configuring refund mappings.

Amazon - NetSuite integration app

Connection concurrency

• Do not schedule flows for multiple domains in the same region at the same time.
• Amazon shares the request quota only across domains in the EU region.
• In multi-brand setups, consider assigning available Celigo concurrency to a single parent connection and scheduling flows across apps from that connection to coordinate throughput.

Important: Do not schedule flows across multiple domains simultaneously (e.g., Spain + Italy in the EU marketplace).

Order sync (Amazon to NetSuite)

• Set recommended filters for delta mode:
  • Filter orders by: Last Modified Time
  • Duration in days: empty
  • Go Live Date: empty
• Always check the Dashboard for errors to resolve and retry.
• Check the rate and burst limits for the Amazon SP-API operations used by your order and feed flows, and enable supported automatic recovery. Do not apply a single historical ListOrders or feed-request quota to every operation. See Amazon SP-API rate-limit guidance.
• Use Allocate FBA orders to below NetSuite customer(s) setting (Settings > Order (FBA) > Customers). For more information, see Configure Amazon FBA order flow settings.

Tax setup

• Configure tax codes in NetSuite or use integrator.io tax config.
• Options:
  • Add total tax as a single line item, OR
  • Overwrite with Amazon tax amounts.
• Enable GST/VAT:
  • Enter GST/VAT rate to apply across all orders to enter a fixed rate.
  • Apply GST/VAT rate reported by Amazon to apply the reported rate.
• Use Exclude Tax if Marketplace Tax Collection applies to avoid duplication when Amazon remits taxes.

Fulfillment sync (NetSuite to Amazon)

• Amazon validates tracking IDs. Invalid IDs lower your account's valid tracking rate. Always use correct IDs.
• Schedule NetSuite Fulfillment to Amazon Shipment Add with:
  • Batch size 200
  • Page size 100 (lower than the default of 2000)

Important: Validate the current feed-operation request and payload limits before scheduling high-volume fulfillment exports. Keep Celigo page-size limits separate from the endpoint's request limits.

• Enable Automate shipment carrier mapping (Settings > Fulfillment).

Inventory sync (NetSuite to Amazon)

• Run flows in delta mode, less frequently (e.g., once every 2 hours).
• Kit Inventory sync always exports its full saved search, so run it less often or narrow the saved search.
• Run inventory/product syncs in delta mode with reduced frequency (avoid full catalog syncs).

Product sync (NetSuite to Amazon)

• Load items before peak.
• Run bulk/mass updates off-peak, in batches.
• During season: reduce item sync frequency to once/day.
• When using item aliases, do not select Active for all Amazon accounts if the same item exists across multiple marketplaces to avoid alias conflicts.
• Run inventory/product syncs in delta mode with reduced frequency (avoid full catalog syncs).
• Use only the pricing and inventory flows to update pricing and quantity. Disable the Product flow during peak seasons if there are no product updates to reduce unnecessary processing.

Pricing sync (NetSuite to Amazon)

• Run at low frequency; avoid enabling during peak.
• If needed during peak: schedule once/hour with minimal mappings.

Auto-billing sync

• Run NetSuite Order to NetSuite Invoice Add and NetSuite Order to NetSuite CashSale Add only after the holiday season.

Settlement sync

• Run pricing and settlement flows sparingly or after peak; use secondary connections.
• For the Amazon Seller Central - NetSuite integration app on Amazon Ireland, confirm marketplace configuration, store IDs, and settlement schedules. Run a scheduled settlement test before transaction volumes increase.

Amazon Transfer Order: inbound shipments

• Update inventory levels well before sale periods.
• For the Amazon Seller Central - NetSuite integration app, test NetSuite Packing Information to Amazon Inbound Shipment Plan before replenishment volume rises. Confirm that Confirm Packing Options completes automatically before packing information is posted, rather than depending on manual confirmation in Seller Central.

Amazon FBA add-ons (FBA return management and FBA Inventory Adjustments)

• Run only once or twice/day.
• Configure secondary connections.

Important: These share throttling limits; schedule them so they do not overlap.

Walmart - NetSuite integration app

Connection and product flow readiness

• Verify that order, fulfillment, inventory, and pricing flows use OAuth-enabled HTTP connections and that the replacement flows are enabled, including Walmart (WFS) order to NetSuite order (add). Test authentication and representative transactions before peak.
• For product listings, use the Walmart - NetSuite Product Flow (ItemSpec 5.X) template instead of the retired ItemSpec 4.x product flows. This replacement is delivered separately from the managed integration app.
• Complete the one-time migration, review the product-type mappings, create required NetSuite product-type records, and test product add/update syncs before large seasonal catalog uploads.
• During peak, monitor OAuth connection health, and monitor product listing errors in the Walmart - NetSuite Product Flow (ItemSpec 5.X) template. Complete migration and authentication changes outside promotional launch windows.

eBay - NetSuite integration app

Order sync (eBay to NetSuite)

• Use Last Modified Time as the filter so the flow works in delta mode.
• Leave Duration in days and Go Live Date blank (for accounts already live).

Tax setup

• Configure tax codes/components in NetSuite or use integrator.io tax config (Settings > General > Tax).
• Options:
  • Add total tax against a single line item, OR
  • Overwrite with eBay tax amounts (assign the default tax code to all orders).
• Enable Exclude Tax if Marketplace Tax Collection applies to prevent duplication when eBay collects/remits tax.

Inventory sync (NetSuite to eBay)

• During peak, uncheck Sync all ended listings with NetSuite for better performance.
• For matrix item inventory, set concurrency = 1 during sync, then reset to normal.
• Disable eBay Item Id to NetSuite Mass Update after IDs are synced.

Item and pricing sync (NetSuite to eBay)

• Sync prices and item updates before holiday season.
• If required during peak, run with low frequency to reduce load.

Magento 2 - NetSuite integration app

• Keep the Magento 2 instance optimized, cached, and compiled for better API performance.
• Pre-load items and images before holiday season to reduce processing overhead.
• Lower the item export frequency to once per day during peak periods.

Store setup

• Verify active Magento 2 stores under Settings > General > General tab.
• If new store views are added and records do not sync, deselect an existing store in the Select active Magento 2 stores setting, save, and then reselect all required stores.

Order sync

• Keep the Magento 2 environment optimized (compiled, cached, indexed) to improve API response performance during order imports and item/inventory exports.

Customer identity and compatibility checks

• For the Magento 2 - NetSuite integration app, confirm that the installed extension and Adobe Commerce environment are compatible before peak.
• If customer email addresses change in NetSuite, test the customer export and verify that it updates the existing Magento customer rather than creating a duplicate. The updated matching uses Magento Customer ID (NetSuite field: eTail Customer Id, ID custentity_celigo_etail_cust_id) with website ID; when the Magento ID is unavailable, the email-and-website lookup remains the fallback.
• During peak, review failed customer exports and identity or website-ID matching issues daily.

Tax setup

• Validate tax setup across both NetSuite and Magento.
• Configure tax codes properly in NetSuite or use integrator.io tax configuration (Settings > General > Tax).
• In How would you like to bring sales tax into NetSuite?, select one of these options:
  • Overwrite taxes with Magento 2 tax amounts
  • NetSuite calculate taxes using its own tax engine
  • Add total tax against a single line item on the order
• To apply the default tax code to every order, select the Assign the default tax code to all orders checkbox.
• Using a proper tax setup reduces variances and prevents unnecessary API calls.

Item and image sync (NetSuite to Magento 2)

• Pre-load all items and images before the holiday season.
• During peak: lower item export frequency to once/day.

Important: Item exports are resource-intensive; schedule heavy item updates during off-peak hours if necessary.

Square - NetSuite integration app

• Set NetSuite connection concurrency to 2 to 3 to free capacity for other integration apps.

Orders

• The app is POS-based, so order data syncs as usual.
• Consider scheduling the Square Order to NetSuite Cash Sale flow at a higher frequency to maintain throughput.
• Disable Square to NetSuite customer sync. Instead, select Add all orders against the default NetSuite customer and set Default NetSuite customer if missing on Square order (Settings > Order > Customer).

Important: Cash sales created against the default customer are not reassigned if you turn customer sync back on.

Tenders

• Avoid syncing tenders unless required for refunds.
• Enable the Square Tenders to NetSuite Payments flow only if you must sync gift card or cash sale refunds.

POS setup

• Ensure all Square POS locations are correctly configured and selected in Select active Square locations (Settings > General > General tab).
• Schedule the Square Refund to NetSuite Cash Refund flow at a lower frequency (1 to 2 times per day) throughout the holiday season.

Product modifiers

• In Settings > Order > Order, set Sync Square product modifier price to NetSuite as and NetSuite item to track product modifier price as a line item to avoid mismatches or variances.

Important: If unmapped, modifiers may cause unwanted variances in orders. On the NetSuite cash sale, the modifier name appears in the description field only if you add the item description mapping in the Square Order to NetSuite Cash Sale flow.

BigCommerce - NetSuite integration app

• Pre-sync products and inventory before peak to avoid large data runs during the season.
• Use delta mode for inventory flows.
• Schedule the fulfillment flow at a higher frequency (every 15 minutes) to keep order statuses updated without causing bottlenecks.
• Avoid running the following flows during the season:
  • BigCommerce Customer to NetSuite Customer Add/Update
  • NetSuite Item to BigCommerce Product Add/Update
  • NetSuite Item Image to BigCommerce Product Image Add/Update/Delete
• Run refunds and cancellation flows at a low frequency during off-peak hours:
  • NetSuite Cancellation to BigCommerce Cancellation Add
  • NetSuite Refund to BigCommerce Refund Add

Payout to Reconciliation Automation for NetSuite

Payout and marketplace tax readiness

Before peak, test order, refund, payout, and reconciliation flows end to end. Verify transaction references and GL postings, and review payout errors daily during peak rather than waiting until month-end.

• Shopify - NetSuite integration app: Keep marketplace-collected and remitted tax separate from ordinary payout variances. For legacy payout flows, select a dedicated NetSuite G/L account under Settings > Payout > NetSuite account to track Marketplace sales tax. For the consolidated GraphQL payout flow, configure the applicable tax transaction types in Business entity transaction type to account mapping for each business entity; do not assume the deprecated tax-account setting transfers automatically. See Configure the GraphQL payout flow.
• Payout to Reconciliation Automation for NetSuite app, for Shopify orders paid through Stripe Card Payments, using the Stripe gateway: In the Shopify - NetSuite integration app order and refund imports, validate eTail Transaction Id(s) mappings that use receipt.payment_id for Stripe Card Payments, with the documented authorization fallback. Test both scheduled and real-time order/refund flows. This mapping update does not apply to on-demand flows. Confirm that orders, refunds, deposits, and Stripe payout transactions can be matched end to end.

Payout operating checks

• Pre-holiday preparation: Clear all open transactions before the holiday season so you start peak operations below NetSuite's transaction threshold.
• Schedule payout flows at regular intervals to keep transaction volumes below NetSuite's 10,000 transaction limit.
• For PayPal payout flows with multi-currency, ensure the PayPal primary currency code is set correctly to prevent variances.
• Validate account settings before the holiday season to prevent setup errors.
• Always set minimal lag offsets to improve payout flow performance and avoid overlapping or missed transactions.
• Ensure all order and refund transactions are synced with undeposited funds accounts and carry the correct transaction IDs.
• Confirm that the bank deposit account and other GL accounts are aligned with the same subsidiary and currency.

Troubleshoot during peak

If you run into errors during the peak period, monitor your dashboards closely, adjust batch sizes if needed, and verify recent configuration or connection changes before escalating.

Related articles

• Optimize your integration app flows for throughput
• Schedule your integration app flows
• Consolidate integration errors in a single report