T
TkTurners Team
Implementation partner
canonical: "https://www.tkturners.com/blog/out-of-stock-without-erp-trigger-cross-system-symptom-map" schema: "BlogPosting"
Out-of-Stock Without ERP Trigger: Cross-System Symptom Map
TL;DR: If your storefront or marketplace shows a product as out of stock but your ERP has no record of the event, you're looking at a cross-system handoff failure. The symptom pattern — which channel shows the gap, what the middleware logs say, and whether the ERP webhook fired — points directly to the failing layer.
You pull up your Amazon seller dashboard and a SKU is suppressed. You check your Shopify admin. Same product, same quantity — zero. You check your ERP. It shows 80 units on hand, no transaction, no event log, nothing. Your team is looking at a gap between what the channels are reporting and what the ERP knows — and the ERP being silent is the most important symptom in the room.
In a multi-channel retail stack, inventory state lives in at least three places simultaneously: the storefront, the marketplace feeds, and the ERP. When the handoff chain between them breaks, each system reflects the gap differently — and each system's version of the truth is a diagnostic clue. This guide maps the symptom patterns — what you see in each system, what it means, and which handoff layer it points to — so you can triangulate the failure without a ticket-first approach.
Product Listings Going Out of Stock Without an ERP Trigger
When an out-of-stock event fails to trigger the ERP, the symptom pattern across storefront, marketplace, middleware, and ERP is not random — it follows a predictable map. The first step is reading that map correctly.
| System | Symptom | What the Symptom Tells You | |---|---|---| | Storefront (Shopify, WooCommerce, etc.) | Product shows quantity 0 or "out of stock" in admin | Inventory event fired locally — check if it was forwarded downstream | | Marketplace (Amazon, Walmart, eBay) | Listing suppressed or hidden — no active offer | Feed received the zero-quantity event — check if ERP received it too | | Middleware (Celigo, Patchworks, Boomi, etc.) | Connector shows "active" but no outbound event in logs for the SKU | Event either never reached middleware or was filtered before forwarding | | ERP (NetSuite, Business Central, SAP) | No inventory transaction, no webhook receipt, no exception flag | Handoff chain broke before this layer — ERP silence is downstream, not the root cause |
Key observation: The ERP being the last to know — or not knowing at all — is the defining symptom of a handoff failure. The ERP's silence is an output of the problem, not the location of it.
This reframing changes how teams approach the problem. The instinct is to start inside the ERP and work outward. The symptom map tells you to start at the storefront and work backward.
Symptom Pattern 1: Storefront Out of Stock, ERP Shows Stock — Middleware Is the Suspect
When the storefront shows zero but the ERP still shows inventory, the handoff failure most likely occurred in the middleware connector or in the ERP webhook listener. The storefront did its job — the question is whether anything received and forwarded the signal.
The storefront registered the out-of-stock event. The ERP did not. That narrows the failure to the bridge between them.
If your middleware logs show the event was received and forwarded, the failure is in the ERP webhook configuration. If your middleware logs show no event received for that SKU, the failure is in the storefront-to-middleware handoff — and the ERP never had a chance to see it.
In Shopify NetSuite inventory sync troubleshooting scenarios — which we break down in depth in our Shopify NetSuite integration guide — this pattern shows up consistently: the middleware connector or the ERP webhook listener is where the chain breaks, not the ERP itself (Shopify inventory webhook docs, NetSuite webhook configuration)[^1].
[^1]: Shopify fires inventory update webhooks per individual inventory level change. Bulk imports and CSV-based inventory updates may apply changes without triggering per-item webhook events — see Shopify's inventory level API documentation.
Which systems to check:
- Storefront inventory event logs
- Middleware integration logs for the SKU and event window
- ERP webhook delivery status (if available)
- Middleware connector flow status (active/suspended)
Symptom Pattern 2: One Marketplace Suppressed, Others Fine — Channel-Level Feed Problem
If one marketplace shows a listing suppressed but others are active and the ERP is fine, the issue is isolated to that marketplace's feed configuration — not a system-wide handoff failure.
Amazon suppressed the listing but Walmart and your direct storefront are fine — this means the central inventory state is intact. The suppression is a feed-layer issue.
Common feed-layer causes: a repricer tool overriding the marketplace listing, a buybox algorithm suppressing at Qty 0 when the marketplace buffer requires Qty 1 minimum, or a feed rule set to "suppress on any zero quantity" regardless of actual intent.
Which systems to check:
- Specific marketplace listing feed settings and buffer rules
- Third-party repricer or dynamic pricing tool configuration
- Marketplace's inventory update feed timestamp vs. storefront timestamp
- Marketplace's minimum advertised quantity threshold
Symptom Pattern 3: All Channels Out, ERP Still Shows Stock — The Silent Block at the First Handoff
If every channel is suppressed and the ERP shows no awareness, the out-of-stock event originated at the storefront but never propagated through any channel — meaning the feed from the storefront to the middleware, or from the middleware to the ERP, broke at the first handoff.
This is one of the quieter ways an ecommerce platform out of stock ERP sync failure gets started. No error gets raised. The event simply disappears.
Two common causes show up in our integration post-mortems. First, the storefront may have had a local inventory event that did not fire an outbound webhook — possible if the inventory update was applied via bulk edit, import, or a workflow rather than a point-of-sale or order receipt transaction[^shopify-webhook]. Second, the middleware received the event but filtered it before forwarding — common when a connector applies a minimum delta rule (for example, only forwarding if quantity changed by 10 or more units).
[^shopify-webhook]: Per Shopify's API behavior, bulk inventory operations and CSV imports do not fire per-item inventory webhooks. See Shopify inventory level API for the event model.
Which systems to check:
- Storefront's outbound webhook configuration for the specific inventory event type
- Middleware connector's event filtering rules and minimum delta threshold
- Bulk edit or import logs in the storefront for the affected SKU
- Middleware connector flow status and recent configuration changes
Symptom Pattern 4: Storefront Correct, All Channels Zero — ERP Is the Likely Culprit
This is the clearest symptom of an ERP-side handoff failure. The upstream systems are in sync — the storefront has the correct quantity. The downstream channels are suppressed because the ERP's outbound inventory update to the channels was never sent.
The ERP is the source of truth for outbound channel inventory feeds in many omnichannel stacks. If the ERP never processed an outbound update for this SKU, all channels that depend on the ERP feed will show stale or suppressed data.
ERP-side causes include a workflow holding the outbound inventory transaction for manual approval, an item record configured as non-inventory (so no outbound transactions fire), or an integration user credential that expired and silently blocked outbound webhooks.
Which systems to check:
- ERP outbound inventory workflow status (any holds or approvals pending?)
- ERP item record configuration for this SKU — inventory item vs. non-inventory item
- ERP integration user credentials and recent password resets
- ERP outbound webhook or EDI feed configuration for each affected channel
Symptom Pattern 5: ERP Has Transaction, Marketplace Still Suppressed — The Return Path Is Broken
Sometimes the ERP correctly receives and processes an inbound order that reduces inventory, but the outbound inventory update back to the marketplace never fires. This is a bidirectional handoff failure — the inbound path worked, the outbound path did not.
The order came in, the ERP decremented stock, and the storefront is correct. But the marketplace never received the updated quantity because the ERP-to-marketplace feed configuration is separate from the storefront-to-ERP inbound path.
This is common when the ERP has a separate outbound inventory feed to each marketplace that is configured independently of the inbound order ingestion flow. Most operators don't discover this until they already have a suppression problem on their hands.
Which systems to check:
- ERP outbound inventory feed configuration for the specific marketplace
- Marketplace's last inventory update timestamp vs. ERP transaction timestamp
- ERP's channel-level inventory push rules (some ERPs push per-item, not per-transaction)
First Steps Before You Call IT: The Symptom Documentation Protocol
Before opening a ticket, document the symptom pattern across all four layers. For more on building cross-system diagnostic habits, see our retail operations troubleshooting framework. The operators who get the fastest resolution are the ones who show up with a cross-system symptom log — not just a screenshot of the storefront.
In our work with omnichannel retail teams, the single most useful pre-ticket habit we've found is screenshot timestamps across all four systems on the same day and same time. The chronological alignment of those timestamps — or the absence of one — cuts diagnostic time significantly.
Gather and document the following before escalating:
- SKU and product name
- Which channels show out of stock and which show stock — screenshot timestamps for each
- Storefront last inventory update timestamp for the affected SKU
- ERP last inventory transaction or webhook receipt for this SKU (or confirm none exists)
- Middleware connector flow status at the time of the out-of-stock event
- Any recent configuration changes in the past 72 hours across storefront, middleware, or ERP integrations
If your symptom pattern maps to an ERP configuration gap or a broken middleware connector, that's exactly the scope our Integration Foundation Sprint is designed to close. Book a 30-minute diagnostic call and bring this symptom map.
Frequently Asked Questions
Why does my ERP show no record of an out-of-stock event when the storefront clearly shows the product is out of stock?
The ERP not receiving the event is a symptom of the handoff chain breaking somewhere upstream — most likely in the middleware connector or the storefront's outbound webhook configuration. The ERP's silence is downstream from the actual failure. Work backward: check middleware logs first, then storefront webhook logs, then ERP webhook configuration.
How do I know if the middleware connector is the problem and not the ERP?
Check the middleware logs for the SKU in the event window. If logs show the event was received and forwarded, the connector worked — the failure is in the ERP webhook. If logs show no event received, the connector never had the data to forward — the failure is in the storefront-to-middleware handoff. If logs show the event was received but not forwarded, the connector's filter rules or flow status is the culprit.
One marketplace is suppressed but the others are fine — is this an integration problem or a marketplace problem?
This is almost always a marketplace feed configuration problem, not a system-wide integration failure. Check that marketplace's specific inventory buffer settings, any repricer or dynamic pricing tool connected to that channel, and the minimum quantity threshold the marketplace applies before publishing a listing. The other channels being fine confirms the central inventory state is correct.
What does it mean when the ERP shows a transaction but the marketplace is still suppressed?
The inbound handoff from storefront to ERP worked. The outbound handoff from ERP to marketplace did not. The ERP's outbound inventory feed to that marketplace needs to be checked independently — the inbound and outbound paths are often configured separately in omnichannel stacks.
What is the most common root cause when all channels are out of stock but the ERP still shows inventory?
Two causes come up most often in our integration post-mortems. First: a bulk inventory edit or import in the storefront that bypassed the normal outbound webhook trigger. Second: a middleware connector filter rule that requires a minimum quantity delta before forwarding an event. Less common but worth checking: an ERP outbound inventory push configured as a scheduled batch rather than event-driven, which creates a lag between what the storefront shows and what the ERP has pushed to channels.
Conclusion
The ERP's silence is the last symptom of a handoff failure, not the first cause. Always check upstream first — the middleware logs and storefront event history will tell you more in the first five minutes than opening a ticket and waiting for someone to look inside the ERP.
Cross-system symptom patterns are diagnostic. Which channels show the gap, and in what order, tells you exactly which handoff layer failed. The four-layer symptom map — storefront, marketplace, middleware, ERP — is a repeatable framework any ops team can use before escalating.
Document the symptom pattern across all four layers before you call anyone. Screenshot timestamps, pull the middleware event log for that SKU, confirm whether the ERP received anything. Operators who bring this data to the diagnostic call consistently get faster answers.
Bidirectional handoffs are often configured separately. A working inbound path — where orders flow into the ERP correctly — does not guarantee a working outbound path, where inventory updates flow back out to channels. Treat them as independent integration flows and test both.
Explore more operational troubleshooting frameworks and integration diagnostics on our retail operations blog, or learn more about how the Integration Foundation Sprint closes cross-system handoff gaps for omnichannel retail systems.
