Screenshot

Nearly 46% of their total traffic and a staggering 86% of their product views ("view_item" events) were trapped in the (not set) ghost town. For this eCommerce brand, it felt like flying a plane into a storm with a broken dashboard:

• They knew people were looking at products.
• They knew their ad budget was being spent.
• But they had zero visibility on WHICH ads actually drove the intent.

They were essentially forced to guess where to allocate their next $10,000 in ad spend.When data breaks this badly, it’s usually a broken server-to-browser handshake, missing session parameters, or a faulty measurement protocol setup. 

But here is the good news: We found the leak. 🛠️

We are currently under the hood rewiring their backend tracking infrastructure to salvage this data, patch the plumbing, and restore 98%+ attribution accuracy.

Stay tuned. Over the next couple of days, I am going to share the exact step-by-step breakdown of how we solve this for them and how you can check if your business is bleeding cash the exact same way.

👇 Drop a comment below if your GA4 looks like this right now, and I'll make sure you're tagged when I drop the step-by-step fix.

Contect me: https://incisiveranking.com/free-audit-request/?utm_source=linkdin&utm_medium=post&utm_campaign=audit

If your store or your client's store has any of these problems, this post is for you.

1. How do you track Stripe purchases server-side without losing the order ID? The reason your Stripe purchases keep "going missing" in Meta and Google isn't a Pixel bug—it's the architecture. Stripe redirects the user off-domain, processes payment, and brings them back to a thank-you page where Safari ITP and ad blockers have already killed the cookie context.

• The fix: Don't rely on the "Thank You" page trigger. Capture the order via Stripe webhook on your server.
• The workflow: Forward the webhook to a server-side GTM container (I run mine on Stape for first-party cookie/custom domain), then send the Purchase event to Meta CAPI / Google Ads with the order_id, hashed PII, and an event_id for deduplication.
• The result: Match rate typically goes from ~60% to 90%+ because you aren't relying on a browser-side trigger that may or may not fire.

2. How do you sell server-side tracking to a client who only cares about ROAS? You don't sell tracking. You sell Signal Recovery.

• The Hook: "Your ad platforms are missing 30–50% of your conversions."
• The Logic: If 40% of purchases never reach Meta, the algorithm is optimizing on bad data. This artificially inflates your CPA by ~25% because the "learning" phase is starved of success signals.
• The Close: Promise a lower CPA through cleaner signal. When the algorithm sees the full conversion set, it finds your customers faster.

3. Why does GA4 disagree with my ad platform? Both are technically "right"—they just speak different languages.

• Attribution: Meta uses 7-day-click + 1-day-view. GA4 defaults to Data-Driven or Last-Click (Non-direct).
• Stitching: Meta deduplicates on its own user graph; GA4 relies on user_id, which most stores haven't configured correctly.
• Privacy: Ad blockers hit GA4 (client-side) harder than they hit server-side CAPI.
• The Framework: Optimize campaigns against the ad platform's number (to feed the algo), report business performance against GA4/Backend, and use server-side deduplicated data as your monthly source of truth.

4. What does a privacy-first stack look like in 2026? The myth is that privacy kills accuracy. In reality, a clean consent stack captures durable signal that doesn't get blocked.

• The Stack: CMP (OneTrust/Cookiebot) → GTM Variables → Google Consent Mode V3.
• Why V3? It’s mandatory for EEA traffic. Skip it, and Google throttles your bidding models silently.
• The Setup: Client-side GTM fires only consented tags; server-side GTM (Stape) hashes PII and deduplicates before outbound to Meta/TikTok.

5. The "Impossible" Platforms: Drupal and Shopware. Most agencies run from these because there’s no "one-click" app.

• Drupal: Hook into Commerce module events via a Twig template extension to push a clean dataLayer.
• Shopware: Use the Frontend Subscriber pattern + checkout finish event.
• The Secret: Use webhooks as a fallback. If the browser fails to hit the thank-you page, your server-to-server webhook ensures the conversion is still recorded.

Happy to go deeper on any of these in the comments. If you want a quick "sniff test" of your setup, drop your stack in a reply (Platform + Ad Channels) and I'll tell you where your biggest leak likely is.

