AgentBIAgent with Business Intelligence for DTC sites

Three content domains

Scan / Optimise / Operate: taxonomy and continuously expanded content. Optimisation is grouped by which layer a change lands in; operations by how the work keeps running. Each domain has its own taxonomy.

Back to the knowledge base

About this batch

This is a continuously expanding collection: the first batch (2026-11-12) put one item per section, and batches two through six (2026-11-13) brought each section to six items; the seventh, eighth and ninth batches (2026-11-14) brought each section to nine items (162 total); the tenth batch (2026-11-15) brought each section to ten items (180 total); batches eleven through fifteen (2026-11-15) brought each section to fifteen items (270 total); the sixteenth batch (2026-11-16) brought each section to sixteen items (288 total); batches seventeen and eighteen (2026-11-16) brought each section to eighteen items (324 total); the nineteenth batch (2026-11-17) brought each section to nineteen items (342 total); the twentieth and twenty-first batches (2026-11-17) brought each section to twenty-one items (378 total); a sourcing-selection item was added to BIZ-2 (22 items, holding sourcing-platform questions). Sections keep being filled in. The scan domain keeps its existing 100-item checklist at /kb and is not repeated here. Taxonomy follows the v3 design doc §2.1 / §2.2; content is written by hand (the §3.2 hard constraint was retired on 2026-11-09). Optimisation entries are remediation actions; operations entries are recurring actions. Neither issues a compliance verdict on any single measurement.

Scan

What the site looks like today: what an external agent can read. All existing content lives here — the 100-item checklist, 15 tool mappings (6 live), 18 Q2 references, 11 Q6 measured examples, 3 skill packs and the knowledge-base item pages. It keeps the existing P0–P3 × business-area taxonomy; this batch adds nothing here.

Existing: Open the 100-item scan checklist

This domain keeps the existing 100-item scan checklist and taxonomy; nothing new in this batch — follow the link above.

Optimise

What to change and how. Six sections organised by which layer a change lands in and who ships it; entries are remediation actions, each closing the loop from a scan reading, through the change, to a re-scan.

Existing: Existing: the GEO 62-item checklist

OPT-1 Config layer21 item(s)

Config files only, no code changes — lowest cost

Carriers:Tools: lint + re-scan after a change; Skill: rewriting robots / llms.txt rules; KB: file specs and common misconfigurations.

  • Review robots.txt and the sitemap agent by agent

    A shopping or search agent reads robots.txt first. Putting /products/ or /collections/ in Disallow makes products invisible; a stale sitemap delays discovery of new listings.

    Recommended actions:

    • Check Disallow rules per user agent (GPTBot, PerplexityBot, Google-Extended …) and block only private paths such as checkout, account and internal search
    • Declare an absolute Sitemap URL in robots.txt, then re-crawl the homepage and key product pages with JavaScript disabled

    View detail

  • Declare llms.txt and .well-known/ucp entry points

    Besides robots.txt, agents look for site-provided declaration files. Without them, the site capabilities can only be inferred from crawled pages and are easily misread. These are the owner own config files in a public format — no external data feed is involved.

    Recommended actions:

    • Place llms.txt at the root: a short Markdown file listing the site purpose, crawlable sections and preferred entry points, without dumping the whole catalogue
    • If UCP is supported, declare the capability endpoint at .well-known/ucp per the current public spec; fetch it with JS disabled to confirm a parseable response, not an HTML error page

    View detail

  • Clean up CDN cache headers and redirect chains

    An agent sees the CDN edge response. Long-caching HTML that contains prices, or a chain of 301/302 before the landing page, makes it read stale content or give up.

    Recommended actions:

    • Give product/price responses a short TTL or revalidate them under no-cache; never long-cache HTML that contains prices
    • Reduce key landing pages to a single hop and re-crawl with JS disabled to confirm the final status and canonical agree

    View detail

  • Sitemap sharding and lastmod freshness

    Once a single sitemap holds tens of thousands of URLs, new products sit at the end and are discovered late; a site-wide identical lastmod gives crawlers no freshness signal at all.

    Recommended actions:

    • Shard via a sitemap index (category / listing date), keep each shard at a stable size, and put new products in their own shard submitted first
    • Update lastmod only when content actually changes, and confirm it reports the real date rather than the build time

    View detail

  • Crawl budget and per-UA rate rules

    A blanket Crawl-delay slows legitimate shopping agents too. Set rates per UA group and throttle only expensive paths.

    Recommended actions:

    • Set crawl rates per UA group and throttle only expensive paths (faceted search, deep pagination)
    • Compare crawl completion for the same UA before and after; do not mistake slower for more stable

    View detail

  • Keep staging and production config separate

    If staging noindex, a fully blocking robots or a test domain reaches production, the whole site vanishes from agent view overnight.

    Recommended actions:

    • Parameterise robots / noindex / site URL per environment and verify the active values in the release manifest
    • After release, fetch anonymously to confirm production serves production config with no staging markers

    View detail

  • Check WAF and rate-limit rules for agent-UA false positives

    The easiest thing to miss at the config layer is edge protection: a WAF, bot manager or rate limiter treats shopping/search agent UAs as scrapers, so the page works in a browser while the agent gets a 403 or a challenge page. Fixing it is a config change — the cheapest kind.

    Recommended actions:

    • Allow-list known agent UAs (GPTBot, PerplexityBot, OAI-SearchBot and shopping agents) and verify a 200 with full HTML via a JS-disabled fetch in a staging environment
    • Review rate-limit thresholds per UA group so agent batch fetches are not mixed with abusive traffic under one rule; close with a re-scan
  • Check X-Robots-Tag and noindex response headers path by path

    No noindex in the HTML does not mean none in the headers. An X-Robots-Tag added by a CDN or reverse proxy can hide a whole class of pages from agents while the pages look perfectly fine. This is a config-layer check — the fix lives in header rules.

    Recommended actions:

    • Fetch headers per path to confirm product/category/home carry no X-Robots-Tag noindex/nofollow, keeping it only for checkout, account and internal-search paths
    • Check CDN and origin header rules do not override each other; re-verify key pages with JS disabled and close with a re-scan
  • Re-check crawl reachability after TLS / HSTS / chain changes

    A certificate rotation, HSTS bump or protocol change can break the handshake or stall redirects for some crawlers while browsers are unaffected. The change is config-layer; acceptance is whether an agent gets a complete response, not whether a browser opens the page.

    Recommended actions:

    • After cert/HSTS/TLS changes, verify handshake, redirect chain and final status via JS-disabled fetches from more than one egress, and leave a change record
    • Check http→https and www/non-www redirects do not form long chains; do not skip the agent-view check just because browsers work
  • Standardise 403 / 429 / 5xx bodies and Retry-After headers

    If rate-limit, auth-failure or maintenance responses look the same as a missing or forbidden page, an agent records a temporary outage as a permanent gap. The change is config-layer (gateway / CDN rules); acceptance is that status semantics are distinguishable, not that the error page looks nice.

    Recommended actions:

    • Give 429 / 503 a Retry-After header and a short machine-readable body, distinct from 403 / 404; return 503 for maintenance windows instead of a 200 soft page
    • Re-scan per status code after the change and confirm an agent can tell a retry-later case from a not-readable case; do not hide the explanation behind JS
  • Roll out in-progress config rules by UA / path

    A new robots, CDN or WAF rule switched on everywhere also changes agent paths still under observation. Roll out in-progress rules by UA / path group at the config layer and verify group by group rather than from one site-wide result.

    Recommended actions:

    • Give in-progress rules UA / path conditions and a rollout ratio, start small, and keep a config change record
    • Re-scan per group and check status plus body separately; one group passing is not a full rollout passing
  • Judge config re-scans per path / UA group

    One URL returning 200 does not mean a config change works for every path and every agent UA. Change acceptance to a per-group pass rate instead of one spot check standing in for the whole site.

    Recommended actions:

    • Define groups (path type by UA) with samples per group and record status plus body verdict for each
    • Report pass rate per group; one failing group fails the item, and do not re-run to force green
  • Put config ownership and a change template in the repo README

    robots, llms.txt and CDN rules scattered across places leave nobody sure who changed what. Put owners and a change template in the config repo README so edits have one fixed entry point.

    Recommended actions:

    • List owner, approver and a change template (reason / scope / rollback) per config file in the README
    • Log changes via the template; no verbal edits, no duplicate explanations in scattered places
  • Layering and naming rules as config rules grow

    As rules grow, CDN, WAF and robots entries override each other and become unreadable. Fix layering and naming rules at the config layer so every new rule has a place.

    Recommended actions:

    • Name rules by layer / UA / path and register new ones with a priority; check for duplicates first
    • Check for overlaps before adding; log merges and retirements in the changelog
  • Keep credentials and tokens out of public declaration files

    Declaration files under robots.txt, llms.txt and .well-known are publicly readable; a token pasted in while debugging leaks immediately. Make it a hard config-layer rule that public files carry no sensitive values.

    Recommended actions:

    • Public declaration files carry paths / rules / entry points only — no tokens, keys, internal hosts or accounts
    • Scan them before release; on a leak, rotate the secret and log it rather than just deleting the line
  • Pre-flight validation for config changes (lint / dry-run)

    A bad push to robots.txt, redirects or response headers can affect agent crawling immediately. Running machine-checkable validation before merge or publish catches syntax errors and contradictory rules before the blast radius grows.

    Recommended actions:

    • Add linting for robots.txt / sitemap / header config and block merges on syntax errors or contradictory rules.
    • Dry-run against a fixed mock request set and confirm allow/deny results per path before publishing.
  • Confirm no live traffic references a config rule before retiring it

    Stale rules stack up and override newer ones. Before removing one, check recent crawl and access records to confirm no path or user agent still matches, then archive the removal.

    Recommended actions:

    • Register an enable date and owner for each rule; record the last matching path and date when retiring it.
    • Keep an archived copy for a period after removal and re-scan to confirm behaviour is unchanged before purging.
  • Manage robots / sitemap declarations per market to avoid hurting regional URLs

    When a multi-market site shares one robots.txt, a rule for one market can hurt another's regional URLs. Split declarations per market and re-verify each.

    Recommended actions:

    • List regional paths and UA rules per market, and re-scan each market's key pages after a change.
    • Shard the sitemap per market with absolute URLs; never put unpublished internal routes in declarations.
  • Lightweight crawling via response headers: compression and caching, no code changes

    Crawling by agents and search engines consumes bandwidth and crawl budget. Compression and cache headers set at the server layer let the same content be fetched faster without touching templates or data.

    Recommended actions:

    • Enable Gzip/Brotli in server config; confirm product pages and sitemap return compressed HTML.
    • Set sensible Cache-Control on robots.txt, sitemap and static images so crawls don't hit origin for full payloads every time.
  • Declare structured-data entry points and correct MIME types at the config layer

    Structured-data files are only reliably fetched when headers and path config are right. Declare entry points, set the correct Content-Type and allow crawling at the config layer — no template or data changes.

    Recommended actions:

    • Set the correct Content-Type (e.g. application/ld+json) for structured-data paths and make sure robots doesn't block them by mistake.
    • Declare stable entry paths and re-verify with a JS-less crawl that they are readable.
  • Enable HTTPS, HSTS and security headers at the config layer

    Agents and users both rely on secure connections. Force HTTPS, enable HSTS and basic security headers at the config layer — no template or data changes.

    Recommended actions:

    • Force HTTPS site-wide, set HSTS and basic security headers on key pages, and avoid mixed content.
    • After the change, re-verify with a JS-less crawl that the main text is still readable.
OPT-2 Template layer21 item(s)

Front-end templates — requires a deploy

Carriers:Tools: validating template output; Skill: generating snippets from readings; KB: per-template fixes and regression checklists.

  • Server-render the core product facts

    Many external agents do not execute JavaScript, or only part of it. If name, price and availability are filled in only by hydration, the agent sees an empty shell.

    Recommended actions:

    • Put name, price, availability and JSON-LD into server-rendered HTML; fetch once with JS disabled to confirm the price is readable
    • Validate every template with the Rich Results Test, not just one hand-written sample page

    View detail

  • Complete JSON-LD and canonical / hreflang per template

    Structured data that exists only on a few hand-written pages disappears with the next template change; on multilingual sites, missing hreflang makes agents treat same-named products across markets as duplicates or mix up prices.

    Recommended actions:

    • Make Product / BreadcrumbList / Organization JSON-LD template variables, with price and availability sourced from the same fields as the server-rendered HTML
    • Emit a self-referencing canonical on every indexable page; cross-link hreflang with x-default on localised pages, and spot-check each template with the Rich Results Test

    View detail

  • Template output for image srcset / alt and critical CSS

    When the main image is JS-lazy-loaded and alt is empty, an agent has no citable image data; if critical CSS blocks first paint, the main content never appears in a JS-disabled fetch.

    Recommended actions:

    • Emit real alt text and srcset for the main image in the template, with a no-script src fallback
    • Inline critical CSS and load the rest async; confirm name and price are visible in a JS-disabled fetch

    View detail

  • Generate and de-duplicate title / meta description per template

    One title site-wide, or filter pages copying the category description, leaves agents unable to tell pages apart or extract a usable one-line summary.

    Recommended actions:

    • Make title/description template variables (category + product name + key attribute), unique per page
    • Give paginated/filtered pages their own description or noindex instead of copying one block everywhere

    View detail

  • Indexability of paginated, filtered and variant URLs

    Colour, size and sort parameters spawn endless URLs that eat the crawl budget, and self-canonicals leave piles of duplicates.

    Recommended actions:

    • Whitelist filter/sort parameters; noindex or canonicalise other combinations back to the main category
    • When a variant has no independently citable content, canonical it to the parent and keep one indexable URL

    View detail

  • Defaults and fallbacks for template variables

    When a locale misses a field, the page shows the raw key or a blank, and agents cite products.title as if it were copy.

    Recommended actions:

    • On a missing dictionary key, fall back to the default locale copy — never render the key itself
    • Add a missing-value smoke test per template: with optional variables cleared, a full sentence still renders

    View detail

  • Emit BreadcrumbList markup from the template

    Breadcrumbs carry the category/product hierarchy, which is how an agent tells which category a product belongs to and which pages sit at the same level. Inferring hierarchy from URLs alone misreads short /p/ links or parameterised paths, so this belongs in the template as a fixed output.

    Recommended actions:

    • Emit BreadcrumbList from category and product templates matching the visible breadcrumb — do not ship structured data without a visible trail
    • Check filtered/paginated pages do not produce contradictory breadcrumbs; spot-check home, category and product pages with JS disabled after the change
  • Fix soft 404s and templates for out-of-stock, removed and empty-result pages

    When a product is removed or a search returns nothing, serving 200 with an empty shell makes agents treat a blank page as a live listing and keep citing it. The template-layer fix is to return the right status and a clear next step instead of an empty shell that looks like a product page.

    Recommended actions:

    • Set a status and template per case: removed returns 410 or a clear pointer to a replacement; empty results expose crawlable suggestions
    • Ensure templates emit no empty JSON-LD or blank price fields; spot-check one page per case to confirm it is not a 200 with an empty shell
  • Fix a single H1 and stable product name in the template

    If the same product shows different heading levels and name variants across search, category and recommendation placements, an agent cannot tell which is the canonical name. Fixing H1 and product name to one source in the template is more reliable than aligning copy repeatedly.

    Recommended actions:

    • Fix one H1 on the product template sourced from the master product name; put promo prefixes or channel tags in a subtitle or structured field, not the H1
    • Check category, recommendation and search-result names match the product page; close a title-template change with a re-scan
  • Stamp price / availability values with an as-of time in templates

    A cached page, a CDN edge or a different egress can serve numbers captured at different moments. Adding an as-of / dateModified stamp to key readings in the template lets an agent judge whether a value is current instead of treating a cached snapshot as live. This is template output and needs a deploy.

    Recommended actions:

    • Emit one consistent as-of / dateModified stamp next to price, availability and promo price, and fix the format and timezone in the template contract
    • On re-scan, check the as-of value is coherent with other time fields on the same URL; the stamp is not permission to compare absolute values across vantages
  • Mark restricted values with a reason instead of placeholder values

    When price is login-only, a region is not served or a price is TBD, a template that writes zero, blank or a guess makes an agent read a placeholder as fact. Emit an explicit restricted marker plus reason at the template layer; no invented values.

    Recommended actions:

    • Emit an explicit restricted marker plus reason for login-only, region-blocked or price-TBD fields; no zeros, blanks or guesses
    • On re-scan, confirm the marker matches structured data and no restricted value leaked into a JSON-LD numeric field
  • Validate templates against a fixed sample-page set before release

    Template changes have a wide blast radius and clicking a few pages misses cases. Validate JSON-LD, meta and key fields against a versioned fixed sample set before release, and version the set itself.

    Recommended actions:

    • Keep a versioned sample set covering every template type / locale and run full validation before release
    • Log sample-set changes in the changelog; do not shrink the set to meet a release deadline
  • A ripple checklist for template changes

    One template edit usually means locale versions, structured data and feed fields too. Fix a ripple checklist at the template layer so only the visible page does not get changed.

    Recommended actions:

    • List affected page types, locales, JSON-LD and feed fields and confirm each one
    • Unconfirmed items block completion; re-scan follows the checklist item by item
  • Shared components and a thin difference layer as templates scale

    With many locales and markets, copying templates page by page means one fix misses ten pages. Extract shared components at the template layer and keep differences in one thin config layer.

    Recommended actions:

    • Extract shared header / JSON-LD / meta into components and keep market differences in one thin layer
    • Change the shared component first and run the full sample set; no per-page edits or full-template copies
  • Keep internal IDs and debug fields out of public HTML

    Internal IDs, session markers or debug flags left in a template become publicly visible with the page. Fix a whitelist for public template output at the template layer.

    Recommended actions:

    • Whitelist fields allowed in public HTML; internal IDs, session markers and debug flags never reach template output
    • On re-scan, sample page source and RSC payload for out-of-scope fields and fix the template before release
  • Server-rendered fallback when a template fails

    When a template variable is missing or rendering fails, returning an empty shell or a JS-only page leaves an agent with no product facts. Keep a server-rendered fallback for key templates so even error states retain core information.

    Recommended actions:

    • Define a minimal output field set for product and listing pages and emit it server-side when rendering fails.
    • With JavaScript disabled and fault injection on, re-crawl the fallback page and confirm title, price, availability and canonical remain.
  • Archive template versions with a rewind window

    After a template change it is hard to tell which edit introduced a regression. Keep the previous version and a change note with each release for comparison and rollback.

    Recommended actions:

    • Archive the previous template file and a change summary with each release, with a retention window.
    • On a re-scan anomaly, diff against the archived version to locate the cause before deciding to roll back, rather than editing live blindly.
  • Make hreflang self-referencing with matching language/region codes

    Missing self-referencing hreflang or wrong language codes send agents to the wrong version. Validate the return links market by market.

    Recommended actions:

    • Declare self-referencing hreflang on each language/region version and verify the return links and code spelling.
    • Point canonical at the market-specific URL, not every regional page at the default market homepage.
  • Put primary content first in templates so JS-less crawlers get key content directly

    Many templates put title, price and specs into script-rendered blocks that JS-less agents never see. Move key fields into server-rendered HTML and keep the first screen independent of large scripts.

    Recommended actions:

    • Crawl key product pages with JS disabled and confirm title, price and specs are readable in raw HTML.
    • Server-render the first-screen content and defer non-essential scripts so they never block the main text.
  • Use semantic tags and aria labels so both agents and assistive tech can read templates

    Div-only markup is unfriendly to both assistive tech and agents. Use semantic tags (header, nav, main, article) and aria labels so price, specs and stock states have clear roles.

    Recommended actions:

    • Switch product pages to semantic tags and label price and stock state with visible text or aria-label.
    • Crawl once with JS disabled and confirm the semantic structure exists in raw HTML.
  • Don't bake secrets or internal addresses into templates; label external links and forms

    Hard-coded keys or test addresses in templates leak. Inject only public values at build time and label the purpose and origin of external links and forms.

    Recommended actions:

    • Check that built HTML contains no secrets, internal addresses or test credentials.
    • Label the purpose and origin of forms and third-party scripts; don't pull in unknown resources.
