Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ECC direct to Google: what it replaces

Converting ECC’s own data straight into Google Merchant Center’s shape takes S/4HANA off the path to Google. It does not replace the S/4HANA upgrade, and it does not replace consent data. It makes the consent layer more important, not less.

What it removes

  • S/4HANA as a prerequisite for Google commerce. Merchant Center doesn’t care which ERP the data came from. MARA, MAKT, MARM, A004, KONP and MARD already hold title, GTIN, price, units and stock, and the Google Merchant Center page maps them attribute by attribute. Listing products on Google doesn’t wait for S/4HANA or need SAP’s commerce add-ons.
  • Commerce from the upgrade’s scope. If feeds to Google were one of the reasons to upgrade, that reason goes away, and the upgrade can be planned on its own schedule.

What it doesn’t remove

  • The S/4HANA upgrade. That is driven by the end of ECC support (standard maintenance ends at the end of 2027, paid extended maintenance runs to 2030), and by finance, tax and security patches. A product feed changes none of that. What it does is decouple the two: when ECC is replaced, only the feed’s source changes. The Merchant API shape, the offer IDs and Google’s product history stay the same.
  • Consent data. ECC has no consent model. It has flags such as ZZ_MKT_OPTIN and tables such as /ACME/CONSENT, with no time, purpose, source, evidence or withdrawal. Consent gaps lists each missing piece. S/4HANA doesn’t add one either: SAP’s answer is a separately licensed product. Here the CRM Sync gap fill and the Xano consent log fill that gap.

A product feed needs no consent: it is catalog data, with no personal data in it. Once the same pipe carries customer data (KNA1 and ADR6 for Customer Match, enhanced conversions, remarketing), a direct ECC → Google link would skip consent entirely. So the two flows are kept apart:

Products:  ECC export ─▶ converter (src/merchant.rs) ─▶ Xano merchant_product ─▶ Merchant API productInputs
People:    ECC export ─▶ Xano user table ─▶ release gate ─▶ Google (Customer Match, enhanced conversions)

Nothing about a person reaches Google without passing the release gate. ECC’s opt-in flags are inputs to the gate’s evidence, never the decision.

What a direct path still has to handle

IssueWhyWhere it is handled
FreshnessECC exports in batches. If the price or stock in the feed doesn’t match the product page, Google disapproves the offer.A refresh window per attribute; versionNumber on each insert so an older batch can’t overwrite a newer one.
A page to buy onMerchant Center needs a product page that can check out, or an agentic checkout. ECC has neither.The storefront, not the ERP.
Prior priceA sale price in the EU must show the lowest price of the previous 30 days (Omnibus), per market.Price history per market, kept outside ECC’s condition records.

When markets multiply: the domain is not the key

A direct path works for one market. The second market is where it breaks, and almost never because of ECC. It breaks when something downstream uses the storefront domain, a URL or a product handle as an identity key. A domain is a routing and presentation attribute. Identity lives in keys that don’t change when a market launches: the *.myshopify.com shop handle, the Shopify GID, MATNR and the GTIN.

The TLD, URL and channel side of this (ccTLD vs subfolder, hreflang, Merchant feed labels, Meta and Amazon) is covered in the TLD & Namespace Strategy book. This section covers what that book doesn’t: the ECC-to-Shopify gaps, and the revenue and WMS risk they carry.

One registry row per market

The market is looked up from a registry, never inferred from the host. Every URL is computed from the row plus an immutable key; no system stores a URL as a key.

{
  "market": "GB",
  "host": "brand.com", "pathPrefix": "/en-gb",
  "contentLanguage": "en", "feedLabel": "GB", "currency": "GBP",
  "shop": "brand-us.myshopify.com",
  "sap": { "vkorg": "2000", "vtweg": "10", "spart": "00" },
  "consentJurisdiction": "UK-GDPR",
  "live": false
}

live is the launch gate. It flips only when the checks in the risk register below pass.

ECC ↔ Shopify gaps

A gap is a place where ECC and Shopify name the same thing differently, at a different grain, or not at all.