Here is what is actually happening under the hood:

Myth: The native one-click setup handles your server-side data perfectly.
Reality: It completely bypasses your GTM setup and clashes with client-side pixels.
Proof: Operators see reported conversion events double overnight while the Meta "Test Events" tool breaks.

The structural breakdown:

→ Zero deduplication control: Meta’s automated server-side capture fires independently of your browser tags.

↳ Without explicit, matching Event IDs, Meta cannot reconcile the dual actions.

→ Over-reporting chaos: The exact same purchase is recorded twice—once from the browser and once from the automated hosted server.

→ Artificial optimization: Your bidding engine optimizes for duplicate data, burning your budget on low-yield audiences because it thinks performance doubled.

Platform automation is built to serve the platform, not your margins.

The cost of this "free" feature is an expensive data black box.

We have completed 2,500+ tracking setups. Automated platform patches almost always trade your data control for platform lock-in.

The fix is turning off the automated native integration and routing your server signals through a dedicated, deduplicated GTM server container.

Imagine hiring 3 independent sales reps.

https://preview.redd.it/prn504gluh1h1.jpg?width=2752&format=pjpg&auto=webp&s=91f0b018b794715632a409f49f5ad5259483c293

They all talk to the exact same customer. The customer buys one item for $100. At the end of the month, all 3 reps demand a full commission check for that single sale.

You would fire them on the spot.

Yet, this is exactly what happens to your ad spend every single day.

Welcome to the "Ghost Math" of online advertising.

• Meta says it made the sale.

• Google says it made the sale.

• TikTok says it made the sale.

But your bank account? It only shows one purchase.

Your ad platforms are grading their own homework and double-counting your revenue. Because your tracking is broken, you are making scaling decisions based on fiction—often turning off winning ads while pouring money into losing campaigns.

Here are 3 signs your tracking is lying to you:

1. The Dashboard Disconnect: Your ad managers claim you made $20k this week, but your actual store backend only shows $12k.
2. The Budget Trap: You scale your daily ad spend up, but your net profit stays completely flat.
3. The Safari Blindspot: You aren't seeing sales from iPhone users because browser cookies are quietly being deleted every 7 days.

Stop flying blind while your daily budget is actively burning.

We’ve fixed over 2,500 tracking setups. In just 10 minutes, we will look at your live running campaigns and show you exactly where your ad dollars are leaking.

Stop overpaying the algorithms.

Claim your free live campaign audit here:

→ https://incisiveranking.com/free-audit-request/

yes/no

If you want to see exactly where your data is leaking, drop your website URL Drop here: https://lnkd.in/d6WiT8Bc. I’m running Free Tracking Audits for the next 48 hours. 📈

#DataPrivacy #ServerSideTracking #MarketingAnalytics #EcommerceTips #LeadGen

GTM as we know it is changing. at Google Marketing Live 2026, a massive shift was announced: GTM containers are evolving into "Google Tags."

If you manage high-traffic eCommerce stores or complex lead-gen sites, here is the TL;DR on what this means for your tracking (and your site speed):

The Big Shift: Destinations Gone are the days of loading multiple gtag.js files for GA4, Ads, and Floodlight. Legacy tags are becoming "Destinations" within a single container.

Result? Fewer library loads and a measurable boost in page performance.

Centralized Control: You can now manage global settings (like Consent Mode and cross-domain tracking) from one dashboard with the ability to override at the destination level. No more manual inconsistencies across 50+ tags.

Visual Event Builder: Google is introducing a WYSIWYG style builder. You can now create tags and triggers by simply interacting with your site elements—no more digging through the DOM for every minor event.

What ISN'T changing (The important part):
1. This is an OPT-IN upgrade. You control the timeline.
2. It does NOT force automatic data collection.
3. Non-Google tags (Meta, TikTok, etc.) still work perfectly.

We know that with big updates comes the risk of broken data. Are you ready for the GTM migration, or is your tracking already showing gaps?

If your store or your client's store has any of these problems, this post is for you.