OPT-3 Data layer21 item(s)

Product master data and feeds — cross-system

Carriers:Tools: strict feed-to-landing-page consistency checks; Skill: generating mappings and conversions; KB: master-data governance SOP.

  • Keep feed and landing-page price / availability consistent

    When the readings disagree, an agent discards the whole record. A feed that is not refreshed after a bulk price change is the most common hidden loss.

    Recommended actions:

    • Make product master data the single source of truth for detail page, cart, checkout and feed
    • Force a feed refresh after every bulk price change and auto-compare the three amounts plus availability

    View detail

  • Unify SKU↔id mapping and unit / size conversions

    When the same product carries different ids in ERP, storefront and feed, an agent reads it as two items; unit and size conversions buried in prose rarely line up across markets.

    Recommended actions:

    • Fix one stable product id as the primary key, map SKU / variant / channel ids onto it, and version the mapping alongside product master data
    • Express weight, dimensions and size conversions as structured fields and lookup tables; never leave approximately-equals only in the description text

    View detail

  • Put currency, decimals and tax wording into master data

    Guessing currency from the URL, two decimals on JPY, or no tax wording next to the price makes agents misread amounts across markets.

    Recommended actions:

    • Attach an ISO currency code and decimal rule to every price (0 for JPY/KRW) and make tax-inclusive/exclusive a separate field
    • Render detail page, cart, checkout and feed from that same field set instead of formatting separately in each template

    View detail

  • availability write-back and preorder / stockout states

    When the page says in stock but the feed says out, or a sold-out item still allows add-to-cart, agents discard the record and users hit failed orders.

    Recommended actions:

    • Model in_stock / preorder / backorder / out_of_stock as one enum shared by detail page, cart, checkout and feed
    • On stockout, disable add-to-cart and offer a restock notice — do not change the copy while leaving the state unchanged

    View detail

  • Link variants to the parent product in structured data

    Writing each size as a standalone Product makes agents compare them as different items rather than options of one product.

    Recommended actions:

    • Attach variants to a parent via ProductGroup / hasVariant (or equivalent), with price and availability at variant level
    • Put shared facts (material, brand, use) on the parent and only differing fields on variants, avoiding four-way duplication

    View detail

  • Feed refresh latency and incremental sync

    If a feed refreshes days after a price change, agents read stale prices; full rebuilds are too slow, so incremental triggers need to be explicit.

    Recommended actions:

    • Trigger incremental sync on price / listing / stock changes and set a maximum effective latency
    • Bucket feed-to-page differences by latency and investigate the job when it is exceeded, rather than hand-editing the feed

    View detail

  • Fill in stable product identifiers (GTIN / MPN / brand)

    Price and stock change; identifiers should not. Without GTIN, MPN and brand, an agent cannot reconcile the same product seen across channels or at different times and may treat it as a duplicate or a conflict. This is master-data work, not a template fix.

    Recommended actions:

    • Make GTIN / MPN / brand required in master data (or record why they are missing) and have feed and landing page read the same field rather than separate copies
    • Check identifiers do not bleed between variants and the parent product; if the field definition changes, record it in the changelog instead of silently overwriting history
  • Define a product state machine and its feed-sync rules

    Without explicit states and transitions for draft, live, out-of-stock, removed and archived, the feed ends up with 'removed but still buyable' or new listings that never appear. This is a master-data rule — define states before discussing how templates display them.

    Recommended actions:

    • List the state enum and allowed transitions, defining for each whether it appears in the feed and sitemap and with what availability
    • Drive feed updates from one master-data source on state change, not per-channel edits; log definition changes in the changelog
  • Align multi-warehouse and in-transit stock definitions

    When one SKU is split across warehouses plus in-transit units, channels computing 'available' differently give agents contradictory stock. The data layer must first define what counts as sellable and what is internal-only.

    Recommended actions:

    • Define sellable stock (which warehouses, whether in-transit counts, how reserved units are deducted) and have all channels read one field
    • Keep out-of-stock/backorder states consistent with that definition; log changes in the changelog and never rewrite historical snapshots
  • Put returns, warranty and delivery windows into master data and the feed

    These promises are often hand-written in template copy while the feed carries a different structured value, so an agent sees two answers. The fix is data-layer: add master-data fields, emit them into the feed from the same source, and let templates render fields only. Re-scan acceptance is field-based.

    Recommended actions:

    • Add return window, warranty period and estimated delivery window to product / category master data and map them to the matching feed fields
    • On re-scan, confirm page copy matches the feed fields; log definition changes in the changelog instead of keeping a second hand-written copy in the template
  • Keep legacy identifier mappings when products merge or are recoded

    After an SKU recode, a product merge or a GTIN reassignment, old links and old feed references point at nothing. Keep a legacy-to-new map at the data layer so both feed and pages still resolve, and historic citations do not break.

    Recommended actions:

    • Build a legacy SKU / GTIN to new identifier map with effective ranges and log mapping changes
    • On re-scan, spot-check that legacy identifiers still resolve to the new product or an explicit archived notice, not a silent 404
  • Sample feed-to-landing consistency by category / channel

    Full comparison is costly and casual sampling is biased. Set consistency acceptance at the data layer as stratified sampling with a fixed sample size and a failure path per stratum, without turning one full sweep into a lasting conclusion.

    Recommended actions:

    • Fix per-category / per-channel sample sizes and log difference counts and types per stratum
    • Log differences per stratum for master-data fixes; never turn a sample into a 'whole site consistent' claim
  • Downstream notification order and confirmers for master-data changes

    A master-data change has to reach the feed, ERP, support and warehouse; the wrong order produces contradictory answers. Fix the notification order and a confirmer at each step at the data layer.

    Recommended actions:

    • Fix the notification order (master data → feed → ERP / warehouse → support) and a confirmer per step, with records
    • Mark 'syncing' until every step confirms; do not claim completion or ingest merchant-private data
  • Tier master-data fields into required and optional as they grow

    As fields grow, validating every product against all of them gets expensive. Split fields into required and optional sets at the data layer: full checks on required, sampling on optional.

    Recommended actions:

    • Define required (identifiers / price / stock / status) and optional sets with different validation strength
    • New fields join a set before going into the feed; do not promote everything to required
  • Keep private fields out of feed exports

    Feeds are read by channels and third-party tools; including supplier price, cost or supplier identity publishes business data. Whitelist export fields at the data layer.

    Recommended actions:

    • Whitelist feed export fields and exclude supplier price, cost, supplier identity and internal notes
    • Recheck the whitelist on every field change; no merchant-private data ingested or sent back to third-party tools
  • Register the source system and owner of each public field

    Feed and on-page fields often come from different systems, making mismatches hard to trace. Register the source system, owner and update cadence of every public field so a consistency issue can be pinned to a specific step.

    Recommended actions:

    • Keep a field register for price, availability and specs recording source system, owner and maximum acceptable staleness.
    • Change the register before changing output, and verify consistency field by field against it during re-scans.
  • Retire fields through a deprecation flow, not a hard delete

    Dropping a feed or master-data field outright leaves downstream consumers reading empty values. Stop public output first, clean up internal fields later, and keep old values queryable for a while.

    Recommended actions:

    • Retire a field in four steps — stop output, notify downstream, retain old values, then purge — dating each.
    • During deprecation keep old values queryable under the original definition; never rewrite history or let a new field masquerade as the old one.
  • Label multi-currency prices with currency and rate source date

    The same product shows different currencies per market; without the currency and rate source date, readings look contradictory. Put the source in master data.

    Recommended actions:

    • Label price fields with currency, tax basis and rate source date, keeping feed and page identical.
    • Do not compare prices across markets; compare trends within a market and log definition changes in the changelog.
  • Trim redundant fields in feeds: ship the minimum usable field set per channel

    Feeds packed with long descriptions, full-size images and hi-res parameters slow down downstream crawling and sync. Trim to the minimum usable field set per channel without losing key attributes.

    Recommended actions:

    • List the fields each channel actually reads and drop redundant large fields nobody consumes.
    • Use crawl-friendly image sizes and formats in feeds and keep originals at the source rather than shipping them again.
  • Add structured fields to feeds and data, labelling entity types and units

    The same product aligns across channels through structured fields such as entity type, unit and currency. Add Product / Offer / Brand fields at the data layer and label units.

    Recommended actions:

    • Label price, weight and size fields with units and currency so downstream systems don't have to guess.
    • Output canonical fields at the data layer for structured-data generators; don't assemble them ad hoc in the view.
  • Keep private fields out of feeds and mask sensitive ones

    Feeds can unintentionally expose internal SKUs, costs or customer info. Trim per channel, mask or omit sensitive fields, and don't drop key attributes.

    Recommended actions:

    • Define a per-channel field allowlist for feeds and drop private fields such as cost and internal IDs.
    • Mask any user-related info before it enters the feed.
OPT-4 Flow layer21 item(s)

Business flows — highest cost, often needs a sandbox

Carriers:Tools: flow smoke tests (bounded by the T3 human/sandbox constraint); Skill: triage order; KB: step-by-step SOP.

  • Sandbox the checkout flow and regression-test currencies

    Any break between add-to-cart and order confirmation makes an agent treat the site as unusable; 3DS and currency rules differ by market.

    Recommended actions:

    • Run a sandbox order per market (add to cart → address → shipping → payment → success) and log failure-code distribution
    • Use 0 decimals for JPY/KRW, label tax-inclusive vs exclusive, and keep amounts identical across detail page, cart, checkout and feed

    View detail

  • Make 3DS, chargebacks and the returns path explicit in checkout

    If payment verification and after-sales paths hide behind modals or scripts, an agent cannot tell whether the transaction can complete. These flow changes need a human or a sandbox; tools only mark the boundary and do not promise automation.

    Recommended actions:

    • Document 3DS trigger conditions, retry and fallback payment paths as crawlable steps in checkout, noting which markets enable them
    • Put the returns / refund entry point and its deadlines into order confirmation and the help centre; run one human sandbox pass per market, log failure codes per step, and do not treat these as auto-verifiable

    View detail

  • Show shipping and duties before checkout

    Shipping and duties that appear only at the payment step are the most common cause of cart abandonment, and an agent reads the same signal as a trust issue.

    Recommended actions:

    • State shipping estimates, duty responsibility and delivery time on the product/cart pages and keep checkout consistent
    • Verify shipping math per market in a sandbox; label landed price separately from item price rather than blending them

    View detail

  • Guest checkout and the account-wall tradeoff

    Forcing signup before checkout is a top abandonment cause, but collecting no email breaks fulfilment notices — the flow needs one explicit minimal path.

    Recommended actions:

    • Enable guest checkout by default, collect only email/phone at order submit, and move signup to post-payment
    • Sandbox the guest → order → notification path per market and log failure codes per step

    View detail

  • Internationalise address and form validation

    Validating global orders with one US address rule rejects valid postcodes, regions and phone formats before payment.

    Recommended actions:

    • Configure required fields and formats per market (postcode, region, phone, name order) with specific instead of generic errors
    • Run real address samples per market in a sandbox and log which fields get rejected

    View detail

  • Payment-failure recovery and order idempotency

    A timed-out retry easily creates two orders, and without a clear recovery path users must redo the whole cart.

    Recommended actions:

    • Send an idempotency key with order requests so retries return the same order, and de-duplicate payment callbacks
    • Keep the cart on failure and offer explicit retry / alternative-payment paths, logging failure codes

    View detail

  • Make order-confirmation and status fields machine-readable (sandbox only)

    If the order number, status and timestamp on the confirmation page and notifications are just human-facing prose, an agent cannot reconcile them. Validate field structure and rendering only within the T3 sandbox / human walkthrough boundary — no real transactions, no real order data collected, and no compliance verdict drawn from it.

    Recommended actions:

    • On sandbox orders, expose order number, status enum and timestamps as explicit fields (not embedded in prose), sharing one status dictionary across confirmation and notification templates
    • Validate readability and status transitions only in a T3 sandbox / human walkthrough — no live payments, no real orders; record field structure only, no compliance verdict
  • Checkout timeout and stock lock/release rules (sandbox only)

    How long stock is locked during checkout and how a timeout releases it determines whether the sellable quantity an agent reads is trustworthy. Validate the rule and its fields only within the T3 sandbox / human walkthrough — no real transactions, no real order data, no compliance verdict.

    Recommended actions:

    • In the sandbox, define lock duration, timeout release and concurrent-order precedence, and confirm sellable quantity is written back consistently on timeout
    • Validate rule and fields only — no live payments, no real orders; record the rule, not a compliance verdict
  • Coupon / promo calculation order and display (sandbox only)

    Whether discounts, shipping and tax are applied in which order changes the payable total for the same coupon across entry points. Check order and display consistency only within the T3 sandbox / human walkthrough — no real transactions, no real order data, no compliance verdict.

    Recommended actions:

    • On sandbox orders, fix the discount → shipping → tax order and confirm product, cart and checkout totals come from one source
    • Use sandbox samples only — no live payments, no real orders; log order-rule changes in the changelog, no compliance verdict
  • Split lines and status for preorder / split-shipment orders (sandbox only)

    Mixed orders (in-stock plus preorder, or multi-warehouse split shipments) are often flattened into one total and one status, so an agent cannot tell which amount belongs to which fulfilment batch. This is the costliest, process-layer change and is validated only in a T3 sandbox / human walkthrough: no live payment, no real orders, no compliance verdict drawn from it.

    Recommended actions:

    • In the sandbox, split checkout lines by fulfilment batch, mark each line's ship-by time and status, and verify the confirmation page is machine-readable
    • Keep it to representation and regression drills only; no live payment, no real orders, and no public commitment based on sandbox results
  • Write back status after cancellation, partial cancellation and chargeback (sandbox only)

    If cancellation, partial cancellation or chargeback does not write back status and stock, an agent still reads the order as placed and stock as held. This process-layer change is validated only in a T3 sandbox / human walkthrough: no live payment, no real orders, no compliance verdict.

    Recommended actions:

    • In the sandbox, verify machine-readable status fields, stock release and confirmation pages for cancel / partial cancel / chargeback, with replay
    • Representation and regression drills only; no live payment, no real orders, no public commitment from sandbox results
  • Sandbox pass criteria go beyond one successful run (sandbox only)

    One successful run can be luck. Define sandbox acceptance as three things together — machine-readable fields, complete status, replayable — judged only in a T3 sandbox / human walkthrough, with no live payment and no real orders.

    Recommended actions:

    • Set three pass criteria plus a replay step; log each drill, and missing any one criterion fails it
    • No live payment, no real orders, no public commitment or compliance verdict from sandbox results
  • Handover record for sandbox drill results (sandbox only)

    A finding with no owner is missed again next round. Turn sandbox drill results into a handover form at the process layer, used only in a T3 sandbox / human walkthrough.

    Recommended actions:

    • Log drill date, findings, suggested actions, receiving owner and status, and track each to closure
    • Records and handover only; no live payment, no real orders, no compliance verdict
  • Grade sandbox combinations by risk instead of enumerating all (sandbox only)

    Currency by payment by fulfilment combinations multiply fast; exhaustive coverage is unrealistic. Pick combinations by risk at the process layer, executed only in a T3 sandbox / human walkthrough.

    Recommended actions:

    • Grade combinations by risk, always run high-risk ones, sample low-risk ones, and log coverage plus gaps
    • No live payment, no real orders; mark uncovered combinations honestly instead of claiming they were verified
  • Use only fake accounts and test credentials in the sandbox (sandbox only)

    A drill wired to a real account or real payment credential stops being a replayable sandbox. Make fake-data-only a hard process-layer boundary, executed only in a T3 sandbox / human walkthrough.

    Recommended actions:

    • Use marked test values for accounts, addresses and payment credentials; no real credentials in the drill environment
    • No live payment, no real orders, no compliance verdict, and no real personal data in drill records
  • Callback signature checks and replay protection (sandbox only)

    Agent-initiated orders trigger payment and fulfilment callbacks. Forgeable or replayable callbacks can corrupt order state. In the sandbox, make signature verification and replay protection mandatory, without touching real payments or orders.

    Recommended actions:

    • In the sandbox, verify callbacks with bad signatures or stale timestamps are rejected without creating real orders.
    • Redeliver the same callback and confirm order state changes once, with a deduplication record kept.
  • Archive sandbox drill records and purge them after retention (sandbox only)

    Sandbox drills accumulate accounts, addresses and callback samples. They are useful but take space; archive by retention window and desensitise or purge when expired.

    Recommended actions:

    • Label drill records with a creation date and retention window; after expiry keep only the desensitised conclusion.
    • Archived records are for internal review and handover only — no real payments, no real orders, nothing in public declarations.
  • Validate local payment and address format combinations per market (sandbox only)

    A payment and address combination that works in one market fails in another. Validate each market in the sandbox without reusing another market's cases.

    Recommended actions:

    • List local payment methods and address formats per market in the sandbox and verify each combination, keeping desensitised conclusions.
    • No real payments or orders; do not extrapolate to untested markets or issue compliance verdicts.
  • Keep callback and checkout flows lightweight — sandbox-only drill (T3)

    Business-flow changes cost the most. To make checkout or stock write-back lighter, first validate fields and idempotency with small traffic in a sandbox — never touch real payments or create real orders.

    Recommended actions:

    • In a sandbox, verify with synthetic orders that slimmed-down callback fields parse correctly; label it T3 / sandbox-only.
    • Record the field mapping and idempotency keys from the drill; consider rollout only after validation, never crossing into real transactions.
  • Validate structured labels for checkout and stock states in a sandbox first (T3)

    To expose stock availability and price validity as structured signals, first validate the field mapping in a sandbox with synthetic data — no real payments, no real orders.

    Recommended actions:

    • In a sandbox, verify with synthetic data that structured state fields parse correctly; label it T3 / sandbox-only.
    • Record the field mapping and drill scope; consider rollout only after validation, never crossing into real transactions.
  • Validate security changes to payment and account flows in a sandbox only (T3)

    Security-control changes to checkout and login cost the most. Validate auth and token boundaries with synthetic accounts and orders in a sandbox — no real payments or orders.

    Recommended actions:

    • Validate auth and token boundaries in a sandbox; label it T3 / sandbox-only.
    • Record the scope and conclusion; consider rollout only after validation, never crossing into real transactions.
OPT-5 Content layer21 item(s)

Human-written content, continuously expanded