GapECCShopifyWhat breaks when a market is addedFix
G1 Market ≠ sales areaSales area: VKORG + VTWEG + SPARTMarketMiddleware infers the sales area from the domain and posts a new market’s orders to the wrong sales orgRegistry maps market → sales area explicitly
G2 GrainMATNR (CHAR 18 in ECC) = one variantProduct groups variantsA second store or a translation plugin forks the grouping, and itemGroupId splitsKey on MATNR ↔ variant GID ↔ SKU; the PIM owns the grouping key
G3 One GTIN vs manyMARM-EAN11 per unit (each, case, pallet)One barcode per variantA case GTIN reaches Google, or an each GTIN reaches the WMSEach consumer reads its own unit (below)
G4 Price authorityA004/KONP per sales area, usually netMarket price list, often tax-inclusiveA market goes live before its conditions exist and falls back to a default or FX pricelive stays false until condition records exist
G5 Location grainPlant + storage location (T001W, MARD), WM warehouseLocation GIDInventory pushes keyed by location name break when a node is addedVersioned WERKS/LGORT ↔ location GID table
G6 Order identityVBAK-VBELN; customer PO in VBAK-BSTKDOrder GID; name #1001 repeats across storesBSTKD deduped on the order name collides across stores; webhook retries duplicate ordersBSTKD = {shop}:{order GID}, deduped with the webhook ID
G7 Customer and consentKNA1, one-time (CPD) accounts; no consent modelCustomer GID, marketing consentA new origin starts with empty consent and ECC never sees itConsent keyed on customer GID + jurisdiction, in the release gate, never ECC
G8 Localized textMAKT per SPRASTranslations and localized handlesAny join on handle breaks per languageHandles are output only; joins use GID or MATNR
G9 URL constructionNone: ECC has no URLPrimary + market domainsThe feed’s link is built in middleware with brand.com hardcodedOne url(market, gid) builder for every feed and the edge Worker

ECC has no concept of a URL. Every URL in an ECC-sourced feed was built by middleware, which is exactly where a hardcoded host ends up.

G3 in this repo

merchant::convert already reads the base unit’s MARM row (MEINH == MARA-MEINS) and validates it with merchant::gtin, so the Merchant feed gets the each-unit GTIN. A WMS or EDI feed must read the case row instead. Keying the GTINs by unit makes that choice explicit:

#![allow(unused)]
fn main() {
use std::collections::BTreeMap;

/// MARM-MEINH values the integration reads.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Uom { Ea, Cs, Pl }

pub struct Gtins(BTreeMap<Uom, String>);

impl Gtins {
    /// Google and the storefront: the unit a shopper buys.
    pub fn consumer(&self) -> Option<&str> { self.0.get(&Uom::Ea).map(String::as_str) }
    /// The WMS and EDI: the unit that is picked and shipped.
    pub fn case(&self) -> Option<&str> { self.0.get(&Uom::Cs).map(String::as_str) }
}
}

Every value goes through merchant::gtin before it enters the map, so a bad check digit, an in-store number (NUMTP IE) or a restricted prefix never reaches either consumer.

Worked example: launching the UK

The fragile way: a translation plugin publishes uk.brand.com. The feed builds brand.com/products/ + handle, and UK handles 404 (G8, G9). A UK order maps to VKORG 1000 because no 2000 mapping exists (G1, G4). The WMS gets the case GTIN where it expects the each GTIN (G3). Consent captured on the new origin never reaches the customer record (G7).

The safe way: add a GB row (VKORG 2000, GBP, /en-gb subfolder through Shopify Markets, live: false). Put the plugin in subdirectory mode. Gate live on A004/KONP for VKORG 2000. None of the failures above can happen, because none of them read the host.

Market prices and FX: one price, read everywhere

A market price can come from three places, and a fixed price wins over everything else. Google then checks that price against the landing page from anywhere in the world. So every market advertised with a local-currency feed needs a deterministic price.

How Shopify derives a market price

LayerWhat it doesNote
Automatic conversionA dynamic rate Shopify updates to real-time rates, or a manual fixed rateAt checkout, automatic conversion uses Shopify’s rates, plus its conversion fee where that applies
Adjustment and roundingA price list adds a percentage on top of FX, then roundsShopify’s example: $20 × 1.3 FX × 1.2 (+20%) = $31.20, rounded to $31.99 by a 0.99 rule. Rounding uses Shopify’s per-currency defaults and can’t be customized
Fixed priceA price-list price already in the target currencyApplies regardless of FX and rounding

What Google requires

OptionHow it worksTrade-off
Local-currency feedSubmit GBP prices for the UKThe feed currency must match the landing page, for every viewer, wherever Google crawls from
Google’s currency conversionOne base-currency feed with extra countries; Google shows its converted price next to yoursFeed, page and checkout must still agree in your currency. Google uses Google Finance rates, and this usually earns fewer eligible impressions than a dedicated feed

If the numbers drift, Merchant Center may update the product’s price to what it finds on the landing page, or disapprove the item.

Where FX breaks the match

  • Dynamic rates drift daily. A feed generated at yesterday’s rate disagrees with today’s page. A market on dynamic FX needs its feed resynced at least as often as the rate changes.
  • IP-based currency switching. The most common failure. Google checks the page from any location, while Shopify Markets switches the page currency by visitor IP, so a local-currency feed is rejected. The fix is a market URL (/en-gb) in the feed link, so the URL sets the currency, not geolocation. This is G9 again.
  • Tax display. Location-based VAT settings in EU and UK stores show the crawler a net or gross price depending on where it seems to come from.
  • Structured data and shipping. JSON-LD offers.price must match the feed and page for every product ID, and shipping rates must use the feed’s currency for each country.