1. How do you track Stripe purchases server-side without losing the order ID? The reason your Stripe purchases keep "going missing" in Meta and Google isn't a Pixel bug—it's the architecture. Stripe redirects the user off-domain, processes payment, and brings them back to a thank-you page where Safari ITP and ad blockers have already killed the cookie context.

• The fix: Don't rely on the "Thank You" page trigger. Capture the order via Stripe webhook on your server.
• The workflow: Forward the webhook to a server-side GTM container (I run mine on Stape for first-party cookie/custom domain), then send the Purchase event to Meta CAPI / Google Ads with the order_id, hashed PII, and an event_id for deduplication.
• The result: Match rate typically goes from ~60% to 90%+ because you aren't relying on a browser-side trigger that may or may not fire.

2. How do you sell server-side tracking to a client who only cares about ROAS? You don't sell tracking. You sell Signal Recovery.

• The Hook: "Your ad platforms are missing 30–50% of your conversions."
• The Logic: If 40% of purchases never reach Meta, the algorithm is optimizing on bad data. This artificially inflates your CPA by ~25% because the "learning" phase is starved of success signals.
• The Close: Promise a lower CPA through cleaner signal. When the algorithm sees the full conversion set, it finds your customers faster.

3. Why does GA4 disagree with my ad platform? Both are technically "right"—they just speak different languages.

• Attribution: Meta uses 7-day-click + 1-day-view. GA4 defaults to Data-Driven or Last-Click (Non-direct).
• Stitching: Meta deduplicates on its own user graph; GA4 relies on user_id, which most stores haven't configured correctly.
• Privacy: Ad blockers hit GA4 (client-side) harder than they hit server-side CAPI.
• The Framework: Optimize campaigns against the ad platform's number (to feed the algo), report business performance against GA4/Backend, and use server-side deduplicated data as your monthly source of truth.

4. What does a privacy-first stack look like in 2026? The myth is that privacy kills accuracy. In reality, a clean consent stack captures durable signal that doesn't get blocked.

• The Stack: CMP (OneTrust/Cookiebot) → GTM Variables → Google Consent Mode V3.
• Why V3? It’s mandatory for EEA traffic. Skip it, and Google throttles your bidding models silently.
• The Setup: Client-side GTM fires only consented tags; server-side GTM (Stape) hashes PII and deduplicates before outbound to Meta/TikTok.

5. The "Impossible" Platforms: Drupal and Shopware. Most agencies run from these because there’s no "one-click" app.

• Drupal: Hook into Commerce module events via a Twig template extension to push a clean dataLayer.
• Shopware: Use the Frontend Subscriber pattern + checkout finish event.
• The Secret: Use webhooks as a fallback. If the browser fails to hit the thank-you page, your server-to-server webhook ensures the conversion is still recorded.

Happy to go deeper on any of these in the comments. If you want a quick "sniff test" of your setup, drop your stack in a reply (Platform + Ad Channels) and I'll tell you where your biggest leak likely is.

I’ve been auditing a lot of Server-Side GTM setups lately, and I’m seeing a recurring nightmare that most agencies are completely missing.

https://preview.redd.it/m4p2q6jqog0h1.png?width=522&format=png&auto=webp&s=6433543f24bb3657bf1a00200f897d02f2f308c9

The "Conversions" tab in Google Ads shows a bright green "Active" status. The client/agency thinks they are winning because the tags are firing, We just audited a 7-figure account where the status was green, but 100% of their sold item IDs were unmatched in the Merchant Center.

If you are running pMax or any Smart Bidding strategy in 2026, Google isn't just looking for "a conversion." It needs to know exactly which product was bought to optimize your bidding towards high-margin winners.

When your Cart Data doesn't match your Merchant Center Feed:

1. AI Blindness: Google sees a $500 sale but doesn't know it was Product A. It can't find more "Product A" buyers.
2. ROAS Guesswork: Your Smart Bidding starts optimizing for volume, often pushing low-margin products because it's the "easiest" path to a conversion signal.
3. The sGTM Trap: Your Server-Side GTM might be firing, but if your schema mapping for the item_id array is slightly off from your feed, the data is essentially dark.

