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_OPTINand 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.
Why a direct path needs the consent layer more
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
| Issue | Why | Where it is handled |
|---|---|---|
| Freshness | ECC 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 on | Merchant Center needs a product page that can check out, or an agentic checkout. ECC has neither. | The storefront, not the ERP. |
| Prior price | A 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.
| Gap | ECC | Shopify | What breaks when a market is added | Fix |
|---|---|---|---|---|
| G1 Market ≠ sales area | Sales area: VKORG + VTWEG + SPART | Market | Middleware infers the sales area from the domain and posts a new market’s orders to the wrong sales org | Registry maps market → sales area explicitly |
| G2 Grain | MATNR (CHAR 18 in ECC) = one variant | Product groups variants | A second store or a translation plugin forks the grouping, and itemGroupId splits | Key on MATNR ↔ variant GID ↔ SKU; the PIM owns the grouping key |
| G3 One GTIN vs many | MARM-EAN11 per unit (each, case, pallet) | One barcode per variant | A case GTIN reaches Google, or an each GTIN reaches the WMS | Each consumer reads its own unit (below) |
| G4 Price authority | A004/KONP per sales area, usually net | Market price list, often tax-inclusive | A market goes live before its conditions exist and falls back to a default or FX price | live stays false until condition records exist |
| G5 Location grain | Plant + storage location (T001W, MARD), WM warehouse | Location GID | Inventory pushes keyed by location name break when a node is added | Versioned WERKS/LGORT ↔ location GID table |
| G6 Order identity | VBAK-VBELN; customer PO in VBAK-BSTKD | Order GID; name #1001 repeats across stores | BSTKD deduped on the order name collides across stores; webhook retries duplicate orders | BSTKD = {shop}:{order GID}, deduped with the webhook ID |
| G7 Customer and consent | KNA1, one-time (CPD) accounts; no consent model | Customer GID, marketing consent | A new origin starts with empty consent and ECC never sees it | Consent keyed on customer GID + jurisdiction, in the release gate, never ECC |
| G8 Localized text | MAKT per SPRAS | Translations and localized handles | Any join on handle breaks per language | Handles are output only; joins use GID or MATNR |
| G9 URL construction | None: ECC has no URL | Primary + market domains | The feed’s link is built in middleware with brand.com hardcoded | One 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
| Layer | What it does | Note |
|---|---|---|
| Automatic conversion | A dynamic rate Shopify updates to real-time rates, or a manual fixed rate | At checkout, automatic conversion uses Shopify’s rates, plus its conversion fee where that applies |
| Adjustment and rounding | A price list adds a percentage on top of FX, then rounds | Shopify’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 price | A price-list price already in the target currency | Applies regardless of FX and rounding |
What Google requires
| Option | How it works | Trade-off |
|---|---|---|
| Local-currency feed | Submit GBP prices for the UK | The feed currency must match the landing page, for every viewer, wherever Google crawls from |
| Google’s currency conversion | One base-currency feed with extra countries; Google shows its converted price next to yours | Feed, 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 feedlink, 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.pricemust 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 source | Drives |
|---|---|
| ECC exchange rates (TCURR) | Invoicing and financial postings |
| Shopify market FX | Storefront and checkout |
| Google Finance | Google’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
- 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.
- Dynamic FX only for markets you don’t advertise locally. Let Google’s conversion handle those ads off the base-currency feed.
- 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. - 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.
| ID | Risk | Gap | Channel hit | Speed | Detection signal | Pre-launch check |
|---|---|---|---|---|---|---|
| R1 | Orders post to the wrong sales org | G1 | Order capture | Immediate | Order errors by VKORG | Registry row has VKORG, VTWEG, SPART |
| R2 | Price falls back to a default or FX value | G4 | Margin, Shopping disapprovals | Immediate | Price-mismatch alerts; price disapprovals | A004/KONP exist for the sales area |
| R3 | Duplicate sales orders from name collisions or webhook retries | G6 | Overshipment, refunds | Immediate | Duplicate BSTKD count | BSTKD = {shop}:{order GID} + webhook ID |
| R4 | Middleware calls the Shopify Admin API from an IP outside a public app’s allowlist and gets 403 | Host | Order reads, inventory pushes, conversions | Immediate, from 2026-11-20 | 403 rate per integration | Dev Dashboard traffic test passes for every caller |
| R5 | A webhook, OAuth, CORS or AS2 endpoint still points at the old host | G9 | Orders, EDI | Immediate | Webhook failure rate; AS2 MDN failures | No hardcoded host strings left |
| R6 | Feed link doesn’t match the claimed site, or 404s | G9 | Shopping ads, free listings | Hours to days | Disapprovals by feed label; 404 rate | Crawl every feed link: 200 on the claimed site |
| R13 | Feed price drifts from the page: dynamic FX, IP-based currency or location-based VAT | G4, G9 | Shopping ads, free listings | Hours to days | Merchant Center price updates and price-mismatch disapprovals | fxMode: fixed for every locally advertised market; feed link carries the market path |
| R7 | Case GTIN where the each GTIN is expected, or the reverse | G3 | Fulfillment, refunds, Shopping | Days | WMS unmatched-GTIN count; EDI 997 rejects | Every item has valid EA and CS GTINs |
| R8 | A Shopify location isn’t mapped to WERKS/LGORT | G5 | Oversell, stockouts | Days | Inventory sync errors per location | Every location GID maps in the registry |
| R9 | Joins on a localized handle break per language | G2, G8 | WMS SKU match, itemGroupId | Days | Unmatched-SKU count; item-group splits | No join keyed on a handle or URL |
| R10 | Consent starts empty on the new origin, or never reaches the gate | G7 | Compliance, email revenue | Weeks, high severity | Consent coverage per market | Consent keyed on customer GID + jurisdiction |
| R11 | Cookie and attribution reset on a new registrable domain | Host | Paid media (CPA, ROAS) | Indirect, weeks | GA4 self-referrals; consent rate per host | Subfolders, or cross-domain linking set up |
| R12 | Re-indexing, hreflang conflicts, redirect chains | G9 | Organic search, AEO | Gradual, weeks | Indexed pages; rank on top revenue URLs | Crawl 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.