The ECC angle: three rate sources

Rate sourceDrives
ECC exchange rates (TCURR)Invoicing and financial postings
Shopify market FXStorefront and checkout
Google FinanceGoogle’s converted ad price

Each gives a slightly different number, so G4 covers rate authority as well as price authority. (TCURR holds the rates; TCURX, which merchant::to_money already reads, holds only the currency’s decimals.)

Recommended pattern

  1. Fixed price lists for every market advertised with a local-currency feed. Source them from A004/KONP for the market’s sales area, or from a nightly job using one agreed rate source plus your own rounding. Feed, page, JSON-LD and the ECC invoice then agree.
  2. Dynamic FX only for markets you don’t advertise locally. Let Google’s conversion handle those ads off the base-currency feed.
  3. Build the feed from Shopify’s contextual pricing. The Admin API returns the price of a variant in a given market context. Write that exact value to the Merchant API (price.amountMicros + currencyCode) instead of recomputing FX in middleware.
  4. Register FX in the market registry. The feed builder and the edge Worker read these fields, so a market can’t be advertised in local currency unless its prices are fixed.
{
  "market": "GB",
  "fxMode": "fixed",
  "rateSource": "KONP",
  "taxDisplay": "inclusive",
  "localCurrencyFeed": true
}

Revenue and WMS risk register

Thirteen risks, sorted fastest first; IDs stay stable as rows are added. Five bite on the first order. Assign each an owner before a registry row goes live.

IDRiskGapChannel hitSpeedDetection signalPre-launch check
R1Orders post to the wrong sales orgG1Order captureImmediateOrder errors by VKORGRegistry row has VKORG, VTWEG, SPART
R2Price falls back to a default or FX valueG4Margin, Shopping disapprovalsImmediatePrice-mismatch alerts; price disapprovalsA004/KONP exist for the sales area
R3Duplicate sales orders from name collisions or webhook retriesG6Overshipment, refundsImmediateDuplicate BSTKD countBSTKD = {shop}:{order GID} + webhook ID
R4Middleware calls the Shopify Admin API from an IP outside a public app’s allowlist and gets 403HostOrder reads, inventory pushes, conversionsImmediate, from 2026-11-20403 rate per integrationDev Dashboard traffic test passes for every caller
R5A webhook, OAuth, CORS or AS2 endpoint still points at the old hostG9Orders, EDIImmediateWebhook failure rate; AS2 MDN failuresNo hardcoded host strings left
R6Feed link doesn’t match the claimed site, or 404sG9Shopping ads, free listingsHours to daysDisapprovals by feed label; 404 rateCrawl every feed link: 200 on the claimed site
R13Feed price drifts from the page: dynamic FX, IP-based currency or location-based VATG4, G9Shopping ads, free listingsHours to daysMerchant Center price updates and price-mismatch disapprovalsfxMode: fixed for every locally advertised market; feed link carries the market path
R7Case GTIN where the each GTIN is expected, or the reverseG3Fulfillment, refunds, ShoppingDaysWMS unmatched-GTIN count; EDI 997 rejectsEvery item has valid EA and CS GTINs
R8A Shopify location isn’t mapped to WERKS/LGORTG5Oversell, stockoutsDaysInventory sync errors per locationEvery location GID maps in the registry
R9Joins on a localized handle break per languageG2, G8WMS SKU match, itemGroupIdDaysUnmatched-SKU count; item-group splitsNo join keyed on a handle or URL
R10Consent starts empty on the new origin, or never reaches the gateG7Compliance, email revenueWeeks, high severityConsent coverage per marketConsent keyed on customer GID + jurisdiction
R11Cookie and attribution reset on a new registrable domainHostPaid media (CPA, ROAS)Indirect, weeksGA4 self-referrals; consent rate per hostSubfolders, or cross-domain linking set up
R12Re-indexing, hreflang conflicts, redirect chainsG9Organic search, AEOGradual, weeksIndexed pages; rank on top revenue URLsCrawl confirms one-hop 301s

Sizing it

revenue at risk = baseline revenue per day × P(failure) × impairment while failing × days to detect and fix

Detection time is the term monitoring changes most: it moves from days to hours. So compare the expected loss with and without the detection signals above. For R1–R3 and R7–R8, add refunds, chargebacks, reships and trading-partner EDI chargebacks, which the formula misses.

In one line

ECC → Merchant through Xano gets products onto Google now, keeps them there through the S/4HANA migration, and keeps consent in a system built for it. It doesn’t avoid the upgrade; it makes it smaller, safer and no longer a commerce deadline.