How we fixed it: We had to go into the sGTM Data Layer, re-map the array parameters to ensure the id being passed in the purchase event was an exact string match for the Merchant Center Feed ID.
The Result: Immediate improvement in bid efficiency. The AI finally stopped "guessing" and started bidding aggressively on the products that actually move the needle.

Check your own account: Go to Conversions > Settings > Diagnostics. Look specifically for the "Needs Attention" flag under "Enhanced Conversions for Retail." If your match rate isn't near 100%, you’re leaking revenue.

I’m doing a deep dive on a few accounts this week to help identify these specific "Tracking Integrity" leaks. If you're spending $10k+/mo and want me to take a look at your schema mapping, drop a comment or shoot me a DM. Happy to help the community out.

https://preview.redd.it/p78s7gi1520h1.jpg?width=2752&format=pjpg&auto=webp&s=658921f6d20d4def5e9f9325ca180607d38b98f2

Look at your r/ga4 revenue. Now look at your actual r/shopify "Total Sales" for the last 30 days. Is the GA4 number higher? Congrats, you’re paying a "stupid tax" to r/meta and r/googleads .

Here’s what’s happening:

Every time a customer buys something, they land on your thank_you page. Then they refresh the page. Or they leave the tab open on their phone and Safari "re-activates" it 3 hours later. Or they bookmark the page to show their spouse what they bought.

If you’re just using a basic GTM container or a "plug-and-play" Shopify app, your tracking is firing every. single. time.

1 real sale becomes 3 "conversions" in your Ads Manager.

Why this actually screws you:

1. Inflated Ego (and Spend): Your media buyer sees a 5.0 ROAS and tells you to scale. In reality, it’s a 1.8 ROAS and you’re actually losing money on every shipment.
2. Algorithm Poisoning: You’re training the Meta/Google algorithms to find "high-value users." But the signal you’re sending is "people who refresh pages." The AI starts optimizing for junk.
3. The "Refund" Gap: When a customer cancels or returns, your ads manager never knows. You’re optimizing for gross revenue, not net profit.

The Fix (The "Operator" way):

Stop relying on browser-side pixels. They’re dead. You need a Server-Side GTM setup with proper deduplication logic.

Your server should be the "bouncer" for your data. Before it sends a signal to Meta CAPI or Google, it needs to check a unique transaction_id.

• If the ID has been sent before? The server kills the event.
• If the ID is new? It passes the signal.

It’s the difference between "I think we made money" and "I know exactly what my CAC is."

If you’re doing over $1M/year and you haven’t audited your deduplication, you’re literally lighting money on fire to make your dashboard look pretty.

TL;DR: Your pixels are double-counting (or triple-counting) sales because of page refreshes. Move to server-side or enjoy your fake ROAS.

We’ve all been there: Meta dashboard shows a 3.5x ROAS, r/shopify backend shows half that, and the client/boss is asking why the bank balance doesn't match the "performance."

Most people blame attribution windows or "signal loss," but after auditing about 50+ server-side setups this year, I’ve realized it’s often much dumber than that: It’s a silent infrastructure failure.

If you aren't monitoring your server-side health daily, you're flying blind. Specifically:

1. IPv6 Traffic Loss: Most ssGTM setups are still optimized for IPv4. If your server isn't catching mobile-first IPv6 traffic (which is most of social media traffic now), you’re dropping 15-20% of your events before they even reach CAPI.

2. The "Ghost" Success: Pixels firing on page load but not on actual transaction completion.

3. Cookie Erasure: Browsers are getting more aggressive. If you're on a subdomain that hasn't been properly mapped as "first-party," your 7-day cookie is actually a 24-hour cookie.

I got tired of losing my performance bonuses because of tracking glitches I didn't catch for 3 days, so I built a "Backend Verification" checklist, basically a server-side health monitor that alerts you before the data drifts.

It’s not a product, just a SOP/Audit framework I use to keep the data clean.

Happy to share the logic/checklist if anyone else is dealing with "Ghost ROAS" or thinks their pixel is currently lying to them.

What are you guys using to verify your server-side health currently? Or are we all just "praying to the dashboard"?

If your store or your client's store has any of these problems, this post is for you.