Carriers:Tools: coverage and readability checks; Skill: writing templates; KB: style guide and per-category fact sheets.

  • Make category pages and size guides agent-readable

    A size chart as an image, or specs scattered through free text, leaves an agent unable to compare products — so it cites a competitor instead.

    Recommended actions:

    • Use an HTML table for the size chart, state how to measure, and put key conversions into structured data
    • Write a citable fact sheet per category (material, origin, use case) and keep first-screen content off hover / JS

    View detail

  • Keep multilingual product copy and the help centre consistent

    When each market writes its own copy, material, warranty and delivery claims diverge and an agent ends up quoting contradictory answers. The help centre is the most-cited yet least-updated place.

    Recommended actions:

    • Maintain one shared fact sheet per product (material, origin, warranty, delivery); generate localised copy from it and update every language when the facts change
    • Include returns / duties / delivery help pages in the review checklist for every price or policy change, keeping help pages and checkout consistent

    View detail

  • Structure per-product specs and material facts

    Specs buried in long descriptions cannot be extracted into comparable fields, and inconsistent material names across pages produce contradictory citations.

    Recommended actions:

    • Move material / dimensions / weight / origin into a spec table or structured fields, with names fixed in one shared fact sheet
    • Attach units and measurement method to each spec; let the description explain rather than carry the only copy of a fact

    View detail

  • Structure and expose help-centre FAQs

    FAQs hidden behind JS accordions or in images cannot be cited by agents, so support keeps answering the same questions.

    Recommended actions:

    • Render FAQ Q&A in server-side HTML with FAQPage structured data; answers must not depend on an expand script
    • Group high-frequency returns/duties/delivery questions by market and keep wording aligned with policy pages

    View detail

  • Make comparison tables and buying guides agent-readable

    Buying guides are the most citable content, yet they are often long images or interactive widgets that leave agents with one marketing line.

    Recommended actions:

    • Use HTML tables with explicit dimensions and units, and keep the conclusion citable without hover or scripts
    • State who a guide is for and who it is not, so agents do not apply the recommendation to every audience

    View detail

  • Clean up stale facts and expired promo copy

    Delisted items, ended promos and superseded specs left on category and help pages keep getting cited long after they stopped being true.

    Recommended actions:

    • Tag every citable fact with an effective period and source, and retire it on expiry or delisting
    • After a promo, reconcile price and delivery claims on category pages, help pages and structured data

    View detail

  • Separate marketing adjectives from verifiable facts

    Words like 'premium' or 'best value' cannot be verified by an agent and dilute the facts that can be — specs, materials, origin. The content-layer change is to put verifiable fields in their own block and keep promotional copy in the description, never mixed in one sentence.

    Recommended actions:

    • Group verifiable facts (specs, materials, origin, warranty) into a dedicated field block; keep promotional wording in the description without presenting it as fact
    • Check translations do not turn adjectives into factual-sounding claims; keep a version trail when fact fields change so re-scans can diff them
  • Add text alternatives for product video, 3D and size imagery

    Agents cannot read video, 3D models or size imagery; without a text version, facts about material, dimensions and usage live only in pictures. The content-layer addition is a readable equivalent, not another pass of marketing copy.

    Recommended actions:

    • Give each video/3D/size asset a crawlable text description covering verifiable facts (dimensions, material, use case), consistent with the spec fields
    • Keep descriptions in sync across languages; update the text when media is swapped so captions do not go stale
  • Normalise terminology and attribute names across categories

    When the same attribute is named differently across categories (material / fabric / composition), agents struggle to align the same fact. The content-layer step is a synonym map plus consistent display wording — not a change to master-data field definitions.

    Recommended actions:

    • Build a cross-category synonym map to canonical display terms and have pages and help centre cite it instead of separate wording
    • Version map changes and sync translations; align names only, do not rewrite existing fact values
  • Write use cases, exclusions and compatibility limits as verifiable facts

    Copy such as 'suitable for everyone' or 'universally compatible' cannot be verified by an agent and tends to conflict with the spec table. The content layer rewrites scope into checkable conditions and exclusions; it is human-written and can keep growing, with re-scan acceptance based on consistency with the specs.

    Recommended actions:

    • Add three fact blocks to priority categories — use cases, exclusions, compatibility limits — citing concrete parameters from the spec table rather than unbounded adjectives
    • On re-scan, confirm the blocks do not contradict the spec table or structured data; log an update date and owner for each new fact
  • Label market-specific claims in multilingual content

    Delivery coverage, warranty or promotions often apply to one market only, and translation or locale reuse turns a regional limit into a global claim. Add a market qualifier to such copy at the content layer; human-written and continuously expandable.

    Recommended actions:

    • Mark market-specific copy with its applicable market and keep the same limit in every language; do not let machine translation erase it
    • On re-scan, confirm the limit matches the help centre and structured-data region fields; log an update date for each new limit
  • Verifiability checks and sampling ratio for content entries

    Human-written content still needs to be verifiable. Require every fact to point back to a source or spec table at the content layer and sample at a fixed ratio, so more entries do not mean less trust.

    Recommended actions:

    • Give every fact a checkable source (spec table / official page), sample at a fixed ratio and log failures
    • Fix content before publishing on a failed sample; never skip sampling to hit a batch deadline
  • Separate author, verifier and update date in content records

    As entries grow, who wrote, who verified and when it was updated blur together. Record the three roles and the date separately at the content layer so responsibility stays traceable.

    Recommended actions:

    • Record author, verifier, update date and source per entry; complete all four before publishing
    • Return failed verification for rewrite; never let the author self-verify to hit a batch deadline
  • Prioritise content backfill as the item count grows

    Filling all 18 sections at once is unnecessary; low-traffic ones can queue. Order the backfill by traffic / inbound citations at the content layer, with a visible queue, as a continuous action.

    Recommended actions:

    • Order the per-section backfill queue by traffic / inbound citations, keep it filed and update per batch
    • Low-traffic sections wait in the queue without padded entries; flat numbers are recorded, not a reason to pivot or spend
  • Never publish unannounced prices, unreleased products or internal policy

    Human-written copy most easily leaks internal information onto public pages. Make public-facts-only a pre-publish check at the content layer to avoid premature disclosure.

    Recommended actions:

    • Before publishing, confirm every fact is already public; no unannounced prices, unreleased items or internal policy
    • Route doubtful content to a pending list instead of publish-then-fix; log update date and verifier as usual
  • Rewrite installation, usage and care as stepwise content

    Installation, usage and care instructions often ship as images or long prose that an agent cannot extract into executable steps. Rewrite them as ordered steps with prerequisites and completion criteria for easier citation and checking.

    Recommended actions:

    • Rewrite installation and care for key products as ordered steps, each with prerequisites and an expected result.
    • Write tool, consumable and environment steps as verifiable facts, without unlabelled market limits or internal assumptions.
  • Keep an expiry-review queue for content entries

    Content is often written and never revisited, leaving stale specs and promo copy online. Label entries with effective and expiry dates so they enter a review queue automatically.

    Recommended actions:

    • Give fact-heavy entries an expiry date; ones not reviewed by then come off display without deleting the record.
    • After review, update the effective date and source; keep the old version in the changelog instead of silently erasing it.
  • Write cross-market spec differences as verifiable facts

    Reusing one copy worldwide hides unit, size or voltage differences. Write per-market differences as verifiable facts rather than translating one sentence.

    Recommended actions:

    • Label key specs with units and applicability per market, citing source and effective date for differences.
    • Do not publish prices for unreleased markets or present one market's promise as universal.
  • Split long content into short sections with citable summaries

    Long walls of text are hard to crawl and cite. Split explanations into short, headed sections, each with a one-sentence stand-alone summary that agents can quote and maintainers can update.

    Recommended actions:

    • Give each short section a descriptive heading and open with a stand-alone one-sentence summary.
    • Put frequently-changing facts in their own section so a small update doesn't require rewriting the whole page.
  • Give knowledge entries structured summaries and entity labels for easier citation

    Label key facts of each entry (scope, version, owner) in a structured way so agents can extract and cite them and maintainers can update them.

    Recommended actions:

    • Open each entry with a fixed-shape summary sentence covering scope, version and source.
    • Keep entity names consistent site-wide so the same object isn't called by many names.
  • Label sources and owners on knowledge entries; don't write unverified conclusions

    Citable content must be traceable to a source and maintainer. State the basis and update time; mark unverified info as pending rather than presenting it as a conclusion.

    Recommended actions:

    • Label each entry with its source system, basis and maintainer.
    • Mark unverified info as pending, not a conclusion, and leave a trace on updates.
OPT-6 Policy layer21 item(s)

Legal and compliance — review-gated

Carriers:Tools: terms and labelling checks; Skill: comparison checklists; KB: compliance wording and review process.

  • Compliance labelling and accessibility basics

    Terms hidden behind JS, forms with only placeholders, or fabricated review counts make agents distrust the site or trigger Rich Result errors.

    Recommended actions:

    • Complete returns / tax / privacy policies per market, keep policy pages directly crawlable, and give form controls real labels
    • Check contrast and keyboard reachability against WCAG AA with axe / Lighthouse; only ever publish real review counts

    View detail

  • A review-gated process for review authenticity and credentials / tax labels

    Treating compliance as a one-off check lets it drift back fast: reviews, credentials and tax labels change with every new product and market. It needs a named reviewer and a release log, not a single fix.

    Recommended actions:

    • Show only genuine reviews and real counts, complete credentials and tax labels per market, name a reviewer and keep a record of every approval
    • Make crawlable policy pages, real review counts and complete labels a fixed pre-listing gate, with periodic spot checks rather than a single launch-time check

    View detail

  • Review compliance fields in structured data

    aggregateRating, offer and return-policy fields that disagree with visible page content trigger Rich Result errors and make agents distrust the site.

    Recommended actions:

    • Keep review counts, prices and return policy in structured data sourced from the visible page; omit a field rather than inventing it
    • Spot-check structured data per template and route the errors into the pre-listing review gate

    View detail

  • Privacy terms and the agent-crawl boundary

    A blanket no-crawling clause blocks legitimate shopping agents too. Separate public product facts, private account data and crawl rate, and state what is readable.

    Recommended actions:

    • State in the terms, robots.txt and llms.txt that public product facts are readable while account / checkout / internal search are not
    • Spell out data use and a contact channel; keep the policy page directly crawlable, not behind a JS modal

    View detail

  • Keyboard reach, form labels and multilingual reading order

    Contrast may pass while the keyboard cannot reach add-to-cart, or a missing lang attribute leaves agents and screen readers with the wrong reading order.

    Recommended actions:

    • Make every control keyboard-reachable with a real label, and keep focus order aligned with visual order
    • Set correct html lang and dir per locale; do not mix languages in one unmarked container

    View detail

  • Versioned compliance records and review cycles

    Changing terms without keeping the old version and effective date leaves no record of what applied at a given time, and with no review cycle nobody notices new rules.

    Recommended actions:

    • Version every terms/label change with effective date and reviewer, archiving rather than overwriting the old text
    • Set a fixed review cycle per market and log conclusions alongside changes in the changelog

    View detail

  • Record approval, owner and rollback point for each remediation change

    Once a change lands in config, templates or master data, the team needs to answer who approved it, who shipped it, and where to roll back to. This institutionalises the register — it does not issue a compliance verdict for any site, nor replace a concrete re-scan.

    Recommended actions:

    • For each remediation record scope, approver, implementer, rollback point and re-scan owner; keep config-layer and template-layer changes in separate entries
    • Link the register to the changelog and review 'recorded but not verified' items at the quarterly review — a register entry is not proof of a passed re-scan
  • Set retention and audit rules for agent access logs

    Access logs are how you trace who changed a config and when something was crawled, but retention, access and which fields are kept must be decided first. This institutionalises that rule — it collects no private site-owner data and issues no verdict on any site.

    Recommended actions:

    • Define retention, access roles and a minimal field set (time, path, UA, status) without recording private site-owner business data
    • Put log queries on the periodic audit checklist and verify expiry cleanup; version changes to the logging rules
  • Register attribution and update ownership for third-party data references

    When content cites external specs, public benchmarks or platform docs, the team must be able to answer where it came from and who keeps it current. This institutionalises that register — it does not replace per-item verification, nor treat citations as owned data assets.

    Recommended actions:

    • For each external citation record source, citation date, owner and review cycle; link the source rather than inlining a copy
    • On upstream updates the owner assesses impact and leaves a trace, updating the citation note only — never rewriting historical conclusions
  • Set out the allowed scope and liability boundary for third-party agent access / purchasing in the terms

    When an external shopping agent browses, compares or even orders on a user's behalf, terms that say nothing about it leave both the merchant and the user unsure when price is final and who is liable. This is a review-gated, policy-layer item: it only registers what legal needs to confirm and how it is filed; it does not issue a compliance verdict for the merchant.

    Recommended actions:

    • Put on the review checklist: whether third-party agents may access / purchase, that price and stock are final at order confirmation, and how liability and disputes are assigned — publish only after legal sign-off
    • File the terms version and effective date and put them on a review cycle; the knowledge base does not declare a merchant compliant or non-compliant
  • Register exceptions and alternative paths for pages that cannot meet the standard

    Some pages cannot meet an accessibility or compliance baseline in the short term. The policy layer is review-gated: register the exception, the alternative access path and a review date. This entry only fixes what gets filed; it does not issue a compliance verdict.

    Recommended actions:

    • List page, reason, alternative access path, owner and review date in the exception register, filed after review sign-off
    • Remind before the review date and file the outcome; the knowledge base does not declare a merchant compliant or non-compliant
  • A policy-layer change passes only with three records in place

    A live page does not mean a policy-layer change is done. Acceptance is three records together: legal sign-off, effective date and review date; missing any one fails it.

    Recommended actions:

    • Add the three-record check to the release checklist and return the change if any is missing
    • Keep the records in one fixed, retrievable location; a live page is not proof of completion
  • Archive legal review opinions and fix who may answer externally

    Opinions in chat threads and anyone free to explain them externally undermine the policy layer. Fix where opinions are filed and who may answer externally; the review gate stays.

    Recommended actions:

    • File opinions by terms version with confirmer, date and scope
    • Only the designated role answers externally from filed opinions; the knowledge base issues no compliance verdict
  • Tier review scope by change risk

    A full review on every policy-layer change breaks the cadence. Tier light vs full review by risk at the policy layer with fixed criteria, never relaxed on the spot.

    Recommended actions:

    • Define risk tiers and matching review scope (light / full), with tiering criteria on the checklist
    • Log tier changes; never downgrade a high-risk change to light review to meet a deadline
  • Access control and tamper-evident filing for review records

    If anyone can edit a review opinion, policy-layer filing means nothing. Give review records access control and append-only filing at the policy layer; register the rule only, no compliance verdict.

    Recommended actions:

    • Restrict review-record access by role, append-only history with confirmer and timestamp
    • Spot-check filing integrity periodically; the knowledge base issues no compliance verdict
  • An intake and response flow for challenges to public statements

    The terms may state the scope of agent access and proxy ordering, but without an intake and response flow for challenges to those statements, they can never be tested or corrected.

    Recommended actions:

    • Register an intake channel, owner and response deadline for challenges to public statements, and archive each response.
    • When a challenge reveals a wording error, correct it through the changelog rather than silently editing a number.
  • Mark effective intervals when a policy is retired, keeping the old version queryable

    Policy rewrites often overwrite in place, leaving old commitments unverifiable. On retirement or revision, mark the effective interval and keep the prior version queryable.

    Recommended actions:

    • Register effective and retirement dates per version; show only the current one, keep archived versions queryable by interval.
    • Answer disputes using the version in force at the time, without issuing a compliance verdict or rewriting history from a single fetch.
  • Register applicable privacy and consumer policy versions per market

    One shared policy across markets ignores local differences. Register the current version and effective interval per market and display the matching one.

    Recommended actions:

    • Bind each market to its current policy version and effective date; archive old versions by interval.
    • State the scope of third-party agent access per market in the terms, without issuing local-law compliance verdicts.
  • Keep terms and policy pages lightweight and crawlable, with clear version ranges

    Terms, privacy and returns policies must be both crawlable and traceable: plain server-rendered text with explicit versions and effective ranges. Don't let fancy layout hide them from agents, and don't issue a compliance verdict here.

    Recommended actions:

    • Server-render policy text as plain text, mark the current version and effective date, and keep old versions retrievable.
    • Publish only after legal review; this item addresses crawlability and traceability, not a compliance verdict.
  • Mark structured versions and conditions on policy pages, without a compliance verdict

    Structured version info on terms and privacy pages aids traceability. This item only describes machine-readable version labels; publish after legal review and issue no compliance verdict.

    Recommended actions:

    • Use fixed fields for version, effective date and scope, keeping old versions retrievable.
    • Publish only after legal review; this item describes traceability, not a compliance verdict.
  • Mark source and review status on policy pages, without a compliance verdict

    Privacy and terms info should expose review status for traceability. This item only describes machine-readable source and status labels; publish after legal review, with no compliance verdict.

    Recommended actions:

    • Label policy source version and review status, keeping old versions retrievable.
    • Publish only after legal review; this item describes traceability, not a compliance verdict.

Operations · Technical

How to keep things running and watched after the changes. Six sections organised by time scale / trigger; entries are recurring actions and on-call duties.

OPS-1 Daily checks (with the batch run)21 item(s)

Availability, 5xx/TTFB trends, crawl errors, price consistency, stock write-back