1. How do you track Stripe purchases server-side without losing the order ID? The reason your Stripe purchases keep "going missing" in Meta and Google isn't a Pixel bug—it's the architecture. Stripe redirects the user off-domain, processes payment, and brings them back to a thank-you page where Safari ITP and ad blockers have already killed the cookie context.

• The fix: Don't rely on the "Thank You" page trigger. Capture the order via Stripe webhook on your server.
• The workflow: Forward the webhook to a server-side GTM container (I run mine on Stape for first-party cookie/custom domain), then send the Purchase event to Meta CAPI / Google Ads with the order_id, hashed PII, and an event_id for deduplication.
• The result: Match rate typically goes from ~60% to 90%+ because you aren't relying on a browser-side trigger that may or may not fire.

2. How do you sell server-side tracking to a client who only cares about ROAS? You don't sell tracking. You sell Signal Recovery.

• The Hook: "Your ad platforms are missing 30–50% of your conversions."
• The Logic: If 40% of purchases never reach Meta, the algorithm is optimizing on bad data. This artificially inflates your CPA by ~25% because the "learning" phase is starved of success signals.
• The Close: Promise a lower CPA through cleaner signal. When the algorithm sees the full conversion set, it finds your customers faster.

3. Why does GA4 disagree with my ad platform? Both are technically "right"—they just speak different languages.

• Attribution: Meta uses 7-day-click + 1-day-view. GA4 defaults to Data-Driven or Last-Click (Non-direct).
• Stitching: Meta deduplicates on its own user graph; GA4 relies on user_id, which most stores haven't configured correctly.
• Privacy: Ad blockers hit GA4 (client-side) harder than they hit server-side CAPI.
• The Framework: Optimize campaigns against the ad platform's number (to feed the algo), report business performance against GA4/Backend, and use server-side deduplicated data as your monthly source of truth.

4. What does a privacy-first stack look like in 2026? The myth is that privacy kills accuracy. In reality, a clean consent stack captures durable signal that doesn't get blocked.

• The Stack: CMP (OneTrust/Cookiebot) → GTM Variables → Google Consent Mode V3.
• Why V3? It’s mandatory for EEA traffic. Skip it, and Google throttles your bidding models silently.
• The Setup: Client-side GTM fires only consented tags; server-side GTM (Stape) hashes PII and deduplicates before outbound to Meta/TikTok.

5. The "Impossible" Platforms: Drupal and Shopware. Most agencies run from these because there’s no "one-click" app.

• Drupal: Hook into Commerce module events via a Twig template extension to push a clean dataLayer.
• Shopware: Use the Frontend Subscriber pattern + checkout finish event.
• The Secret: Use webhooks as a fallback. If the browser fails to hit the thank-you page, your server-to-server webhook ensures the conversion is still recorded.

Happy to go deeper on any of these in the comments. If you want a quick "sniff test" of your setup, drop your stack in a reply (Platform + Ad Channels) and I'll tell you where your biggest leak likely is.

been digging into r/meta CAPI adoption data for a client report, and the gap is wider than I expected.

Meta's own Dataset Quality / Events Manager benchmarks show stores sending the same events through both Pixel and CAPI (with proper deduplication) see roughly 35% more conversions reported on average versus Pixel-only on events like AddToCart and Purchase. That's not a vendor stat. That's pulled from their own developer-facing tooling.

Industry estimates also put browser-side conversion loss at over 50% now, with ITP, ad blockers, cookie restrictions, and iOS link tracking protection.

What surprised me more CAPI adoption is still under 40% for small to mid-size e-commerce. Enterprise figured this out two years ago. SMBs haven't moved.

Four reasons that keep showing up when I audit setups:

1. "The Pixel still shows numbers, so it must be fine."
The dashboard fills in. Reports load. Nobody sees the gap until you compare Meta-reported purchases against Shopify/Stripe and realise the algorithm is optimising on ~70% of the data.

2. bad Event Match Quality (EMQ).
People install CAPI, send only an email, and call it done. EMQ sits at 4-5. Meta needs email + phone + IP + user agent + fbc (click ID) + fbp (browser ID) to actually match, especially on iOS, where ATT broke cross-app visibility.