Carriers:Tools: reuse the daily batch diff; Skill: a daily review checklist; KB: what counts as an anomaly vs noise.

  • Review the daily batch results

    Day-over-day 5xx and TTFB shifts, crawl-error spikes and feed/landing-page price mismatches usually appear before traffic drops.

    Recommended actions:

    • Follow trends from one vantage only; never compare absolute values across vantages (KR vs CN)
    • Classify feed-window drop-outs separately — never count them as delistings or price changes; the event carries no information

    View detail

  • Same-day availability review of key pages with an exception log

    The batch gives trends; on-call work is whether these key pages are still reachable today. An exception without context cannot be judged as a blip or a sustained problem tomorrow.

    Recommended actions:

    • Spot-check availability and HTTP status of the homepage, category, key product and checkout pages daily, compared with yesterday from the same vantage
    • Log site, vantage, time and previous baseline for each exception, classify one-off blips separately, and never change definitions or re-run to force a green result because of a single day numbers

    View detail

  • A daily checklist and on-call handover log

    Ad-hoc reviews miss items and lose all context on handover. Fix the pages to check, the comparisons to make and the fields to log in one checklist.

    Recommended actions:

    • Keep a fixed checklist of key pages, same-vantage comparisons, price/stock consistency and crawl errors, ticked item by item
    • Log open exceptions and the previous baseline at handover; do not skip the record just because nothing fired

    View detail

  • Bucket crawl errors by type

    404, 5xx, timeouts and robots blocks are four different problems; one combined crawl-failure number gives on-call no idea who to call.

    Recommended actions:

    • Break errors down by status code and cause, and follow each bucket trend rather than the total
    • Handle blocked requests separately by checking robots/CDN rules; do not mix them with site outages

    View detail

  • Daily sampling of price / availability consistency

    Full comparison is costly, but sampling a few SKUs daily across all four surfaces catches a missed feed refresh before it spreads.

    Recommended actions:

    • Sample a fixed set of SKUs daily and compare amounts and availability across detail page, cart, checkout and feed
    • Log mismatches and locate the cause (master data, template or stale feed) instead of editing numbers to hide them

    View detail

  • Third-party dependency status checks

    When a payment gateway, CDN or tracking API is down, our pages still return 200 while the flow is broken — self-only availability checks miss it.

    Recommended actions:

    • Include key third-party endpoints in daily checks with their own status and error codes, separate from our availability number
    • On third-party incidents, record the blast radius (which pages / steps) and follow the provider SLA

    View detail

  • Daily diff of new/removed listings against the feed

    Beyond the daily batch, the daily check should watch the catalogue itself: whether SKUs added yesterday or removed today are reflected in the feed and sitemap. This is not re-running to turn things green — it is a same-day review of a diff list, with a trace left behind.

    Recommended actions:

    • Produce a diff of added / removed / status-changed SKUs and check it against the day's feed and sitemap versions; log discrepancies in the handover note
    • Review set changes only — do not re-run historical batches because a daily reading moved; route discrepancies to the owner instead of editing master data yourself
  • Daily spot-check of product-page rendering from an agent's view

    Page availability only answers 'does it open'. This adds 'are the core fields there'. Sample a few product pages daily with JS disabled and check title, price, stock and identifiers are readable; log discrepancies the same day, without re-running to turn things green.

    Recommended actions:

    • Sample N product pages per category daily via JS-disabled fetches and log any missing core fields in the handover note
    • Record that day's sample only — do not re-run historical batches because a reading moved; route missing fields to the template owner
  • Daily spot-check that structured-data markup parses

    JSON-LD in a template does not stay valid forever — one template change can drop fields or break syntax. Parsing markup on a few pages each day catches it faster than waiting for external feedback, and it is a same-day check that never rewrites historical data.

    Recommended actions:

    • Parse JSON-LD on one home, one category and one product page daily, checking required fields and types; bucket anomalies by type
    • Check that day's sample only — no bulk re-parsing of historical snapshots, no re-running to turn things green; log parser-definition changes in the changelog
  • Daily check that declaration files are reachable and unchanged

    When a release, a CDN rule or a mistaken edit overwrites robots.txt, llms.txt or .well-known/ucp, pages still open normally while agents go blind. Treat these as separate daily inspection objects alongside the batch; log anomalies without auto-rewriting them.

    Recommended actions:

    • Fetch the declaration URLs daily and compare status, content hash / key sections with the previous day; log any exception
    • Record differences without auto-rewriting; keep expected release-window changes separate from unexplained drift, and do not re-run to force a green result
  • Daily spot-check whether yesterday's accepted changes regressed

    A change that passed on release day is often overwritten by a cache, a CDN rule or the next release. Sample a few of yesterday's accepted items daily and re-check them; record the result without auto-rollback.

    Recommended actions:

    • Re-check a sample of yesterday's accepted changes against the same criteria daily and record pass / regression with URLs
    • Log regressions and hand them to change management; do not re-run to force green or auto-edit config
  • Fix daily inspection sample sizes and anomaly thresholds

    Sample sizes that float with how busy the day is make the daily series incomparable. Fix sample sizes and anomaly thresholds on the inspection side and log changes only, so readings do not drift with effort.

    Recommended actions:

    • Fix sample sizes, anomaly thresholds and verdict rules per check in one list; log changes in the changelog
    • No same-day sample padding or threshold loosening; flat numbers are recorded, not a reason to pivot or spend
  • Handover windows and default handling for unread anomalies across timezones

    Across timezones an anomaly can sit unread in the handover gap. Fix handover windows and a default escalation rule for unread anomalies on the inspection side, without depending on live chat.

    Recommended actions:

    • Fix handover windows and handover form fields; carry every open anomaly forward with a receipt
    • Escalate unread anomalies in the window by a default rule; silence is not evidence of health
  • Tiered sampling as inspection items grow

    Running every inspection item daily stops being realistic as they grow. Split core checks (daily) from secondary ones (rotating) in daily inspection, with a fixed tiering rule.

    Recommended actions:

    • Split checks into core (daily) and secondary (rotating) with a fixed rotation and sample size
    • Log tier changes; never demote a core check to rotating to save effort
  • Tier access to inspection results

    Inspection details often contain internal paths and anomaly detail that a public status page should not copy. Split public-status-only from on-call-only detail in daily inspection.

    Recommended actions:

    • Public pages show health status and update time only; anomaly details / internal paths stay in the on-call view
    • Log permission changes; never copy details onto a public page for convenience
  • Sample one external agent's crawl daily and compare with our declaration

    Testing our own declaration files only proves the file exists and reads correctly; what an external agent actually sees may differ. Each day, sample one agent and compare its result against our declaration item by item.

    Recommended actions:

    • Sample one agent entry point daily and record whether the fields it reads on key product pages match the declaration.
    • Log any mismatch with its date first, check it against the agreed definitions before treating it as an anomaly, and avoid drawing conclusions from one reading.
  • Archive inspection logs by retention window and purge raw logs when expired

    Daily inspection logs pile up; keeping every raw record forever is unnecessary. Archive by retention window — detailed recent logs, desensitised conclusions for older ones.

    Recommended actions:

    • Label inspection records with date and retention window; after expiry keep only the anomaly conclusion and resolution.
    • Purge raw logs containing personal data or internal IDs on expiry; archived items carry the same access tier as inspection results.
  • Sample key pages per market in daily inspection, not only the default one

    Inspecting only the default market leaves regional page issues invisible. Sample a few pages per market daily, covering main languages and currencies.

    Recommended actions:

    • Fix the sample page set and volume per market; log differences by market rather than merging them into one total.
    • On a mismatch, check snapshot date and source first, then decide against the agreed definition whether it is an anomaly.
  • Include compression and cache config in availability checks; watch TTFB trends

    A single bad header can slow or break site-wide crawling. Fold compression and cache checks into daily availability monitoring and watch TTFB as a trend, without concluding from a single blip.

    Recommended actions:

    • Periodically sample key pages for expected compression and cache headers and log anomalies in the inspection record.
    • Watch TTFB as a trend, not a single point; if numbers don't move, just record them — don't change direction or add spend.
  • Fold structured-data and semantic-structure errors into availability checks

    Parse failures or missing semantic tags hurt agent understanding. Fold them into daily availability checks and watch them as a trend, without concluding from a single blip.

    Recommended actions:

    • Periodically crawl key pages to verify structured data parses and semantic tags are present; log anomalies.
    • Watch error counts as a trend; if numbers don't move, record them as-is — don't change direction or add spend.
  • Fold certificate expiry and TLS errors into availability checks

    An expired certificate or bad TLS config breaks both crawling and access. Fold them into daily availability checks and watch as a trend, without concluding from a single blip.

    Recommended actions:

    • Periodically check certificate validity and TLS config; log anomalies.
    • Watch as a trend; if numbers don't move, record them as-is — don't change direction or add spend.
OPS-2 Periodic review (weekly / monthly)21 item(s)

Coverage and index growth, CWV percentiles, launch cadence, competitor-wide repricing

Carriers:Tools: aggregation and percentile stats; Skill: weekly/monthly review templates; KB: metric definitions and baselines.

  • Monthly field-coverage and CWV percentile report

    Single readings are noisy; monthly percentiles and coverage deltas are what carry signal.

    Recommended actions:

    • Measure field coverage per category and prioritise low-coverage categories for the next backfill
    • Use CrUX monthly percentiles for CWV rather than one Lighthouse score; allow at least a week after a change before judging it

    View detail

  • Weekly / monthly review of index growth and launch cadence

    Many new listings with no index growth points to a template or feed problem; looking at index totals without launch cadence mistakes no new listings for lost indexation.

    Recommended actions:

    • Track daily new listings alongside newly indexed ones; separate few listings added from added but not indexed
    • Correlate index changes with release windows and template edits to see whether we caused them; never conclude from a single crawl

    View detail

  • Periodic watch on competitor-wide repricing

    A single discounted item is noise; a store- or category-wide repricing can shift our own baseline. Reviews must tell the two apart.

    Recommended actions:

    • Measure how broad a competitor price change is per category; only widespread moves enter the pricing-baseline discussion
    • Log the observation window alongside the magnitude so a one-off promo is not mistaken for a trend

    View detail

  • Review launch cadence and content capacity

    Flat index growth sometimes just means no listings or copy shipped that week. View capacity alongside indexation so it is not misread as a site fault.

    Recommended actions:

    • Log weekly new listings, content items and newly indexed pages in one table
    • When capacity drops, schedule more content first instead of changing crawling or templates to chase a phantom index problem

    View detail

  • Cross-month comparability of percentile definitions

    A changing sample size or CrUX percentile can move the monthly curve without anything on the site changing. Confirm the definition first.

    Recommended actions:

    • Fix the percentile, sample size and data window in the review table and log any change in the changelog
    • Never directly compare two months with different definitions; mark them not comparable rather than plotting one line

    View detail

  • Quarterly goals and stage-criteria review

    Reviews drift into monthly metric tuning. Checking the line against its stage criteria — continue or stop — matters more than optimising one number.

    Recommended actions:

    • Each quarter, map review conclusions to the stage criteria and state continue / adjust / stop with reasons
    • When a criterion is unmet, follow the agreed action; do not add spend or change direction just because numbers are quiet

    View detail

  • Monthly report on re-scan pass rate and remaining gaps

    Add a monthly view that tracks the OPT loop: how many remediations were logged, how many passed a re-scan, and which gaps remain. It counts actions and verification states — it does not conclude from a single measurement or compare absolute values across vantages.

    Recommended actions:

    • Summarise actions per OPT-1..6 layer into logged / passed / unverified / rolled-back, listing gaps by section and owner
    • Report actions and verification states only — no 'pass/fail' verdict; note any definition change in the changelog so months stay comparable
  • Monthly inventory of content coverage gaps and per-section progress

    When filling content section by section it is easy to count additions and miss which sections are still thin. A monthly inventory of per-section item counts and gaps exists to plan which sections to fill next — not to treat item count as a quality verdict.

    Recommended actions:

    • List item counts and obvious gaps per OPT/OPS/BIZ section and flag which sections to fill next
    • Record coverage only — do not turn item counts into a pass/fail verdict; log inventory-definition changes in the changelog
  • Monthly log of external citations and inbound references (record only)

    Counts like inbound references or external mentions may stay at or near zero for a long time early on; the monthly report simply records them to keep a traceable timeline. State the facts and the next scheduled action — do not change direction, add spend or hunt for 'growth hacks' because the numbers did not move.

    Recommended actions:

    • Log this month's inbound references/mentions with sources, forming a time series with prior months — counts only, no conclusions
    • Keep executing the scheduled content and external-tracking work; do not add spend, change direction or re-run to turn things green when the figure is flat or zero
  • Monthly review of remediation mix and post-re-scan stability

    Each month, list change counts by OPT-1..6 and whether they still pass on re-scan. This is distribution and stability only: flat numbers are not a signal to change direction or add spend. When numbers do not move, record them as they are — no pivot, no extra investment, no growth stimulus.

    Recommended actions:

    • Count changes, re-scan passes and regressions per section for the month; record and file only
    • When readings stall, archive as usual without changing direction or adding spend; log distribution shifts separately from definition changes
  • Monthly log of sites / categories left out of the batch

    Some sites or categories are not yet in the batch, and they sit inside the coverage denominator. List those gaps with reasons monthly; record only, do not pad the sample, and do not change direction or add spend because of them.

    Recommended actions:

    • List sites / categories not in the batch with reasons and mark them pending, without padding the sample
    • When numbers stall, archive as usual; no pivot, no extra spend, no growth stimulus
  • Fix denominators in the monthly report and log denominator changes

    Ratios like coverage or pass rate move when the denominator moves. Put every denominator in the monthly report header and log denominator changes separately, so a definition change is not read as a performance change.

    Recommended actions:

    • State numerator / denominator definitions in the report header and log denominator changes on their own line
    • Compare periods only where denominators match; log definition changes separately from real changes
  • State the audience and purpose in the monthly report header

    One monthly report serves people making decisions and people merely filing it. State audience and purpose in the header during periodic review so record-only data is not mistaken for a decision basis.

    Recommended actions:

    • State audience, purpose (decision / record) and reviewer per metric in the header
    • Record-only metrics carry no suggested actions; decision metrics carry a conclusion and a trail
  • Trim and archive metrics as the monthly report grows

    Metrics pile up while only a few drive decisions. Keep the decision-relevant ones in periodic review and archive the rest rather than discarding them, so the report does not become a log.

    Recommended actions:

    • Tag each metric decision / record / archive; move archived ones out of the body but keep their history
    • Trimming changes presentation only, not definitions; definition changes still go to the changelog
  • Desensitise the external version of the monthly report

    Publishing the monthly report as-is exposes site detail and business definitions. Split internal and external versions in periodic review; the external one keeps aggregates and definitions only.

    Recommended actions:

    • Keep only aggregate metrics, definitions and time range in the external version; strip site detail and account info
    • No merchant-private data, no third-party ingestion; generate both versions from one source and log the diff
  • List planned-but-skipped items in the monthly review with reasons

    Monthly reports usually list only what was done; planned-but-skipped actions disappear. Listing them separately with reasons distinguishes a deliberate cancellation from a miss.

    Recommended actions:

    • Keep a standing "planned but not done" column and mark each as cancelled by judgement, blocked by a dependency, or simply missed.
    • Move missed items into the next cycle; when numbers have not moved, record that fact without adding spend or hunting for growth hacks.
  • Keep a monthly-report archive index for cross-period review

    Monthly reports scatter after sending, and the definitions in force at the time are hard to find later. Keep an archive index that maps each month to its report and definition version.

    Recommended actions:

    • Register month, definition version and audience for each archived report; index only publicly citable items.
    • When numbers did not move, record that honestly in the archive too — no retroactive flattering explanation; mark comparability in the index.
  • Split monthly metrics by market instead of merging into one total

    A combined multi-market total hides real changes in any one market. List metrics by market and compare trends only under a consistent definition.

    Recommended actions:

    • List key metrics and denominators per market; present markets side by side without absolute-value comparison.
    • When one market's numbers did not move, record that fact without adding spend or hunting for growth hacks.
  • Track page weight and crawl budget alongside coverage, using percentiles

    Heavier pages burn crawl budget faster and delay discovery of long-tail URLs. Watch average and percentile page weight together with long-tail index growth, judge by percentiles not single points, and record flat numbers as-is.

    Recommended actions:

    • Log key-page weight and long-tail index growth by percentile; flag anomalies without concluding from a single reading.
    • If numbers don't move, record them as-is — don't change direction, add spend, or hunt for growth hacks.
  • Track structured-data coverage alongside overall coverage, using percentiles

    How many key pages carry valid structured data affects long-tail discovery and citation. Judge by percentiles not single points, and record flat numbers as-is.

    Recommended actions:

    • Track the share of key pages with valid structured data by percentile; flag anomalies without concluding from a single reading.
    • If numbers don't move, record them as-is — don't change direction, add spend, or hunt for growth hacks.
  • Track the effect of security incidents on coverage, using percentiles

    Security incidents such as certificate errors or flags can affect crawling and indexation. View them alongside coverage percentiles, and record flat numbers as-is.

    Recommended actions:

    • Log security incidents alongside coverage percentiles; flag anomalies without concluding from a single reading.
    • If numbers don't move, record them as-is — don't change direction, add spend, or hunt for growth hacks.
OPS-3 Change management (event-driven)21 item(s)

Pre/post-release re-scans, release windows, rollback artefacts

Carriers:Tools: pre/post-release diffs; Skill: regression checklists; KB: release process and rollback SOP.

  • Re-scan and regression-test around releases

    Template, routing and bulk price changes are the most likely to reintroduce issues already fixed.

    Recommended actions:

    • Keep a baseline of key pages before release, then re-scan homepage, category and key product pages afterwards
    • Retain rollback artefacts; after bulk price changes force a feed refresh and compare all three amounts

    View detail

  • Release windows and rollback artefact management

    Whether a bad change can be rolled back in one step depends on keeping a fully restorable artefact before release and a defined window. Ad-hoc edits without a rollback artefact make recovery time unpredictable.

    Recommended actions:

    • Package templates / routes / dictionaries / data files into one swappable artefact; keep a dated, verified-restorable rollback copy before each release
    • Fix release windows and avoid one-off production edits outside them; log which files changed each time and roll back by swapping the whole artefact, not by patching files individually

    View detail

  • Regression scope for payment / logistics / platform changes

    When an upstream changes fees, tracking-number formats or feed specs, we are affected passively. Define which pages to regression-test before release instead of re-testing everything.

    Recommended actions:

    • Name the affected tools, checklist items and pages in the change ticket and scope regression from that dependency map
    • Re-test only the affected surface and log the result; do not re-run the full suite for a single upstream change

    View detail

  • Ship data files and dictionaries with the release artefact

    Pages read JSON from fs at runtime; missing files in the artefact show raw keys or blanks, and this only surfaces after release.

    Recommended actions:

    • List data/*.json and messages/*.json explicitly in the release manifest and verify they are present after packaging
    • After release, spot-check a page that reads at runtime and confirm it renders copy, not raw keys

    View detail

  • Rollback drills and recovery-time checks

    Having a rollback artefact is not the same as being able to roll back. Without a drill, missing dependencies or recovery time surface only during an incident.

    Recommended actions:

    • Drill a full-artefact rollback in staging periodically, log the time and missing dependencies, and update the release manifest
    • Set an explicit recovery-time threshold; if a drill exceeds it, fix the process before the next release

    View detail

  • Changelog and public verifiability

    When definitions, fields or taxonomies change, outside readers need to see when, or old conclusions keep being cited.

    Recommended actions:

    • Log every change that affects public readings in a date-ordered changelog on an anonymously readable route
    • State effective date, scope and where the old version went; never rewrite historical entries

    View detail

  • Use different re-scan regression sets for config vs template changes

    A single regression suite should not cover every release: a robots/CDN config change needs crawl-reachability and header checks, while a template change needs output-field and structured-data checks. Picking the regression set by which layer changed avoids pointless re-scans and localises regressions faster.

    Recommended actions:

    • Group re-scan cases by config / template / data layer and select the matching group on the release ticket instead of running everything by default
    • For cross-layer changes add the adjacent layer's cases; log changes to the regression set itself so the next release does not reuse a stale list
  • Define observation windows and rollout gates for staged releases

    Rolling a template or config change to 100% at once maximises regression blast radius. Change management fixes the canary share, observation window and rollout/rollback gates first, so 'keep rolling' has a checkable precondition rather than a hunch.

    Recommended actions:

    • State canary share, observation length, rollout metrics and rollback triggers on the release ticket; freeze other changes during the window
    • Before scaling, check the matching re-scan regression set; if gates fail, hold or roll back rather than re-running to turn things green
  • Define which changes can be hot-applied and which need a release

    Config, dictionary and template changes take effect differently: some apply on file write, others are baked into the build. Writing down this boundary in change management prevents 'changed but no effect' being misread as a regression — and prevents silently hot-applying something that needed a release.

    Recommended actions:

    • List how data files, dictionaries, templates and code take effect and whether a rebuild is needed; the release ticket follows this list
    • After a hot update, confirm via an anonymous read; log changes to the boundary rules so the next release does not reuse a stale convention
  • Put schema / seed changes on the release checklist with a rollback order

    Shipping a new artefact without seeding means DB-backed detail pages 404 and deep links go dead. Put DB changes alongside the static artefact in change management: back up first, apply in a compatible order, keep rollback reversible, and re-check anonymous reads on DB-dependent routes after deploy.

    Recommended actions:

    • List the schema / seed changes, apply order, backup point and rollback steps on the release checklist; ship artefact and data together
    • After deploy, verify anonymous reads on DB-dependent routes; on failure roll back as a whole rather than patching live data by hand
  • Pause conditions and recovery criteria when external dependencies are unhealthy

    Releasing while a payment, logistics or platform dependency is down makes regression results meaningless. Define pause conditions and post-recovery re-run criteria in change management so incident-window data is never used as acceptance evidence.

    Recommended actions:

    • Check dependency health before a release; if a pause condition hits, delay and log, then re-run the original checklist after recovery
    • Label readings from the incident window as not valid for acceptance; do not re-run to force green
  • Define release 'pass' as three checks together

    A page that opens is too weak. Define release acceptance as three checks together: anonymous reads on key routes, expected data row counts, and a usable rollback artefact; missing any one fails it.

    Recommended actions:

    • List the three checks and their pass standards on the release checklist; all three are required
    • On any failure, roll back as a whole rather than patching data or pages to hide it
  • Signing roles and their confirmations on the release checklist

    After a bad release nobody can say who confirmed what. Split the checklist confirmations across dev, data and ops roles in change management, each with a signature.

    Recommended actions:

    • Split the checklist by role (artefact / data and seed / service and rollback) with a signature each
    • No release without every signature; post-release review uses the record, not memory
  • Batch release windows and checklist reuse as release frequency rises

    Several releases a day each written from scratch lose items. Batch similar releases into windows in change management and reuse a standard checklist, logging only deltas.

    Recommended actions:

    • Fix batch windows and a reusable standard checklist; log only deltas and confirmers per batch
    • Log out-of-window emergency releases separately and backfill the checklist; never skip sign-off for frequency
  • Keep env files, secrets and debug config out of release artefacts

    Packaging env files, secrets or debug flags publishes the config. Put an artefact scan on the release checklist as a fixed item in change management.

    Recommended actions:

    • Scan artefacts for env files, secrets and debug flags before release; block and rotate on a hit
    • Keep the check on the release checklist with its result; secrets never enter chat, logs or git
  • Confirm temporary flags are cleared after a change window

    Gray releases and hotfixes often add temporary flags or skip switches. If they survive the window, they become long-lived hidden branches nobody remembers, skewing future re-scans.

    Recommended actions:

    • Register an expiry window and an owner for each temporary flag, and confirm removal when the window closes.
    • Add a final "temporary items cleared" step to the release checklist; anything kept must be re-registered as permanent config.
  • Archive release checklists with rollback artefacts and state retention and cleanup conditions

    Checklists live in chat threads and rollback artefacts get cleaned up, so reverting to a prior release becomes impossible. Archive the checklist and rollback artefact together.

    Recommended actions:

    • Record the checklist, artefact version and rollback artefact in one archive entry with a retention window.
    • Before expiry, check for remaining references; purge a rollback artefact only after confirming no rollback need, not on a hunch.
  • List regression scope per market in the release checklist, allowing single-market rollback

    Changing all markets at once enlarges the blast radius and forces an all-or-nothing rollback. List regression scope per market and allow rolling back one market.

    Recommended actions:

    • List each market's regression set and sign-off items in the checklist; ramp per market.
    • A single-market rollback affects only that market's artefact, leaves others untouched, and archives rollback items per market.
  • Add page weight and crawl headers to the pre/post-release re-scan checklist

    After a config or template release, re-scan not just content but whether compression, caching and page weight regressed, and keep a rollback artefact that can revert a single page.

    Recommended actions:

    • Crawl key pages before and after release, compare headers and weight, and log regressions.
    • List per-page revert points in the release checklist and archive the rollback artefact with it.
  • Add structured data and semantic structure to pre/post-release re-scans

    Template edits can break structured data and semantic tags. Crawl and validate before and after each release, and keep a rollback artefact that can revert a single page.

    Recommended actions:

    • Before and after release, verify key-page structured data parses and semantic tags are intact; log regressions.
    • List per-page revert points in the release checklist and archive the rollback artefact with it.
  • Add security items to the pre/post-release re-scan checklist

    Releases can introduce security regressions (HTTPS downgrade, accidentally committed keys). Re-scan security items before and after each release and keep a rollback artefact for single-page revert.

    Recommended actions:

    • Before and after release, verify HTTPS / HSTS / security headers and that built output contains no secrets.
    • List per-page revert points in the checklist and archive the rollback artefact with it.
OPS-4 Alerting and response (threshold-triggered)21 item(s)

Which metrics deserve alerts, severity, false-positive control, response SOP

Carriers:Tools: threshold evaluation (reusing the noise-floor definition); Skill: response steps; KB: severity levels and threshold rationale.

  • Alert severity and false-positive control

    Under the noise-floor definition, alert only on signals that should fire — otherwise alerts are quickly ignored.

    Recommended actions:

    • Limit alerts to availability, price inconsistency and stock conflicts; assign severity and response deadlines
    • Attach context (site, vantage, window, previous baseline) rather than a bare number

    View detail

  • Alert response SOP and escalation path

    An alert nobody owns, or one that is never closed, is no alert at all. Beyond severity, spell out who does what within what time, and when it escalates.

    Recommended actions:

    • For each severity, define the owner, response deadline, response steps and close condition, and archive the closure record
    • Escalate automatically on timeout; forbid re-run until green or lowering the threshold as a response — adjust only under the noise-floor definition

    View detail

  • Periodic recalibration of thresholds and the noise floor

    As scale and traffic change, once-good thresholds drift. Adjust them only under the stated definition, never just to silence an alert.

    Recommended actions:

    • Revisit thresholds and the noise floor monthly against historical distributions; log the rationale and effective date in the changelog
    • Keep calibration separate from response: calibration changes definitions, response fixes the site; never lower a threshold instead of fixing the cause

    View detail

  • Alert de-duplication and aggregation

    One root cause firing dozens of alerts gets ignored. Aggregate by site + root cause, send once, and include the blast radius.

    Recommended actions:

    • Aggregate by site / root cause / time window; repeat events update a counter instead of sending a new notification
    • Include affected page count and first-seen time in the aggregated message rather than making on-call reconstruct context

    View detail

  • On-call rota and escalation contacts

    However good the severity levels, an empty rota or stale contact list leaves night alerts unhandled. Keep the table in sync with people changes.

    Recommended actions:

    • Maintain a current on-call rota and escalation contacts with effective dates and backups
    • Update on every staffing change and run a notification test rather than discovering delivery failures during a real alert

    View detail

  • Post-alert review for every real incident

    Closing an alert without review lets the same root cause fire again. Every real alert should record why it fired, the fix, and whether thresholds need changing.

    Recommended actions:

    • After each real alert, add three lines: root cause, fix, and whether definitions or thresholds need changing
    • Track recurring root causes separately and push a site fix instead of endlessly tuning alerts

    View detail

  • Alert silence during release windows, with post-window catch-up

    Planned changes trip thresholds themselves and can drown out real alerts if not silenced; silence is not discard, so suppressed events must be reported after the window. This is an upfront alerting policy, not retroactively changing thresholds to erase an anomaly.

    Recommended actions:

    • State the silence window, affected rules and catch-up owner on the release ticket; auto-report suppressed events when the window closes
    • Silence only rules tied to the planned change — other rules keep firing; do not absorb anomalies by widening thresholds or re-running
  • Verify alert-channel delivery and fallback paths

    Perfect rules are useless if the channel is down. Response-side work periodically confirms the primary channel delivers and which backup takes over — instead of discovering nobody was notified during a real incident. This checks channels, not thresholds.

    Recommended actions:

    • Periodically verify primary delivery and latency with a test event, and confirm the backup takes over when the primary fails
    • Record channel status and fallback in the on-call roster; route channel changes through change control, not by widening thresholds to reduce alert volume
  • Replay new alert rules against history before enabling them

    Enabling a new rule live means experimenting on a real incident. Replay it against retained historical readings first to see how often it would fire and whether it false-positives, then set thresholds and silence scope. Replay produces no new events and rewrites no history.

    Recommended actions:

    • Replay the rule on retained snapshots, count triggers and false positives, then set thresholds and silence scope before enabling
    • Replay is read-only — no batch re-runs, no history rewrites; register the rule version and replay findings in the changelog
  • Log alert threshold / severity / silence changes and verify their effective scope

    A threshold or silence-window change with no record makes later reading shifts unexplainable, and one edit may silence several rules at once. Log changes to the rules themselves alongside the definition changelog, then sample the effective scope after each change.

    Recommended actions:

    • For every threshold, severity or silence-scope edit, record before/after values, effective time and operator in the change log
    • After the change, sample which rules were actually affected and whether silence ended as planned; backfill missing records instead of re-running historical alerts to force green
  • Distinguish 'no data' from 'everything is fine'

    If a missing batch or data source is treated as no alert, a broken feed reads as a green light. Make missing data its own alert class on the alerting side, separate from threshold alerts.

    Recommended actions:

    • Alert separately on a missing daily series / snapshot with a 'data not arrived' message, not a healthy state
    • Log an arrival record when data resumes; a silent window with no alerts is not evidence of health
  • Log alert response-time percentiles, not blame

    The distribution of time from trigger to claim to closure shows whether the process is adequate. Log percentiles on the alerting side and do not use them for individual performance review.

    Recommended actions:

    • Log claim / closure time percentiles by ticket type with sample size and definition
    • Use them to spot process bottlenecks only; no individual blame, no spend changes on percentile swings
  • Feed alert handling conclusions back to rule owners

    Closing a ticket without feedback leaves the faulty rule unfixed. Send each real-alert conclusion back to the rule owner on the alerting side as an input to rule changes.

    Recommended actions:

    • Classify each conclusion (false positive / threshold fit / missing rule) and send it to the rule owner with a record
    • The handover is an input to rule changes only; no auto threshold edits, and changes go through change logging
  • Alert channel cost and fallback order

    More channels raise both notification cost and noise. Fix a keep-critical-first fallback order and a cost cap on the alerting side instead of stacking every channel.

    Recommended actions:

    • Split channels into critical / supplementary, fix a fallback order and cost cap, and log degrade events
    • Critical channels are never degraded; missed alerts during degradation follow the 'no data' catch-up rule
  • Keep order and personal data out of alert payloads

    Alerts get forwarded across channels; an order ID or user info in the payload spreads with them. Limit alert payloads to route, status and aggregates on the alerting side.

    Recommended actions:

    • Limit alert payloads to route / status / aggregate count / time; no order IDs, names, addresses or emails
    • Link to the on-call view for detail instead of embedding it, and re-check before channel forwarding
  • Run periodic alert drills to verify delivery and response

    A rule that never fires gives no confidence the channel still delivers or that anyone is alerted. Periodically trigger a drill to test the response chain, not to assert a real incident.

    Recommended actions:

    • Run one controlled trigger per key alert each quarter and confirm delivery, on-call response and escalation each complete once.
    • Record drill results separately from real incidents and fix channel decay as a config issue, not as an incident postmortem.
  • Archive alert history by retention window, including conclusions from retired rules

    When an alert rule is retired, its resolution history disappears too. Archive history by retention window so conclusions from retired rules stay queryable.

    Recommended actions:

    • Archive alerts by date and rule; when a rule closes, keep its historical conclusions and closure reason.
    • Archived records carry no order or personal data; keep response time as percentiles, not as individual performance records.
  • Label alerts with affected markets so one market's swing does not page everyone

    A temporary swing in one market should not page the whole on-call team. Label alerts with affected markets and route notifications by scope.

    Recommended actions:

    • Give alert rules a market dimension; notify only the affected market's owner and tier escalation by scope.
    • Alerts carry no order or personal data; market labels use only publicly citable region codes.
  • Set tiered alerts for compression/cache failures and page-weight spikes

    Config failures tend to be sudden. Set tiered alerts for lost compression headers, bad cache headers and page-weight spikes, with false-positive suppression and a response SOP to avoid alert fatigue.

    Recommended actions:

    • Set thresholds and severities for lost compression and cache headers and weight spikes; escalate only on sustained anomalies.
    • Write a response SOP: check recent releases and config changes first, suppress false positives promptly and record the conclusion.
  • Set tiered alerts for structured-data parse failures and missing semantic tags

    Structured-data errors are often introduced by releases. Set tiered alerts for parse failures and missing required fields, with false-positive suppression and a response SOP.

    Recommended actions:

    • Set thresholds and severities for parse failures and missing required fields; escalate only on sustained anomalies.
    • Write a response SOP: check recent releases first, suppress false positives promptly and record the conclusion.
  • Set tiered alerts for certificate expiry and abnormal access

    Impending certificate expiry and abnormal request volumes need prompt response. Set tiered alerts with false-positive suppression and a response SOP to avoid alert fatigue.

    Recommended actions:

    • Set thresholds and severities for expiring certificates and abnormal access; escalate only on sustained anomalies.
    • Write a response SOP: check recent releases and config first, suppress false positives and record the conclusion.
OPS-5 Data and definition upkeep (continuous)21 item(s)

Daily series and snapshots, vantage labels, definition changes, citation readiness

Carriers:Tools: series-integrity checks; Skill: definition-change checklists; KB: changelog and data dictionary.

  • Vantage labels, daily series and a definition changelog

    Once a definition changes, the historical series is no longer directly comparable; before citing anything publicly, confirm the route is actually live.

    Recommended actions:

    • Label every number with vantage and date, keep the daily series unbroken and fields frozen; log definition changes in the changelog
    • Before stating where our data can be checked, confirm that route is actually anonymously readable in production

    View detail

  • Snapshot retention and citation-readiness checks

    A broken historical series cannot be rebuilt, so keep daily snapshots with frozen fields. Before claiming where our data can be checked, confirm that route is truly anonymously readable in production.

    Recommended actions:

    • Archive daily snapshots by date, freeze fields, keep the series unbroken; definition changes apply forward only and are logged in a changelog, never back-applied
    • Before listing a verifiable route in public material, hit the production build once with an anonymous request and confirm it returns data, not a login page or a stale build

    View detail

  • Notifying definition changes and preserving comparability

    A definition change breaks direct comparison with history, and public material still on the old definition leads readers to wrong conclusions.

    Recommended actions:

    • Record the effective date, affected fields and whether a change is back-comparable; leave historical data untouched
    • Label public material with the current definition version and state explicitly when two versions are not directly comparable

    View detail

  • Daily-series integrity and gap logging

    One missing day distorts every later comparison. Gaps must be logged explicitly, never smoothed over by backfilling numbers.

    Recommended actions:

    • Check the series for missing days daily; log the date and reason, never fabricate values to fill the gap
    • Mark gaps on public charts and label any comparison across a gap as not directly comparable

    View detail

  • Freeze the main pool fields and guard the daily series

    Changing the 225-site main-pool fields breaks historical comparability; one missing day in the 30-site daily series distorts every later comparison.

    Recommended actions:

    • Freeze main-pool fields; add new dimensions as a separate series rather than rewriting historical fields
    • After each batch, verify the series is continuous and snapshots landed; log gaps with a reason, never fabricate values

    View detail

  • Anonymous-read checklist for public routes

    Public material may state where data can be checked while that route requires login or serves a stale build — a dead reference.

    Recommended actions:

    • List every route claimed as publicly checkable and test each anonymously for status and content version
    • Re-test after release to confirm it returns data, not a login page or stale artefact

    View detail

  • Maintain a metrics glossary consistent with public wording

    If terms like vantage, percentile, noise floor and field freeze drift in meaning across pages, reports and the changelog, historical data stops being comparable. A glossary is the single source of truth for definitions — changing one term means syncing every public wording and keeping a version.

    Recommended actions:

    • Centralise term definitions, calculation rules and scope in one glossary; pages, reports and the changelog cite the same version
    • Register every definition change in the glossary with a version and effective date before syncing public wording; never rewrite historical data, only mark the switch point
  • Version data export formats and keep them backward-compatible

    Once an external party reads a public data file in a fixed format, removing or renaming fields breaks them. Metrics maintenance should version export formats and keep old fields for a while instead of silently changing the structure.

    Recommended actions:

    • Tag exports with a format version and effective date; add fields additively and keep old ones with a deprecation note
    • Assess consumer impact before structural changes and log them in the changelog; never rewrite historical exports, publish a new version instead
  • Periodically re-check the 'trends only, no cross-vantage absolute comparisons' rule

    Readings from different vantages have different baselines, so comparing absolute values across them yields wrong conclusions. Metrics maintenance periodically checks reports, pages and reviews for such comparisons and restores trend-based wording — without touching the data itself.

    Recommended actions:

    • Spot-check reports, pages and the changelog to confirm cross-egress wording uses trends and relative change, not absolute-value comparisons
    • Correct any overreach in wording and log it in the changelog; do not alter historical readings or re-run to turn things green
  • Label third-party readings with snapshot date, source and non-realtime status

    Third-party star counts, policy snapshots and industry benchmarks are not our data assets and must not be read as quality verdicts. Define one labelling rule in data/definition maintenance so they are neither mixed into the daily series nor cited as live values.

    Recommended actions:

    • Give every third-party reading a source, capture date and capture method, label it on the page as a non-realtime snapshot that is not a quality verdict, and keep it out of our own data assets
    • Refresh snapshots quarterly without rewriting historical readings; log labelling changes in the changelog and never compare absolute values across vantages
  • Mark temporarily non-comparable ranges in the changelog

    Across a series gap, a definition switch or an incident, before-and-after readings are not directly comparable. Mark such ranges as temporarily non-comparable in data / definition maintenance so they are not used for conclusions later.

    Recommended actions:

    • Log start, end, reason and recovery condition for gaps / definition switches and label the range non-comparable
    • Cite trends only within a comparable range; never stitch conclusions across the gap
  • Criteria for filling or leaving daily-series gaps

    Some series gaps can be filled, others become fabrication if filled. Write the criteria in data / definition maintenance: when a gap is fillable, how the source is labelled, and how it is marked when left alone. No invented values.

    Recommended actions:

    • Define fillable / non-fillable criteria; label source and method when filled, keep and label the gap otherwise
    • No stitching trends across gaps, no re-running to force green, and log gap handling in the changelog
  • Owner and notification path for third-party reading labels

    Labels on third-party readings such as star counts or benchmarks go stale and keep old dates when nobody owns them. Assign a reviewer and notification path in data / definition maintenance.

    Recommended actions:

    • Log a review owner, cadence and notification path per type of third-party reading
    • Reviews update the label and snapshot date only, keep historical readings, and never present them as live or as quality verdicts
  • Tier snapshot retention: detailed recent, summarised old

    Keeping every full snapshot forever grows storage linearly. Tier retention by age in data / definition maintenance, keeping summaries and definitions for old periods so comparability survives.

    Recommended actions:

    • Define detailed-recent / summarised-old tiers with a cutover point; summaries keep definitions and versions
    • Log cutovers; compression never rewrites historical readings and citations stay retrievable
  • Keep accounts and private URL parameters out of public snapshots / exports

    Accounts, sessions or URLs with private parameters inside an export become a leak surface once public. Define export desensitisation rules in data / definition maintenance.

    Recommended actions:

    • Strip accounts, session markers and URLs with private parameters from public snapshots / exports
    • Log export-rule changes; never rewrite historical exports, generate new ones under the new rule
  • Attach a checksum to public snapshots so citers can verify integrity

    If a snapshot can be rewritten in transit, a citation cannot be verified. Attach a content checksum and generation time to public snapshots so a citing party can check the version they received.

    Recommended actions:

    • Attach a content checksum and generation time to each public snapshot and archive them together.
    • Keep old checksums for a period when a correction creates a new version, and register any incomparable interval instead of erasing history.
  • Put changelog entries themselves under retention, not lost as versions advance

    The changelog records definition changes, yet it can be pruned itself. Archive entries by date and keep them so historical comparability holds.

    Recommended actions:

    • Date each changelog entry with the changed field and affected interval; archive it rather than overwriting.
    • Archive temporarily incomparable intervals too — do not erase the note just because comparability later resumed.
  • Label multi-market snapshots per market and log comparable intervals per market

    Mixing readings from different markets in one table invites false equivalence. Label snapshots per market and log definition changes per market.

    Recommended actions:

    • Tag each market's snapshot with region code, source and date; log incomparable intervals per market in the changelog.
    • Compare trends within a market, never absolute values across markets; mark external readings as non-real-time.
  • Record page weight and crawl headers as snapshot fields with vantage labels

    Weight and crawl headers shift with the site and markets. Record them as snapshot fields with vantage labels, log definition changes in the changelog, never compare absolute values across vantages, and keep them citation-ready.

    Recommended actions:

    • Label weight and crawl-header fields in daily snapshots with vantage and definition version.
    • Log definition changes in the changelog; attach checksums to public snapshots and never compare absolute values across vantages.
  • Record structured-data coverage as a snapshot field with vantage labels

    Coverage shifts with the site and markets. Record it as a snapshot field with vantage labels, log definition changes in the changelog, never compare absolute values across vantages, and keep it citation-ready.

    Recommended actions:

    • Label structured-data coverage fields in daily snapshots with vantage and definition version.
    • Log definition changes in the changelog; attach checksums to public snapshots and never compare absolute values across vantages.
  • Record security signals as snapshot fields with vantage labels

    Certificate state and security headers shift with the site and markets. Record them as snapshot fields with vantage labels, log definition changes in the changelog, never compare absolute values across vantages, and keep them citation-ready.

    Recommended actions:

    • Label security-signal fields in daily snapshots with vantage and definition version.
    • Log definition changes in the changelog; attach checksums to public snapshots and never compare absolute values across vantages.
OPS-6 External cadence tracking (externally driven)21 item(s)

GMC / Meta policies, search algorithm updates, UCP and protocol progress, platform rules

Carriers:Tools: source-change monitoring; Skill: impact-assessment checklists; KB: external policy timeline.

  • Track platform policies and protocol progress

    GMC / Meta product specs, UCP and .well-known progress, and search algorithm updates change which practices still hold.

    Recommended actions:

    • Record only changes relevant to our definitions, noting which checklist items or tools they affect
    • Assess new agent UAs / protocol fields before adding them to the scan scope; never extend scan_batch.py fields directly

    View detail

  • An external policy timeline with impact mapping

    Seen piecemeal, policy changes are easy to miss and hard to map to our own practices. A dated timeline that marks which checklist items each change affects beats a folder of bookmarked links.

    Recommended actions:

    • Log only GMC / Meta / search / UCP changes relevant to our definitions, each with date, source and the checklist items or tools affected
    • Route new agent UAs or protocol fields through impact assessment before any change; do not extend scan script fields directly, and keep the timeline as part of the changelog

    View detail

  • Compatibility check for protocol field changes

    When UCP / .well-known adds or renames a field, existing tools and checklist items may read the old shape. Check compatibility before pulling it into the definitions.

    Recommended actions:

    • Map old vs new fields to the affected scan readings and checklist items, marking added, renamed or deprecated
    • Confirm the old field is still readable and the new one has a fallback before adopting it; never extend scan script fields directly

    View detail

  • Observe and assess new agent user agents

    When a new shopping/search agent appears, observe which paths it reads and whether it honours robots before writing a dedicated rule.

    Recommended actions:

    • Group logs by UA with paths and frequency, and observe one full cycle first
    • Only after assessment decide on a robots rule or scope change; do not edit config just because a new name appeared

    View detail

  • Decide the impact window for search algorithm updates

    Traffic can swing for weeks after an algorithm update; concluding from the first two days is almost always wrong.

    Recommended actions:

    • Log the announcement date and official notes, and set an observation window of at least several weeks before assessing
    • Within the window, record changes only — do not change definitions or rush site edits and mistake noise for causality

    View detail

  • Compliance cross-check against platform product rules

    GMC / Meta rules for titles, images, prices and promos change, and violations get whole batches rejected with little signal on our side.

    Recommended actions:

    • Keep a crosswalk of platform required and forbidden fields and check it per SKU before listing
    • After a platform update, re-check only affected fields and log the change in the external policy timeline

    View detail

  • Track format changes in shopping-agent declaration files

    The shape of llms.txt and .well-known/ucp is still evolving, and platform/agent support for fields changes. External tracking means recording format changes and assessing the impact on our own declarations — not rewriting config at every rumour.

    Recommended actions:

    • Log added/deprecated formats and fields from public change feeds with source and effective date, building a timeline
    • Assess impact before changing our own declarations; route changes through the OPT-1 re-scan and leave unconfirmed fields out
  • Log deprecation notices and migration windows for third-party sources

    When an external data source, protocol endpoint or dependency is deprecated, what matters is the time window and impact. External tracking first logs the notice source, sunset date and replacement, then schedules migration — config does not change on announcement day.

    Recommended actions:

    • Log notice source, deprecated fields/endpoints, sunset date and replacements from public announcements into a dated impact list
    • Back-plan the migration assessment from the sunset date; route changes through change control and a re-scan, with no config edits before the window
  • Quarterly comparison with public industry benchmarks and competitor docs

    External comparison uses public benchmarks and competitor public docs to see whether definitions or formats shifted — not to compare their absolute values with ours. Do it quarterly, record sources, and use conclusions only to adjust our own wording, never to rewrite historical data.

    Recommended actions:

    • Log sources, versions and definition changes of public benchmarks/competitor docs quarterly; compare definitions and formats only, not absolute values
    • Use conclusions to align our glossary and public wording in the changelog; do not alter historical readings or the main-pool series
  • Periodically re-check external tool / online demo availability and licence changes

    Linked upstream demos and repositories go offline, change licence or change terms. This site only distributes links — it does not run or host third-party binaries — so what we track is whether the annotations are still accurate, not importing third-party content.

    Recommended actions:

    • Quarterly, re-check link reachability, licence and upstream terms; update annotations and outage notes only, without caching or running third-party content
    • When an entry dies, mark it honestly or remove the link rather than hosting a self-managed copy; log changes on the external timeline and do not reshape our own architecture because of them
  • Handle references when an external benchmark goes offline

    When an industry benchmark or a competitor's public doc is redesigned or taken offline, earlier citation links break. External-cadence tracking only annotates status and the outage: no guessed URLs, no hosted copies.

    Recommended actions:

    • On finding a dead link, log 'offline / changed + date' and keep the original citation record
    • Do not guess new URLs or host third-party copies; update the annotation with the new address when it returns
  • A tracked item closes only with an upstream notice and a local check

    Closing a tracked item after one announcement skips the local compatibility check. Require two records together before closure in external-cadence tracking.

    Recommended actions:

    • Require both an upstream notice link and a local field / route check before closing; otherwise keep it open
    • File the closing note with a date; silence is not a closure
  • Give every external tracking item an owner

    As the tracking list grows, ownerless items turn into stale information. Assign an owner and a review date to each item in external-cadence tracking.

    Recommended actions:

    • Log owner, subscription source and next review date per item; ownerless items stay separate from 'covered'
    • Log owner changes; being subscribed is not the same as being checked
  • Tier tracking subscriptions by impact scope

    More subscriptions drown the important ones if all are tracked equally. Tier external-cadence tracking by impact: actively check high-impact items, scan low-impact ones periodically.

    Recommended actions:

    • Split tracked items into high / low impact with different check frequencies and subscription scopes
    • Log tier changes; subscription count is not tracking quality, and high-impact items are never dropped
  • Track external progress from public sources only

    Mixing unpublished material into protocol / platform tracking undermines both citations and conclusions. Log public sources and dates only in external-cadence tracking.

    Recommended actions:

    • Log only public notices / repos / docs with the retrieval date and source type per item
    • No unpublished material in records or conclusions; handle dead sources per OPS-6-11
  • Track changes in major agents' support for structured-data fields

    The schema fields agents support change; a field that worked yesterday may be ignored today. Each quarter, check the public docs of major agents to confirm the fields we use are still recognised.

    Recommended actions:

    • List the structured-data fields in use and check quarterly whether major agents still declare support in public docs.
    • Record the public source and date for any change before deciding on output changes; avoid verdicts from a single fetch.
  • Archive closed external-tracking items with their snapshot

    A tracking item closed with only a 'done' note leaves nothing to verify later. Archive the public source and snapshot alongside the closure.

    Recommended actions:

    • On closure, archive the upstream notice link, snapshot date and local verification conclusion, indexed by date.
    • Record only public sources and do not promote a contemporaneous guess into a conclusion; archiving is not a verdict on the upstream.
  • Track platform policy differences and effective dates per market

    Platform policies take effect at different times per market; applying one market's conclusion everywhere misjudges the impact. Log notices and effective dates per market.

    Recommended actions:

    • Tag each tracking item with market and effective date; close it only on upstream notice plus local verification.
    • Record only public sources and archive the notice snapshot; avoid verdicts from a single fetch.
  • Track changes in how major agents prefer rendering and crawl budget

    Major agents' support for JS rendering, structured fields and crawl frequency changes over time. Regularly record their public docs and observable behaviour as input for config and template tuning, without concluding from a single observation.

    Recommended actions:

    • Keep a tracking sheet of each agent's public notes on JS-less content, sitemap sharding and refresh frequency.
    • Re-verify any perceived preference change locally or in a sandbox before adjusting; note the source and date.
  • Track changes in how major agents support structured data and semantic markup

    Which schema types and semantic marks each agent supports changes over time. Regularly record public docs and observable behaviour as input for tuning, without concluding from a single observation.

    Recommended actions:

    • Keep a tracking sheet of each agent's supported schema types and semantic markup notes.
    • Re-verify any perceived change locally or in a sandbox before adjusting; note the source and date.
  • Track changes in how major agents support security and privacy signals

    How agents recognise certificates, privacy claims and trust marks changes over time. Regularly record public docs and observable behaviour as tuning input, without concluding from a single observation.

    Recommended actions:

    • Keep a tracking sheet of each agent's public notes on security and privacy signals.
    • Re-verify any perceived change locally or in a sandbox before adjusting; note the source and date.

Operations · Business

The business the store owner actually runs. Six sections in lifecycle order: setup → listing → sales → after-sales → supply chain → review. KB articles and Skills carry most of this side; Tools are downloaded and run in the user's own environment against their own data in our format (see v3 §2.3).

BIZ-1 Store setup21 item(s)

Entity, platform, payments, tax, logistics, brand

Carriers:KB: setup checklist and policy templates; Skill: pre-launch self-check; Tools: validate the user's own entity and payment details in our format, locally.

  • Settle the entity and payment rail first

    Entity, tax and payment rail determine whether you can take money and run ads at all — settle them before listing products.

    Recommended actions:

    • Fix the legal entity, tax setup and payment rail (Stripe / third party / Creem TBD), together with 3DS and chargeback policy
    • Spell out shipping cost, duties, delivery time and returns address; keep policy pages and checkout consistent

    View detail

  • Brand, domain and multi-market baseline setup

    After entity and payment rails are settled, fix domain structure, default locale/currency and brand facts before listing — changing them later ripples through URLs, feeds and already-indexed pages.

    Recommended actions:

    • Decide single-domain multilingual vs per-market domains, set default locale / currency / timezone, and freeze the URL scheme rather than changing it later
    • Write brand, contact and credential facts as a citable block in the about page and structured data, consistent across markets

    View detail

  • Pre-launch credentials and brand filing checklist

    After entity and rails are settled, missing licences, trademarks or platform filings block listing and ads, and the requirements differ by market.

    Recommended actions:

    • List licences, trademark/brand authorisation and platform filings per market, with the documents ready for each
    • Keep credential ids and expiry dates in the setup file and align entity facts across policy pages and structured data

    View detail

  • Assess crawlability when choosing a storefront platform

    Whether templates server-render and whether robots / structured data are editable determine if any later fix is possible — skipping this check means re-platforming later.

    Recommended actions:

    • Before committing, fetch a product page with JS disabled and confirm price, availability and JSON-LD are readable
    • Confirm robots / llms.txt / structured data are customisable and record it in the selection decision

    View detail

  • Tax registration and filing cadence

    VAT/sales-tax registration thresholds and filing cycles differ by market; missing registration blocks payouts and missed filings accumulate penalties.

    Recommended actions:

    • List thresholds, tax ids and filing cycles per market and confirm they are operable before launch
    • Put tax-inclusive pricing and tax ids on policy and checkout pages with consistent wording

    View detail

  • Policy pages and support channels ready before launch

    Missing terms, shipping, returns, privacy or contact info blocks the first order or first complaint, and stalls platform review too.

    Recommended actions:

    • Before launch, verify policy pages are crawlable, contacts work and support channels are staffed
    • Link policy pages from footer and checkout with wording aligned to support scripts

    View detail

  • Split fixed vs variable costs and set a break-even baseline before launch

    Before launch, separate costs into those paid regardless of sales and those incurred per extra order, then work out how many orders cover fixed outgoings. With a high variable-cost mix, more orders need not improve cash flow; setting this baseline gives later reviews a reference point.

    Recommended actions:

    • List fixed items (subscriptions, hosting, labour) and per-order variables (payment fees, commission, fulfilment); derive contribution per order and break-even volume
    • Put the baseline in the launch checklist; quarterly reviews explain deviations only, without repeatedly re-pricing on short-term volume swings

    View detail

  • Set logistics, warehousing and delivery coverage before launch

    Delivery coverage, lead time and warehousing decide what product pages can promise and what after-sales costs. Fixing this baseline before launch gives policy pages, support scripts and structured data one version to cite.

    Recommended actions:

    • List self-fulfilment vs 3PL options, reachable markets, lead-time ranges and excluded regions as a launch baseline
    • Product, policy and support wording cite that baseline; version plan changes instead of silently overwriting old promises
  • Clarify data ownership and third-party tool access before launch

    Launch brings a set of tools, so separate which data stays on our side and which goes to cloud services. Data the user brings and processes locally in our format is fine; anything requiring private data to be piped to the cloud is listed separately and deferred — not wired up by default at launch.

    Recommended actions:

    • List each tool with where its data lives (user-side / site-owned / cloud) and its purpose; user-side results are not our data assets
    • Register and defer any cloud-ingestion of private data; at launch use only public or user-supplied data and issue no compliance verdict
  • Set SKU / category coding rules and a master-data owner before launch

    Listing products before coding rules exist leaves later multi-channel feed mapping, bundles and variant linking without a baseline. Fix the codes and the owner during setup: this is a launch baseline, not a listing checklist item.

    Recommended actions:

    • Define SKU, category and variant coding rules plus forbidden characters in one launch-baseline document
    • Name a master-data owner and an approval rule for changes; later feed mapping and bundle structures follow this baseline
  • Prepare a public notice template for maintenance windows before launch

    Without one agreed notice, channels and support say different things during maintenance or an order pause. Settle the notice template, the responsible channel and the recovery confirmation during launch preparation.

    Recommended actions:

    • Write a public maintenance / order-pause notice template covering scope, expected recovery and support channel
    • Name an owner for publishing and recovery confirmation; keep channel promises consistent with the page during the window
  • Sign off each launch-baseline item as ready

    Credentials, payments, logistics and policy pages being more or less done is not readiness. Fix a checkable ready criterion and a signer per item during launch preparation so the store does not open half-broken.

    Recommended actions:

    • Give each baseline item a checkable ready criterion and a signer; unsigned items stay listed separately
    • Log owner and plan for unready items; do not skip sign-off to hit a launch date
  • Register third-party provider contacts and incident channels

    When a payment, logistics or storefront provider fails, no contact channel turns it into a business incident. Register contacts and incident channels as one list during launch preparation.

    Recommended actions:

    • Log contact, incident channel, service hours and escalation path per provider in one place
    • Follow the list during incidents with a record; do not dig through personal chats for contacts
  • Shared backend vs per-market config when opening multiple markets

    With several markets, sharing everything mixes data and duplicating everything breaks cost. Draw the shared / per-market boundary during launch preparation to avoid rework later.

    Recommended actions:

    • List shared (backend / master data) and per-market (currency / tax / policy / fulfilment) items in the launch baseline
    • Add markets within the boundary instead of cloning the whole site; log boundary changes
  • Keep credentials and tax filings in controlled storage only

    Credentials and tax filings dropped into a public directory or static assets become publicly visible. Fix storage location and access scope during launch preparation.

    Recommended actions:

    • Store credentials and tax filings in controlled storage; public pages show a 'filed' status, not the documents
    • Restrict access by role and log retrievals; never put originals in the repo or static assets
  • Set one source and owner for public contact details before opening

    Emails, phone numbers and addresses on pages, feeds and policy pages are often filled by different people; updating one and missing another leaves agents with contradictions. Establish one authoritative source before opening.

    Recommended actions:

    • Define one authoritative source for contact details and how each surface references it, updating all surfaces together.
    • Assign an owner and review cadence so the same field matches across policy pages, footer and feed.
  • File opening qualifications and tax materials by expiry with review reminders

    Qualifications and tax registrations expire, which can make store pages and declarations stale. Register expiry dates and remind before they lapse.

    Recommended actions:

    • Register subject, expiry date and reviewer for each document; trigger a review before expiry rather than auto-renewing.
    • Keep materials in a controlled location, show only publicly citable parts on pages, and log validity changes in the changelog.
  • Verify entity, tax and delivery scope market by market when opening

    A shared backend does not mean entity, tax registration and delivery scope can be copied. Verify each market before launch.

    Recommended actions:

    • List per-market verification results for entity, tax registration and delivery scope, then sign off before launch.
    • Archive qualifications per market in controlled storage and show only publicly citable parts on pages.
  • Include bandwidth and crawl-friendliness in platform selection

    When choosing a platform or CDN, besides price and features evaluate whether compression, caching and custom response headers are configurable, so platform limits don't hurt crawlability later.

    Recommended actions:

    • Make a selection checklist confirming whether robots, sitemap and response headers can be customised.
    • Record the platform's compression and caching limits to inform later config changes.
  • Include structured-data and semantic control in platform selection

    When choosing a platform, besides price and features confirm whether structured-data output and semantic templates can be customised, so platform limits don't cause trouble later.

    Recommended actions:

    • In the selection checklist, confirm whether JSON-LD output and semantic tags can be customised.
    • Record the platform's limits here to inform later adjustments.
  • Include security controllability in platform selection

    When choosing a platform or CDN, confirm you can manage certificates, access control and keys yourself, so platform limits don't cause trouble later.

    Recommended actions:

    • In the selection checklist, confirm certificate management, access control and key custody capabilities.
    • Record the platform's security boundaries to inform later changes.
BIZ-2 Sourcing and listing22 item(s)

Sourcing, costing, pricing, listing, localisation, feed sync

Carriers:KB: margin structure and listing standards; Skill: pre-listing checklist; Tools: validate the user's own catalogue and feed against our format, locally.

  • Margin structure and a pre-listing checklist

    Marking up only the goods cost omits inbound freight, duties, platform fees and return losses; missing listing fields poison every downstream step.

    Recommended actions:

    • Compute landed margin per market (inbound freight, duties, platform fees, return losses) before setting price and promo floors
    • Walk the pre-listing checklist: attributes, image alt text, locale/currency, SKU, feed sync, stock initialisation

    View detail

  • Validate sourcing with a small test batch

    Going straight to a large buy turns a sourcing mistake into dead stock. Run a small batch first to surface real demand, return reasons and fulfilment cost before scaling.

    Recommended actions:

    • Test each new product in a small batch, log sell-through, return reasons and landed cost, and decide on replenishment from measured data rather than projected margin
    • Feed test results back into size charts and product copy before committing to a large buy and the listing checklist

    View detail

  • Category attributes and image asset standards for listing

    Half-filled category attributes, missing alt text or inconsistent image sizes cost feed quality and comparison agents, and cost far more to fix later than at listing time.

    Recommended actions:

    • Define required attributes per category (material, size, audience …) and validate completeness at listing time
    • Standardise main-image size and ratio, write real alt text, and map variant images one-to-one to SKUs

    View detail

  • Version check for localised and multi-currency listings

    When one SKU has mismatched copy, currency and price across markets, comparison agents quote contradictory numbers.

    Recommended actions:

    • List every market version keyed by SKU and reconcile copy, currency, tax wording and status
    • After an edit, write it back to all market versions so none stays on an old price

    View detail

  • Feed field mapping and channel differences

    One catalogue feeds several channels with different required fields and taxonomies; forcing a single template gets whole batches rejected.

    Recommended actions:

    • Maintain a field map and category crosswalk per channel, with facts stored once in master data
    • After each channel rule change, validate and trace rejected fields to the map rather than editing product data

    View detail

  • First-batch sampling after listing

    A perfect pre-listing checklist can still render wrong due to a template or cache; without sampling you never find out.

    Recommended actions:

    • Sample live pages after each batch and verify price, availability, image and structured data with JS disabled
    • Also check the feed and on-site search; trace mismatches back to mapping or cache

    View detail

  • Define SKU and stock structure for bundles, kits and gifts

    Without SKU rules for bundles, kits and gifts, a parent item can show in stock while a component is out, or stock gets deducted twice. This is a data structure decided before listing — not something support can patch afterwards.

    Recommended actions:

    • Decide whether a bundle gets its own SKU, whether stock is derived from components or maintained separately, and that gifts do not consume stock
    • Before multi-language/multi-channel listing, verify feed field mapping with one bundle so channels do not report different stock definitions for the same kit

    View detail

  • Pre-listing check for restricted or prohibited categories

    Restricted/prohibited lists differ by platform and market; checking against target markets before listing is cheaper than being taken down later. This is a checklist with a trace, not a compliance verdict on any specific product.

    Recommended actions:

    • Maintain restricted/prohibited category lists per market/channel and check each listing against them, leaving a check record
    • Sync list updates into the listing checklist; route ambiguous cases to the owner instead of self-declaring them allowed
  • Define lifecycle tiers and archival for new, core, clearance and retired items

    Without lifecycle tiers, feeds and reports mix SKUs in different states and review definitions drift. The business side first fixes tiers and archival conditions, then listing/removal actions cite them.

    Recommended actions:

    • Define criteria for new/core/clearance/retired and the listing, promo and feed rules for each
    • Archive retired items with identifiers and historical definitions intact — no history rewrites; log tier-rule changes in the changelog
  • Record supplier price, lead time and MOQ baselines per SKU before listing

    With only a selling price and no supplier-price or lead-time baseline, later margin breakdowns and replenishment / stockout reviews have nothing to compare against. Record these three values per SKU before listing; the data stays on the merchant's side and is never shown publicly.

    Recommended actions:

    • Record supplier price, default lead time, MOQ and effective date per SKU as the comparison baseline for margin and replenishment reviews
    • Append a new version on change instead of overwriting; never expose supplier prices publicly or send them back to third-party tools

    View detail

  • Listing rules when a supplier temporarily runs out or changes lead time

    A listed item whose supplier runs out or whose lead time jumps becomes a fulfilment problem if sold on the old promise. Fix a mark-first, delist-second rule on the listing side; the data stays on the merchant's side.

    Recommended actions:

    • On a stockout or lead-time change, first mark current availability and the new lead time, then decide whether to pause listing
    • Append a new version instead of overwriting; never put supplier details into the feed or public pages
  • Review cadence and deviation thresholds for supplier baselines

    Supplier price and lead-time baselines drift after they are recorded. Fix a review cadence and deviation threshold on the listing side, updating only when exceeded so the baseline stays useful as a comparison.

    Recommended actions:

    • Set a quarterly review and deviation threshold; append a new version with a reason only when exceeded
    • Keep historical versions; do not change the baseline on one-off swings or expose it publicly
  • A three-way handover form for sourcing, content and warehouse

    One SKU touches sourcing, content and warehouse; out of sync, the wrong item gets listed. Use one handover form in the listing flow to align all three.

    Recommended actions:

    • List SKU, supplier info, copy status, stock and owners on the form; list only after all three confirm
    • Mark 'incomplete' until every party confirms; append a new version on change
  • Batch listing and adjusted sampling as SKU count grows

    Checking every SKU stops being realistic from dozens to thousands. Fix batch listing and a sampling ratio by SKU scale on the listing side, with ratio changes logged.

    Recommended actions:

    • List in batches with a fixed sampling ratio per SKU scale band
    • Log ratio changes; never drop sampling to zero to hit a deadline
  • Register licences and attribution for images and copy assets

    Unlicensed images or copied copy become a business risk later. Make source, licence scope and attribution required fields on the listing side.

    Recommended actions:

    • Record source, licence scope and attribution per SKU's images and copy; missing records block listing
    • Append a new version on licence change; no assets of unknown origin, no treating third-party assets as owned
  • Check new products against existing SKUs for duplicates and conflicts before listing

    Listing the same product under multiple SKUs, or a code/variant conflict with a live SKU, creates contradictory price and availability in feeds and pages. Check for duplicates before listing.

    Recommended actions:

    • Run a duplicate check using stable identifiers and key attributes before listing, and merge on a hit before going live.
    • Preserve old identifiers through merges or recoding so historical citations do not break.
  • Archive materials and historical reference mappings for delisted SKUs

    Deleting a delisted SKU outright breaks after-sales references and historical feed records. Keep materials and old identifier mappings under an archive rule.

    Recommended actions:

    • Archive the page and feed snapshot for a delisted SKU and keep the old↔new SKU mapping for citation checks.
    • Archived items are not relisted and history is not rewritten; purge only on retention conditions, not ad hoc.
  • Check category and required attributes per market before listing the same SKU

    A SKU can fall under different categories and required attributes per market; a single global listing misses fields. Check each market before listing.

    Recommended actions:

    • List category and required-attribute differences per market, fill gaps, then list and run a first-round sample check.
    • Check prohibited and restricted catalogues per market; never apply one market's list to all.
  • Set lightweight image and description standards in the listing spec

    Bake image sizes and description length into the listing spec so full-size images and overlong copy don't slow feeds and crawling — while keeping required attributes and not dropping key info for the sake of lightness.

    Recommended actions:

    • State image size/format and description length caps in the listing checklist; flag overruns for review.
    • Apply the same lightweight spec across locales and currencies so no market version becomes bloated.
  • Set standards for structured fields and units in the listing spec

    Bake brand, model, unit and currency into the listing spec so downstream systems can reliably generate structured data rather than leaving blanks.

    Recommended actions:

    • State required structured fields and unit conventions in the listing checklist; flag gaps for review.
    • Apply the same standard across market versions so fields aren't missing or written inconsistently.
  • Keep costs and internal IDs out of public fields during listing

    During listing, internal costs and IDs can accidentally land in public fields. Use a field-mapping allowlist and spot checks to prevent leaks without blocking launches.

    Recommended actions:

    • Map only public fields for output and keep internal fields inside the system.
    • Spot-check that public pages contain no internal info; fix the mapping if found.
  • Sourcing channel selection

    The sourcing channel directly shapes the supply-price, lead-time and MOQ baseline; channels differ widely in category coverage, minimum order and trial cost. This item collects common questions on how to choose and where to look.

    Recommended actions:

    • Pick a channel layer by category and trial cost, then check quotes and minimum orders per platform.
    • Feed channel info back into the SKU baseline, with source and registration date.
BIZ-3 Traffic and acquisition21 item(s)

SEO, paid ads, social/influencers, affiliates, content, repeat visits

Carriers:KB: channel structure and metric definitions; Skill: acquisition review template; Tools: aggregate the user's own channel spend and conversions in our format, locally.

  • Channel mix and a CAC baseline

    Without per-channel baselines, a total traffic number cannot tell you which channel to scale or stop.

    Recommended actions:

    • Track spend and conversions separately for SEO, paid, social, influencers and affiliates; establish CAC baselines before optimising
    • Write category and help pages as citable facts so shopping assistants have something to quote

    View detail

  • Repeat-visit and retargeting baselines

    Focusing only on acquisition ignores existing customers. Build separate baselines for repeat visits, retargeting conversion and member retention to decide whether budget belongs in acquisition or retention.

    Recommended actions:

    • Track repeat purchase, retargeting conversion and opt-out rates separately from new customers; establish baselines before increasing spend
    • Keep email / retargeting claims consistent with landing pages, and sync promo and member prices across detail page, checkout and feed

    View detail

  • Attribution and settlement checks for influencers and affiliates

    If influencer and affiliate conversions blur into organic traffic, neither commission nor ROI is trustworthy, and renewal decisions become guesswork.

    Recommended actions:

    • Give each influencer/affiliate a distinct link or code and reconcile conversions and commission per contract period, not from totals
    • Remove returns and opt-outs before computing ROI and fix the settlement definition in the contract and changelog

    View detail

  • Pacing organic search and content investment

    Content compounds; judging it on one-month ROI cuts it too early. Review indexation and citations quarterly, not with the paid-ads yardstick.

    Recommended actions:

    • Set a steady cadence for category pages, buying guides and help content; review indexation and citations quarterly
    • Account for organic separately from paid and do not apply the same CAC threshold to content decisions

    View detail

  • Paid-campaign structure and negative-keyword checks

    Mixing brand, competitor and generic terms in one ad group makes CAC unreadable; without negative keywords, budget keeps leaking to irrelevant traffic.

    Recommended actions:

    • Split ad groups by intent (brand / competitor / generic / retargeting) with separate spend and conversion tracking
    • Review search-term reports weekly and add negatives; do not let a blended CAC hide one losing group

    View detail

  • Cross-device and attribution-window definitions for repeat visits

    A person switching devices counted as new, or different attribution windows per channel, distorts both repeat rate and CAC.

    Recommended actions:

    • Define cross-device merging and the attribution window once and apply it to every channel
    • Apply definition changes forward only and log them in the changelog, never rewriting history

    View detail

  • Identify and tag sessions coming from shopping agents / AI search

    Agent-driven visits often land in direct/referral and blend with organic traffic, skewing CAC and channel mix. The business-side step is simply to tag and bucket these sessions separately — without collecting or inferring visitor identity.

    Recommended actions:

    • Tag agent sessions by public UA/referrer rules and report them as their own bucket, not folded into organic search
    • Aggregate session/order counts only — no private site-owner data, no absolute-value comparisons across vantages; log tagging-rule changes in the changelog

    View detail

  • Map subscription sources and activation cadence for email / owned lists

    Unclear subscription sources break attribution and frequency control; without an activation cadence, new subscribers get hit immediately. Set source tagging and cadence first, aggregating counts only — without collecting or inferring visitor identity.

    Recommended actions:

    • Tag subscription entry and time, bucket reports by source, and set an activation observation period plus frequency caps for new subscribers
    • Aggregate subscription/contact counts only — no private site-owner data; log tagging-rule changes in the changelog

    View detail

  • Check landing pages match channel promises on price, stock and lead time

    If ad or affiliate landing pages state price, stock or lead time differently from the product page, traffic drops and agents read contradictory facts. The business side samples wording consistency per channel periodically.

    Recommended actions:

    • Sample ad/affiliate landing pages against product pages for price, stock state and lead time; log mismatches in a fix list with a deadline
    • Check wording consistency only — no master-data edits, no re-running to turn things green; version channel-definition changes

    View detail

  • Register stable citable URLs and an update cadence for public reference pages

    Public checklists, knowledge-base pages and tool docs are valuable when others cite them, and a URL change breaks those citations. Treat citable URLs and their update cadence as long-term assets on the acquisition side: record inbound references only, without one-off promotion pushes.

    Recommended actions:

    • Register a stable URL, last-updated date and a 301 / old-link retention rule per type of public reference
    • Periodically confirm old links still resolve and the update cadence is met; log inbound citations only, without chasing trends in titles or adding spend

    View detail

  • Record-keeping when a channel is throttled or attribution breaks

    Throttling, bans or broken attribution make readings drop sharply. The acquisition side records facts on the usual cadence and labels the anomaly: no scrambling to another channel for volume, and no reading the incident window as a trend change.

    Recommended actions:

    • Log the incident window, affected channel and known cause, and label readings from that window
    • When numbers stall or drop, archive as usual; no extra spend, no pivot, no growth stimulus

    View detail

  • Counting and de-duplication rules for inbound citations

    Inbound citation count is a long-term asset metric and swings if its definition drifts. Fix what counts, the de-duplication key and the window on the acquisition side; record only, do not chase trends.

    Recommended actions:

    • Define what counts as one citation, the de-duplication key and the window, and publish counts with the definition
    • Record counts only; no trend-chasing titles or extra spend, and flat numbers are archived as usual

    View detail

  • One reply template and a handover owner for inbound inquiries

    Inconsistent answers to citation or partnership inquiries contradict each other. Fix one reply template and a handover owner on the acquisition side, answering with public information only.

    Recommended actions:

    • Write a public-information-only reply template with a handover owner and an answerable scope
    • Log and hand over questions about unpublished data / pricing / roadmap; make no on-the-spot promises
  • Cap attribution / settlement reconciliation cost as channels grow

    Each new channel adds attribution and settlement reconciliation whose cost quietly exceeds its value. Cap reconciliation frequency and cost on the acquisition side, merging or deferring when exceeded.

    Recommended actions:

    • Set reconciliation frequency and a cost cap per channel; merge or reduce frequency with a logged reason when exceeded
    • Reduced frequency is not no reconciliation; never blend small-channel data into the top-line definition
  • Never use user lists of unknown origin

    Bought lists and scraped addresses are unreliable and risky. Use only explicit opt-in sources on the acquisition side, logging source and activation cadence.

    Recommended actions:

    • Send only to explicit opt-in sources, logging source, opt-in time and unsubscribe path; no bought or scraped lists
    • Discard lists of unclear origin; flat numbers are recorded, no bought volume to stimulate growth
  • Start new channels small with a recorded baseline, without rushing to scale

    A new channel starts with sparse, noisy data; scaling immediately risks treating random swings as signal. Start small, record a baseline, and only add when it stabilises.

    Recommended actions:

    • Give a new channel a small cap and observation window and record the initial conversion and cost baseline.
    • When numbers do not move, record that fact; do not switch direction, add budget or hunt for growth hacks because it is quiet.
  • Archive attribution data and settlement records when a channel ends

    When a channel ends, its attribution and settlement data is often left unmanaged. Archive by retention window for future reconciliation without hoarding useless data.

    Recommended actions:

    • On channel exit, archive the attribution definition, settlement records and end date, noting comparability in the index.
    • When numbers did not move, record that fact rather than switching direction or adding budget; archive only public sources and own records.
  • Split channel CAC and attribution by market to avoid mixed definitions

    Mixing spend and conversions across markets hides which one actually works. List channel data per market and compare only under a consistent attribution window.

    Recommended actions:

    • Record CAC baseline, attribution window and settlement definition per market; present side by side, never merged.
    • When a market's channel is quiet, record that fact rather than switching direction, adding budget or hunting for growth hacks.
  • Keep marketing landing pages light; don't let heavy scripts eat crawl budget

    Both paid and organic traffic land on landing pages. Packed tracking and animation scripts slow crawling and first paint; keep pages light and defer analytics, and if numbers don't move just record them — don't change direction.

    Recommended actions:

    • Keep only essential scripts on landing pages; defer analytics and tagging and server-render the main content.
    • Watch indexation and first paint by channel; if numbers don't move, record them as-is — no extra spend, no growth hacks.
  • Label content types with structured data on marketing pages; record flat numbers as-is

    Label content type and main entities on landing and article pages for clarity. Watch the effect as a trend; if numbers don't move, record them as-is — don't change direction.

    Recommended actions:

    • Label content type and main entities on landing and article pages using site-wide consistent names.
    • Watch indexation and citations as a trend; if numbers don't move, record them as-is — no extra spend, no growth hacks.
  • Govern third-party scripts on marketing pages; record flat numbers as-is

    Too many third-party scripts on landing pages create security and privacy risk. Keep only necessary sources with labelled purposes, watch the effect as a trend, and if numbers don't move record them as-is — don't change direction.

    Recommended actions:

    • Inventory third-party scripts, remove unnecessary sources and label each purpose.
    • Watch indexation and conversion as a trend; if numbers don't move, record them as-is — no extra spend, no growth hacks.
BIZ-4 Sales and conversion21 item(s)

Promotions, cart and checkout, AOV, cart recovery, peak-season cadence

Carriers:KB: checkout-friction playbook; Skill: pre-promo regression checklist; Tools: run the user's own funnel and price-consistency checks in our format, locally.

  • Locate cart abandonment and keep promo prices consistent

    Which step loses the cart (shipping, signup, payment) determines the fix; site-wide discounts usually mask the real friction.

    Recommended actions:

    • Break abandonment down by checkout step, fix only that step, and do not mask it with a site-wide discount
    • Before a promo, reconcile amounts across detail page, cart, checkout and feed; never leave the old price on the landing page

    View detail

  • Raise AOV and attach rate structurally

    Raising AOV by price hurts conversion. Bundles, add-ons and free-shipping thresholds should follow real attach patterns, not arbitrary product pairings.

    Recommended actions:

    • Derive bundles and add-ons from real order co-occurrence, expose them as structured recommendations rather than forced pairings, and watch their effect on conversion and returns
    • Set free-shipping thresholds from the AOV distribution and reconcile all four amounts before a promo so the threshold does not reintroduce checkout friction

    View detail

  • Peak-season cadence and rollback plan

    A peak season stacks price, template and stock changes, which is exactly when fixed issues reappear. Cadence and rollback need to be set in advance.

    Recommended actions:

    • Split warm-up / launch / encore into explicit windows, each with a key-page baseline and rollback artefact beforehand
    • After the promo, walk a checklist to remove prices and copy, then confirm the feed refresh and all four amounts back to normal

    View detail

  • Cart-recovery cadence and frequency caps

    Too many recovery messages become spam and opt-outs; too late and the order is gone. Cadence and caps should differ by abandonment cause.

    Recommended actions:

    • Tailor messages by abandonment step (shipping / signup / payment) with a per-order cap and interval
    • Track opt-out rate alongside recovered conversion and slow the cadence when opt-outs rise, not just open rate

    View detail

  • Payment-method coverage and local methods

    Card-only checkout blocks most buyers in many markets; without local wallets or instalments, abandonment stays high.

    Recommended actions:

    • List mainstream local payment methods and coverage per market, prioritising the largest gaps
    • Sandbox success / failure / cancel paths per method and show only methods available in that market

    View detail

  • Break the conversion funnel down by channel

    A falling overall conversion rate may just be a mix shift in one channel; without a split you end up fixing a checkout page that was fine.

    Recommended actions:

    • Split visit → cart → checkout → payment conversion by channel and locate which channel and step moved
    • Fix only that step instead of masking a mix problem with a site-wide discount

    View detail

  • Set sample size and read-out rules before conversion experiments

    After a button, price-display or checkout tweak, short-term noise is easily read as a result, leading to repeated redesigns. Fix the observation window, sample-size threshold and read-out rule before the experiment; below the threshold draw no conclusion and do not re-run to make the numbers look better.

    Recommended actions:

    • Record hypothesis, observation window, sample threshold and target metric before the run; freeze changes and withhold conclusions during the window
    • Archive under-threshold results as 'insufficient sample' without re-running to turn them green; scope each conclusion to that experiment only

    View detail

  • Align trust signals (stock, lead time, review summary) on product pages

    Stock, lead time and review summaries living in separate modules that disagree give both users and agents contradictory facts. The business side unifies their data sources and display — without ruling on review authenticity.

    Recommended actions:

    • Source stock, lead time and review summary from one field set and show a data timestamp so modules do not compute separately
    • Check consistency across language/market variants; log definition changes in the changelog without altering historical readings
  • Carry conversion intent with out-of-stock / back-in-stock notices

    An out-of-stock page that only says 'unavailable' ends the visit. The business side defines carry-over paths (alternatives, back-in-stock alerts) and caps contact frequency — it does not decide whether to push, it lays out the available actions.

    Recommended actions:

    • Give out-of-stock pages crawlable alternative links and a back-in-stock signup with source tagging and frequency caps
    • On restock, contact once per the agreed cadence and leave a trace; aggregate counts only — no private site-owner data, no re-running to turn things green
  • Break out shopping-agent / AI-search sessions in the conversion funnel

    Tagged agent sessions mixed into the general funnel hide where checkout and abandonment happen. Break them out as their own cohort on the conversion side for a definition-clean view only — no verdict on which channel is better, and flat or small samples are simply recorded.

    Recommended actions:

    • Use the session tag to isolate shopping-agent / AI-search traffic, align funnel-step definitions, and keep it out of the organic totals
    • With small samples or flat readings, record as-is without extra spend or a pivot; log definition adjustments separately from real changes
  • Alternative paths when delivery or payment is unavailable

    A bare failure at checkout for an undeliverable address or unavailable payment method leaves both user and agent without a next step. State the reason and alternatives on the conversion side, and log why the order was abandoned.

    Recommended actions:

    • State the concrete reason, what can be changed and the alternatives for undeliverable addresses or unavailable payment methods
    • Log abandonment by reason for attribution only; no pressure tactics, and failures stay out of the conversion denominator
  • Fix denominator and entry definitions for funnel steps

    Change what counts as entering checkout and the abandonment rate moves with it. Fix entry conditions and denominators per step on the conversion side, and log definition changes separately.

    Recommended actions:

    • Write entry condition, denominator and exclusions per funnel step; log definition changes in the changelog
    • Compare periods only within one definition; keep definition changes separate from real changes
  • Handover for acting on or rolling back experiment conclusions

    A conclusion with no handover leaves both rollout and rollback unowned. Put who acts and how to roll back into the experiment conclusion form.

    Recommended actions:

    • File scope, rollout owner, rollback condition and rollback owner together with the conclusion
    • A conclusion without handover does not take effect; roll back by the stated condition with a record
  • Cap concurrent experiments and fix traffic allocation

    Too many concurrent experiments compete for traffic and make every conclusion unreliable. Cap concurrency and fix traffic allocation on the conversion side; overflow queues.

    Recommended actions:

    • Set a concurrency cap and per-layer traffic allocation; new experiments queue when the cap is hit
    • Log allocation changes; never starve another experiment's sample to run more tests
  • No A/B tests on real payments or real orders

    Experimenting on real orders makes one mistake a real loss. Run experiments only on sandbox or anonymised aggregate data on the conversion side, with the usual read-out discipline.

    Recommended actions:

    • Run experiments on sandbox or anonymised aggregate data only; no live payments, no real orders in test groups
    • Flow changes follow the OPT-4 T3 sandbox boundary; no compliance verdict from experiment results
  • Keep merchandising copy on home and category pages consistent with product pages

    If merchandising copy on the homepage and category pages describes a different price, availability or applicability, agents treat them as different products. Merchandising copy should reference the same master data.

    Recommended actions:

    • Make price, availability, lead time and applicability on homepage and category pages reference the same fields as product pages.
    • Spot-check merchandising pages after master-data updates and fix stale copy through the changelog without rewriting history.
  • Archive raw groups and sample-size records for conversion experiments

    An experiment ending with only a conclusion cannot be re-checked later. Archive the grouping method, sample size and reading discipline alongside it.

    Recommended actions:

    • Archive sample size, grouping and decision thresholds regardless of outcome.
    • No A/B on real payments or orders; archived records carry no unverified causal claims.
  • Split conversion funnels by market and log payment/delivery differences as denominator changes

    One market's unavailable payment method drags the combined funnel down and looks like a conversion drop. Split by market and log availability differences as denominator changes.

    Recommended actions:

    • Fix each market's step denominators and entry definitions; label payment/delivery availability differences separately.
    • Offer an alternative path where delivery is unavailable, and do not fold that traffic into an unreachable denominator before drawing conclusions.
  • Light-load test the lightweight path before peaks; keep checkout script-light

    During peaks, traffic and crawling surge together. Load-test compression and caching ahead of time and keep checkout pages script-light so heavy pages don't drag down conversion at peak.

    Recommended actions:

    • Load-test key-page headers and weight in staging before peaks and record the baseline.
    • Trim checkout scripts and serve a lightweight page variant at peak; any payment change is sandbox-only.
  • Label structured prices and validity on promo pages, validated in a sandbox first

    Promo price, discount and validity windows suit structured labels; fields tied to transactions or payments are validated only in a sandbox — no real transactions or orders.

    Recommended actions:

    • Label price, discount and validity fields on staging pages and verify they parse.
    • Any payment- or order-related change is sandbox-only (T3), never crossing into real transactions.
  • Validate security signals on promo and checkout pages in a sandbox first

    Checkout pages need clear HTTPS and trust signals. Security changes tied to payments are validated only in a sandbox — no real transactions or orders.

    Recommended actions:

    • On staging, verify checkout pages have complete HTTPS and trust signals.
    • Any payment- or order-related change is sandbox-only (T3), never crossing into real transactions.
BIZ-5 Fulfilment and after-sales21 item(s)

Shipping, tracking, duties, returns, support, reviews and chargebacks

Carriers:KB: fulfilment and returns SOP; Skill: review-root-cause checklist; Tools: classify the user's own returns and tickets in our format, locally.

  • Shipment tracking and feeding return reasons back

    Without order-status write-back or return-reason classification, the same problems keep recurring in sourcing and size charts.

    Recommended actions:

    • Write order status and tracking numbers back in real time; state duties and customs responsibility on product pages
    • Classify reviews and returns by cause (sizing / quality / logistics) and feed results back into size charts and sourcing

    View detail

  • Support SLAs for tickets, chargebacks and negative reviews

    Slow after-sales handling turns into chargebacks and bad reviews. Setting response and closure deadlines per ticket type is far cheaper than damage control later.

    Recommended actions:

    • Classify tickets as logistics / sizing / quality / refund, set first-response and closure deadlines per type, and escalate on timeout
    • Route chargebacks and negative reviews through a separate root-cause pass and feed results back into size charts, copy and sourcing so the same cause does not recur

    View detail

  • Keep support FAQ in sync with review root causes

    When reviews clearly point to sizing but the FAQ still says the old thing, the same tickets keep recurring.

    Recommended actions:

    • Feed return/review root causes back into size charts, product copy and the support FAQ each quarter
    • Tag each FAQ entry with its evidence and update date, and keep policy pages, checkout and support scripts consistent

    View detail

  • Keep returns policy consistent across pages

    A 30-day policy page, a 14-day checkout note and a different support script turn straight into chargebacks and bad reviews.

    Recommended actions:

    • Keep one master definition of return window, shipping cost and exclusions, sourced by policy / checkout / product pages and support scripts
    • After each policy change, walk a page checklist and update the return policy in structured data too

    View detail

  • SOP for logistics exceptions

    Without a standard for lost parcels, customs holds and bad addresses, support improvises and the same issue is handled differently each time.

    Recommended actions:

    • Define criteria, compensation/reship rules and deadlines per exception type for support to follow
    • Classify exceptions by carrier and lane and feed results back into channel choice and delivery estimates

    View detail

  • Align support scripts with structured data

    Support says 14 days, structured data says 30, the policy page says something else — no single definition can be defended in a dispute.

    Recommended actions:

    • Generate support scripts, policy pages and structured data from one master definition of returns / delivery / shipping cost
    • After each master change, run a three-way consistency check and log and fix differences the same day

    View detail

  • State duties, return-shipping liability and delivery windows for cross-border orders

    Most cross-border disputes come from not stating before checkout who pays duties, who covers return shipping, and what counts as late. Writing these into product and policy pages — consistent with support scripts — is far cheaper than explaining case by case. This is wording consistency, not a legal compliance verdict.

    Recommended actions:

    • State duty bearer, return-shipping liability and delivery window consistently across product, checkout and policy pages; support scripts cite the same version
    • Check market/language variants do not contradict each other on timing and liability; version policy changes instead of silently overwriting old wording

    View detail

  • Link exchanges / replacements with stock write-back

    If exchanges and replacements only live in support tickets without a stock write-back, book sellable quantity drifts further off. Fulfilment maps these actions to stock movements, keeping definitions aligned with the daily series — without rewriting historical readings.

    Recommended actions:

    • Define stock write-back direction and timing for exchanges, replacements and refused returns; ticket closure triggers the write-back
    • Write today's movement only — no historical snapshot rewrites; log definition changes in the changelog, no re-running to turn things green
  • Align fulfilment status definitions across channels

    Own store, marketplace and affiliate channels each use their own status words (shipped / in transit / completed), which breaks reconciliation and support. The business side builds a status map to one canonical definition — aligning names only, not changing each channel's actual workflow.

    Recommended actions:

    • Build a channel-to-canonical status map; reports and support scripts cite it with a version tag
    • Version map changes and sync public wording; align names only, do not rewrite historical order states
  • Scope after-sales policy changes to orders by their placement time

    A policy change can leave one order described two ways across the page, the confirmation and support scripts. Scope each version by order placement time on the fulfilment / after-sales side so old and new policies never disagree on the same order and disputes can resolve to a version.

    Recommended actions:

    • Record the effective timestamp of each policy change and tag confirmations and support tickets with the applicable version
    • Verify historical orders still use the old version and both versions stay reachable; resolve disputes by the order-time version rather than improvising
  • Approval limits and logging for goodwill compensation

    Compensation outside policy with no limits makes support inconsistent and costs uncontrolled. Fix approval tiers and required log fields on the fulfilment / after-sales side instead of deciding case by case.

    Recommended actions:

    • Define compensation tiers and approvers; log order, reason, amount and approver for every case
    • Ring-fence compensation from ordinary return losses; do not rewrite public after-sales policy because of it
  • Sample-check that after-sales policy versions match order time

    Scoping policy by order placement time is easy to get wrong in practice. Periodically sample whether the version tag in confirmations and support tickets matches the order time.

    Recommended actions:

    • Sample at a fixed ratio to confirm the version tag matches the policy effective time; log mismatches
    • Send mismatches back to support scripts and order templates; no improvising, no rewriting historical versions
  • Handover fields for exception orders across support, warehouse and carrier

    Exception orders bounced between three parties lose who changed the status and why. Fix handover fields and responsibility boundaries on the after-sales side.

    Recommended actions:

    • Require order, current status, handling basis, handler and next step; reject incomplete handovers
    • Each party edits only its own fields; status definitions stay aligned across channels
  • Tiered response and outsourcing boundary at support-ticket peaks

    Post-peak ticket volume cannot all run at the normal SLA. Tier response by issue type on the after-sales side and draw a clear outsourcing boundary.

    Recommended actions:

    • Fix response tiers and what may be outsourced (no order / personal data), keeping disputes and chargebacks in-house
    • Log SLA changes during peaks and restore afterwards; never hand personal data to outsourcers
  • Access scope and retention for personal data in support tickets

    Tickets are full of names, addresses and order data; without access scope and retention they spread. Fix both on the after-sales side.

    Recommended actions:

    • Fix visible roles, retention period and expiry handling for personal data in tickets; log out-of-scope access
    • Desensitise before exporting / sharing; never use raw tickets in public content or external reports
  • Define extra verification for high-value or anomalous orders

    High-value orders or orders with unusual delivery details carry a larger cost if they follow the same fully automated flow. Add a manual verification step for these cases without expanding it to all orders.

    Recommended actions:

    • Define objective triggers for extra verification (value, address anomaly, rerouting) and escalate only on a hit.
    • Record the step and outcome on the order, keep personal data to the minimum necessary, and never expose it in public declarations.
  • Separate reusable conclusions from personal data when archiving support tickets

    Tickets contain both reusable resolutions and personal data. On archive, split them: keep the conclusion queryable, purge personal data on expiry.

    Recommended actions:

    • Turn repeatable causes and resolutions into reusable entries; keep order numbers and addresses to the minimum necessary.
    • Purge personal data on expiry, never publish archived items in public declarations, and avoid verdicts from a single ticket.
  • Label return windows and responsibility per market's terms

    Answering one market's order with another's policy misstates windows and responsibility. Label the applicable version per market.

    Recommended actions:

    • Register return window, shipping responsibility and applicable policy version per market; sample-check by order market.
    • Follow per-market terms on classification and delivery without issuing local-law compliance verdicts.
  • Keep after-sales and shipping info pages lightweight, crawlable and citable

    Agents often crawl returns, shipping-time and duty notes to answer shoppers. Server-render them as plain text with explicit conditions and versions so they're citable and no key info is lost to layout.

    Recommended actions:

    • Write returns and timing notes as short plain-text sections with explicit conditions and version dates.
    • On policy updates, sync public pages and citable artefacts, keep old versions retrievable, and issue no compliance verdict.
  • Add structured status fields to after-sales and shipping notes for easier citation

    Returns windows and shipping states suit structured labels so agents can cite them when answering shoppers. Mark conditions and versions; issue no compliance verdict.

    Recommended actions:

    • Label timing and status fields structurally with explicit conditions and version dates.
    • On updates, sync public pages and citable artefacts, keep old versions retrievable, and issue no compliance verdict.
  • Protect customer info in after-sales flows; keep records but don't expose them

    Returns and support handle addresses and similar data. Public notes should describe process only, not personal info; keep ticket records with controlled access, and issue no compliance verdict.

    Recommended actions:

    • Keep public notes to process and timing only, with no personal info.
    • Keep ticket records with controlled access; sync public pages on updates, and issue no compliance verdict.
BIZ-6 Supply chain and business review21 item(s)

Replenishment, inventory turns, stockouts and slow movers, margin, CAC/LTV, cash flow

Carriers:KB: metric definitions and review templates; Skill: replenishment and slow-mover checklists; Tools: aggregate the user's own operating data in our format, locally.

  • Replenishment, stockouts/slow movers and metric definitions

    Stockouts and slow movers need different treatments; if metric definitions change monthly, reviews lose comparability.

    Recommended actions:

    • Replenish from turnover and demand forecasts, treat stockouts and slow movers separately, and review supplier terms alongside cash flow
    • Split GMV, margin, CAC, LTV, return rate and cash flow by channel; freeze definitions in a changelog instead of redefining them monthly

    View detail

  • Monthly decision review of CAC / LTV and channel profitability

    Once definitions are frozen, the point is to use them: which channel to scale or stop, which category only looks busy — each should turn into a concrete action for next month.

    Recommended actions:

    • Compute CAC, LTV, margin and return rate per channel / category under one frozen definition, and state explicit scale / cut / stop decisions
    • Turn each decision into a tracked next-month action; definition changes apply forward only and are logged in a changelog, never redefined monthly so reviews stay comparable

    View detail

  • Quarterly review of inventory turns and slow movers

    Stockouts need replenishment and slow movers need clearing — opposite actions. Watching total inventory alone hides both.

    Recommended actions:

    • Compute days-of-turn per SKU, keep stockouts and slow movers on separate lists with their own actions (replenish / clear / delist)
    • Review supplier terms, warehouse capacity and cash flow together and turn conclusions into next-quarter purchasing

    View detail

  • Break margin down by category and channel

    A healthy blended margin can hide one high-margin category carrying channels that actually lose money.

    Recommended actions:

    • Compute landed margin per category × channel (freight, duties, platform fees, returns, fulfilment) and flag loss-making pairs
    • Give loss-making pairs their own action (reprice / switch channel / delist) instead of hiding them in the blended margin

    View detail

  • Supplier performance and lead-time review

    Planning replenishment on nominal lead times causes stockouts when suppliers slip; without on-time rates per supplier, the blame always lands on demand forecasting.

    Recommended actions:

    • Track on-time rate, defect rate and actual lead-time distribution per supplier and feed them into replenishment parameters
    • For volatile suppliers, add backups or safety stock rather than only tuning the forecast model

    View detail

  • Rolling cash-flow forecast and purchasing caps

    With mismatched terms and payouts, a profitable book can still fail to fund the next purchase order; caps should follow cash flow, not sales volume.

    Recommended actions:

    • Forecast payouts, platform settlement, supplier terms and purchasing weekly, flagging cash-gap weeks
    • Set per-category purchasing caps tied to that forecast and lower them in gap weeks rather than adding promos

    View detail

  • Quarterly review of supplier concentration and backup sources

    Delivery reviews ask whether each shipment was on time; concentration asks whether an alternative exists if a source fails. When one supplier dominates, a single delay becomes store-wide stockouts, so the business review tracks this separately — it assesses structural risk, not supplier scoring.

    Recommended actions:

    • By category, report each supplier's share of spend/units and flag high-concentration categories with no backup and their alternatives
    • Log backup-sourcing status and switching cost each quarter; use conclusions for structural changes, not to swap a primary supplier over one late delivery

    View detail

  • Build seasonal demand forecasts and safety-stock baselines

    Handling peak/seasonal swings with ad-hoc orders leads to stockouts or overstock. The business side builds a seasonal baseline and safety stock from historical sales; conclusions set purchasing caps, and the baseline is not repeatedly re-cut on single swings.

    Recommended actions:

    • Aggregate historical sales by category/month into seasonal factors, safety stock and purchasing caps as a baseline
    • Quarterly reviews explain deviations only — no baseline re-cuts on one month's swing, no re-running to turn things green; log definition changes in the changelog
  • Set FX and reconciliation rules for multi-currency / multi-market settlement

    Multi-market receipts mix FX rates, fees and settlement timing; if each market computes margin its own way, monthly reviews stop being comparable. Fix the rate source, booking time and reconciliation granularity first, then discuss channel profitability.

    Recommended actions:

    • Fix the FX source and timestamp, fee classification and settlement cycle; every market produces one reconciliation format
    • Log definition changes in the changelog with an effective date; never rewrite historical data and do not compare absolute values across vantages
  • Ring-fence return / exchange / replacement losses in the quarterly review

    Folding after-sales losses into ordinary margin merges 'selling well' and 'returning a lot' into one number. Ring-fence those costs in the quarterly review so margin stays comparable and can be reconciled with fulfilment. Record and compare only; a single quarter's swing does not change direction.

    Recommended actions:

    • List return, exchange and replacement costs and counts separately each quarter, outside the ordinary margin definition, with the aggregation rule stated
    • Log aggregation-definition changes in the changelog and keep historical readings comparable; record and compare only, without changing direction on one quarter's swing
  • Separate one-off and recurring gains / losses in the quarterly review

    One-off clearance, FX or compensation mixed into ordinary margin distorts the trend. List one-off items separately in the quarterly review so definitions stay comparable.

    Recommended actions:

    • List one-off items with event and period, outside ordinary margin and channel profitability
    • Log aggregation changes in the changelog; record and compare only, without changing direction on one quarter's swing
  • A definition card for every business metric

    When CAC, LTV, margin and inventory turns are each computed differently, reviews talk past each other. Give every metric a definition card: definition, data source, update frequency.

    Recommended actions:

    • Give each metric its definition, formula, data source and update frequency in one versioned place
    • Log definition changes and keep historical readings comparable; no absolute comparisons across definitions
  • File review conclusions as the next review's comparison items

    A conclusion left in a meeting and never revisited is no conclusion. File review conclusions and carry them straight into the next review's comparison list.

    Recommended actions:

    • Log item, criterion, owner and expected review date per conclusion and carry it into the next review
    • Walk the carried items first before new conclusions; record and compare only, no pivot on one quarter's swing
  • Trim review metrics to those that change purchasing or pricing

    The review sheet thickens while few metrics change purchasing or pricing. Keep only decision-changing metrics in the body on the business side and archive the rest.

    Recommended actions:

    • Tag each metric as affects purchasing / affects pricing / record-only, keep the first two in the body with an owner
    • Trimming changes presentation only, history stays; record and compare, no pivot on one quarter's swing
  • Visibility and export limits for shared business-review docs

    Margin, supplier price and CAC in a shared doc leave the circle with one forward. Set visibility and export limits for shared review docs on the business side.

    Recommended actions:

    • Set visibility by role, disable public links and casual export, and log exports
    • Use only the desensitised version externally; permission changes never rewrite historical versions
  • Separate controllable and external factors in business reviews

    A single topline figure cannot tell whether our actions worked or the market moved. Splitting results into controllable and external factors shows which actions are worth continuing.

    Recommended actions:

    • Attribute results separately to "actions this cycle" and "external market / platform changes" without claiming credit or blame for external swings.
    • When external factors leave numbers flat, record that fact without switching direction, adding spend or hunting for growth hacks.
  • Make past review conclusions retrievable by archive index with their definition version

    A review conclusion nobody can find is as good as lost. Keep an archive index that retrieves past conclusions and their definition version by date.

    Recommended actions:

    • Register date, definition version and conclusion for each archived review; index only publicly citable items.
    • When numbers did not move, archive that fact without a retroactive story; keep conclusions that separate controllable from external factors.
  • Review business metrics per market and list FX impact separately

    Aggregating multi-market revenue in one currency makes FX swings look like business improvement. Review per market and separate FX impact from operational actions.

    Recommended actions:

    • Record revenue, cost and margin in local currency per market; list FX separately and attribute conclusions per market.
    • When numbers did not move, record that fact rather than switching direction or adding spend; archive the definition version with the review.
  • Track the cost/benefit of lightweighting as a trend; don't flip direction on flat numbers

    The payoff from lightweighting shows gradually. Record weight, crawl efficiency and related conversion and cost as trends; if numbers don't move, record them as-is — don't add spend or chase growth hacks.

    Recommended actions:

    • Log weight and crawl efficiency alongside related conversion and cost by period; watch trends, not single points.
    • If numbers don't move, record them as-is — no direction flip, no extra spend, no growth hacks; log definition changes in the changelog.
  • Track the payoff of structured-data work as a trend; don't flip direction on flat numbers

    The payoff from structured data shows gradually. Record coverage, citations and related conversion cost as trends; if numbers don't move, record them as-is — don't add spend or chase growth hacks.

    Recommended actions:

    • Log coverage, citations and conversion cost by period; watch trends, not single points.
    • If numbers don't move, record them as-is — no direction flip, no extra spend, no growth hacks; log definition changes in the changelog.
  • Track the payoff of security work as a trend; don't flip direction on flat numbers

    Security work mostly avoids losses and rarely shows up immediately in metrics. Record related cost and incidents as trends; if numbers don't move, record them as-is — don't add spend or chase growth hacks.

    Recommended actions:

    • Log security-related cost and incidents by period; watch trends, not single points.
    • If numbers don't move, record them as-is — no direction flip, no extra spend, no growth hacks; log definition changes in the changelog.

Taxonomy follows the v3 design doc §2.1 / §2.2; content is written by hand in an independent data file (data/kb-domains.json), not added to the items table or seed, and does not touch the 225-site pool or the 30-site daily series. Content is expanded section by section; each section now has twenty-one items (BIZ-2 adds a sourcing-selection item).