3. broken deduplication.
Install both Pixel and CAPI without matching event_ids → Meta double-counts → ROAS looks unreal → algorithm goes wild → spend triples in two weeks. saw this happen to a furniture brand. They burned through the margin before anyone noticed.

4. Batching events daily instead of real-time.
Events should hit Meta within seconds, not in a nightly dump. Late events miss attribution windows entirely.

where the uplift is biggest (rough numbers from setups I've worked on, lines up with what others are reporting):

- fashion/beauty/supplements: 20-30%+ attribution recovery. mobile-heavy, impulse buys, iOS hit hardest.

- B2B SaaS/courses: 15-20%.

- high-ticket B2B / long sales cycle: 10-15%. Attribution windows are too long for even perfect tracking to catch everything.

If you want the full breakdown of what CAPI actually is, how the server-to-server flow works under the hood, and the deduplication setup that keeps both feeds clean wrote it up here: https://incisiveranking.com/a-brief-study-on-facebook-conversion-api-capi/?utm_source=reddit&utm_medium=post&utm_campaign=capi-blog

Full disclosure: That's my site. I run a tracking implementation shop. happy to answer specific questions in the thread without the link if anyone wants me to skip it.

Curious what others are seeing. What's your average EMQ score on Purchase events right now? And is anyone still on Pixel-only deliberately, or is it mostly "haven't gotten to it"?

Most checkout pages with promo codes track tracking wrong.
They either:

• Track only the discounted price (loses revenue context)
• Track only the original price (inflated reporting)
• Don't differentiate users who saw the promo vs. didn't

Here's the structure that fixed this for a recent implementation.

The setup:

• Trial offer: C$6.99
• Promo TEST24-85 → C$1.00
• Need to track both scenarios in GA4

The data layer structure that worked:

javascript

window.dataLayer.push({
  event: 'begin_checkout',
  ecommerce: {
    value: chargedAmount,        // 1.00 or 6.99
    currency: 'CAD',
    items: [{
      item_id: 'trial_7day',
      price: chargedAmount,
      discount: originalPrice - chargedAmount,
      promotion_id: promoApplied ? 'TEST24-85' : null
    }]
  },
  promo_applied: promoApplied,    // true/false for segmentation
  original_value: 6.99
});

Why this structure:

1. Single event → Cleaner GA4 reporting than separate events
2. promo_applied parameter → Segment audiences in GA4
3. discount field → Native GA4 ecommerce support
4. promotion_id → Track which promos drive conversions

Timing matters: Track on form submit, not page load. Users abandon. Page load fires too early.

The gotcha most people miss: If you have wallet payments (Apple Pay/Google Pay), they bypass your form submit listener. Add tracking in the wallet's process callback too.

Results:

• Clean r/GoogleAnalytics4 reporting on both scenarios
• Audience segmentation by promo status
• Accurate revenue tracking
• Works across card + wallet payments

Happy to answer questions in comments.

Most checkout pages with promo codes track wrong.

They either:

• Track only the discounted price (loses revenue context)
• Track only the original price (inflated reporting)
• Don't differentiate users who saw the promo vs. didn't

Here's the structure that fixed this for a recent implementation.

The setup:

https://preview.redd.it/lgthwu148ayg1.png?width=542&format=png&auto=webp&s=d929deafdf3aeafe899028e6b0d58dcd5038bb4b

• Trial offer: C$6.99
• Promo TEST24-85 → C$1.00
• Need to track both scenarios in GA4
• Multiple payment methods: card + Apple Pay + Google Pay

The DOM structure to read from:

https://preview.redd.it/vq4koft78ayg1.png?width=484&format=png&auto=webp&s=6b26406530239b8d4692c3fdd4b064185dfbeae0

Three things to grab:

• .promo div → exists only when promo is applied
• .psec2 → current charged price
• .delprice → original price (struck through)

The data layer push that worked:

javascript

const promoApplied = !!document.querySelector('.promo');
const chargedAmount = parseFloat(
  document.querySelector('.psec2').innerText.replace(/[^0-9.]/g, '')
);
const originalAmount = parseFloat(
  document.querySelector('.delprice').innerText.replace(/[^0-9.]/g, '')
);

window.dataLayer.push({
  event: 'begin_checkout',
  ecommerce: {
    value: chargedAmount,        // 1.00 or 6.99
    currency: 'CAD',
    items: [{
      item_id: 'trial_7day',
      price: chargedAmount,
      discount: originalAmount - chargedAmount,
      promotion_id: promoApplied ? 'TEST24-85' : null
    }]
  },
  promo_applied: promoApplied,    // true/false for segmentation
  original_value: originalAmount
});

Why this structure:

1. Single event → Cleaner r/GoogleAnalytics4 reporting than separate events
2. promo_applied parameter → Segment audiences in GA4
3. discount field → Native GA4 ecommerce support
4. promotion_id → Track which promos drive conversions

Timing matters: Track on form submit, not page load. Users abandon. Page load fires too early and inflates your numbers.

The gotcha most people miss: Wallet payments (Apple Pay / Google Pay) bypass your form submit listener entirely. They have their own process callbacks. You need to fire the dataLayer push inside those callbacks too, otherwise wallet conversions disappear from your reporting.

Results:

• Clean GA4 reporting on both scenarios
• Audience segmentation by promo status
• Accurate revenue tracking
• Works across card + wallet payments

Happy to answer questions in comments.

https://reddit.com/link/1szmm76/video/i3mxmfjyh9yg1/player

Most setups I audit fail one of these three critical checks:

1️⃣ The "Lie": Default state isn't actually "denied" before the click.
2️⃣ The "Ghost": User choices don't actually update the consent signals in the Data Layer.
3️⃣ The "Rebel": GTM tags ignore the consent state and fire anyway. 🚫

I just finished a clean implementation for a client to fix exactly this. 🛠️

The video below walks through all three scenarios: Default Denied, Custom Grant, and Accept All with the console proof for each. 🧪

If your store runs EU/UK traffic and you're not 100% sure your setup is compliant, you likely have a "blind spot" problem that puts your data (and legal standing) at risk. 🇪🇺🇬🇧

The good news: It takes 60 seconds to check. The fix takes a few hours. ⏱️
Want a second pair of eyes?

Just wrapped up a tracking audit for a Shopify store and the findings were too common not to share. Posting here because I keep seeing the same pattern and figured others might have hit it too.

https://reddit.com/link/1sv7hue/video/3s7cxg9u1bxg1/player

The setup looked fine at first glance. They were using Shopify's native plugin for Meta events, and the dashboard showed Page View, View Item, and Add to Cart firing every day. No alerts, no obvious red flags.

But once I actually traced the funnel end-to-end:

1. Lower-funnel events weren't firing at all

Begin Checkout, Add Payment Info, and Purchase were completely missing. Turned out the delivery plugin (the one responsible for sending those events) had been disconnected at some point, probably during a theme or app update. Nobody noticed because the upper-funnel numbers kept rolling in normally, so the dashboard never looked broken.

2. Upper-funnel events were duplicated

A second plugin was also sending View Item and Add to Cart, so those counts were inflated. Their reported conversion rate looked worse than reality because the denominator was wrong, not the actual purchases. Classic case of "more data" looking like "better data" when it's actually the opposite.

3. TikTok Pixel was inheriting the same problems

Both pixels were routed through the same Shopify connector, so the bad data was flowing into TikTok as well. They didn't realise until I pulled both event managers side by side and saw the same gaps mirrored across platforms.

The reason this matters: when your Purchase event doesn't fire, the ad platform algorithm has no way to learn who's actually valuable. It optimises on Add to Cart instead, which is a much weaker signal. You end up paying to acquire window-shoppers and wondering why CPA keeps climbing.

A few things I've noticed come up over and over in audits like this:
- Missing Purchase events after a Shopify app or theme update
- Duplicate firing when more than one plugin handles the same event
- CAPI sending data without proper deduplication keys, so Meta counts the same purchase twice
- Consent Mode V2 implementations that block events even for users who accepted

Curious how others handle this. Do you run a manual pixel check after every Shopify update, or have you got something more automated set up? And for those running both Meta and TikTok through Shopify, have you moved away from the native connectors entirely?