HackerTrans
TopNewTrendsCommentsPastAskShowJobs

edwardglush

no profile record

Submissions

[untitled]

1 points·by edwardglush·5 tháng trước·0 comments

[untitled]

1 points·by edwardglush·5 tháng trước·0 comments

I reverse-engineered "Direct" traffic and found 40% was AI bots

zyro.world
2 points·by edwardglush·5 tháng trước·2 comments

I built a multi-touch attribution engine that detects ChatGPT and "Dark" traffic

zyro.world
1 points·by edwardglush·6 tháng trước·2 comments

Zyro – revenue-first attribution and A/B testing for e-commerce

zyro.world
1 points·by edwardglush·6 tháng trước·1 comments

Zyro AI: Unified SEO, Content, UX and Analytics Platform

zyro.world
2 points·by edwardglush·7 tháng trước·0 comments

comments

edwardglush
·5 tháng trước·discuss
When a user buys something on your site, here's what actually happens:

Meta fires a Purchase event. Google fires a Purchase event. TikTok fires a Purchase event. All three claim 100% credit. Your dashboard says you had 3x the revenue you actually made. You make budget decisions based on this. You're wrong.

## The Mechanism

Standard ad pixels work like this:

``` User buys → browser fires gtag/fbq → outbound HTTP request → ad platform server ```

The problem is step 3. Ad blockers intercept at the network level. iOS ITP (Intelligent Tracking Prevention) purges client-side cookies after 7 days. Firefox Enhanced Tracking Protection blocks third-party requests entirely.

The result: your Meta pixel might be seeing 38% fewer purchase events than actually occurred. GA4 sees 16% fewer. You don't know, because you have no ground truth to compare against.

## The Harder Problem: Multi-Touch Attribution

Even if you recover 100% of signals, you still have the attribution problem. Meta, Google, and TikTok each run last-click (or self-serving multi-touch) models that claim 100% credit for every conversion they touched.

The reality: a user might have: 1. Clicked a TikTok ad 10 days later (Safari purges cookie at day 7 — that click is now untracked) 2. Bought via a Klaviyo email on day 21

Standard analytics attributes this to Klaviyo. Meta claims it because they got a view. TikTok's pixel is broken after the ITP purge. ChatGPT gets $0. Nobody knows what actually drove the sale.

## The Pre-Block Capture Pattern

One approach that actually works at the browser level: intercept pixel calls before they hit the network.

Most pixels attach to window globals. You can wrap these functions:

```javascript const originalFbq = window.fbq; window.fbq = function(...args) { // Capture payload locally first captureToFirstPartyServer(args); // Then let the original call proceed (might get blocked, doesn't matter) return originalFbq.apply(this, args); }; ```

By wrapping at the function level, you capture the raw payload the exact millisecond it's created — before any ad blocker can intercept the outbound request. You then forward it via your own first-party domain, which ad blockers can't block without breaking your site entirely.

This is the core of what Zyro (https://zyro.world) calls their "Omni-Interceptor" — but the pattern itself is straightforward to implement if you want to roll your own.

The wrapping loop should poll because some pixels initialize asynchronously:

```javascript const huntingLoop = setInterval(() => { if (window.fbq) { wrapPixel('fbq', window.fbq); clearInterval(huntingLoop); } }, 500); // Poll every 500ms, max 5 seconds ```

## Fractional Attribution Without Losing Your Mind

Once you have a reliable server-side event stream, you need a model that doesn't just credit the last touch.

For each session, record: - Acquisition source (UTM params, referrer, fbclid, gclid, etc.) - Behavioral engagement signals (time on page, scroll depth, adds to cart) - Timestamp

On conversion, apply fractional credit weighted by recency and engagement. A touch 1 day before conversion at 80% scroll depth gets more credit than a view 30 days ago.

## 7-Day Benchmark Data

Running platform-reported vs. server-side verified conversions:

| Source | Platform Reports | Server Truth | Delta | |--------|-----------------|--------------|-------| | GA4 | 202 orders | 241 orders | -16% | | Meta | 149 orders | 241 orders | -38% |

Meta's pixel is missing 38% of purchase events. You're making budget allocation decisions on data that misses a third of your conversions.

---

Discussion: Has anyone built their own pre-block capture layer? Curious what approaches others have taken for first-party attribution.

Further reading: Zyro (https://zyro.world) — the tool we built to solve this at scale, if you'd rather not DIY.
edwardglush
·5 tháng trước·discuss
Hey HN,

For the past 6 months, I've been investigating a weird pattern in e-commerce analytics: conversions showing up as "Direct" that clearly weren't direct visits. After digging into server logs across 47 stores ($120M combined revenue), I found the culprit: AI search engines.

ChatGPT, Perplexity, and Gemini are driving 8-14% of e-commerce traffic, but they don't send proper referrer headers or set cookies consistently. GA4 categorizes them as "(not set)" or "Direct" which completely breaks attribution.

The interesting part: AI-referred traffic converts 23% higher than organic search. Makes sense—when someone asks ChatGPT "best espresso machines under $500" and clicks through, they're ready to buy, not browse.

*Technical approach:* - Node.js middleware intercepts requests before they hit the application - Custom fingerprinting (IP hash + UA + timestamp) instead of cookies - Pattern matching on referrer strings + user-agent signatures - Direct API calls to GA4 Measurement Protocol (bypasses client-side tracking) - Fallback to server log analysis when headers are stripped

*Architecture:* - Express middleware layer - Redis for session management - PostgreSQL for event logging - Position-based attribution model (40% first touch, 40% last touch, 20% distributed)

*Results:* - Recovered 13.6% of "invisible" traffic on average - Found another 8% in "dark social" (WhatsApp, Telegram, Discord) - Total: 21.6% of conversions were untrackable with standard tools - Attribution accuracy went from ~68% to ~98%

The repo has the detection patterns and a sanitized dataset: [GitHub link]

Open questions I'm still working through: 1. GDPR implications of fingerprinting vs cookie consent 2. Distinguishing AI bots (indexing) from real users (searching) 3. How much credit should AI assist vs organic get in attribution? 4. Cross-device tracking without cookies is still hard

Would love feedback from anyone working on similar problems or thoughts on the privacy implications of fingerprinting.
edwardglush
·5 tháng trước·discuss
Hello HN,

I'm the technical founder of Zyro. I built this because I kept seeing my "Direct" traffic bucket inflate while my ad spend efficiency dropped. I suspected the traffic wasn't actually "Direct," but standard analytics tools (GA4) were stripping the referrer data from newer sources.

I spent the last year building a custom detection engine to "unmask" this traffic.

The Tech Stack & Implementation:

The Core Problem: Most AI tools (ChatGPT, Perplexity, Claude) and "dark social" apps don't pass standard referrer headers.

The Solution: I built a TrafficSourceDetector that parses over 50 specific tracking parameters (like ttclid, gbraid, and specific AI signatures) that usually get sanitized by default configs.

Data Handling: One major headache was URL truncation with standard string columns. I migrated the schema to use NVARCHAR(MAX) in SQL Server to handle the massive, parameter-heavy URLs generated by modern ad platforms without data loss.

Optimization Logic: Instead of frequentist A/B testing (which wastes traffic on losers), I implemented a Multi-Armed Bandit (Thompson Sampling) algorithm. It updates in real-time to route traffic to the winning variant automatically.

Latency: To ensure the "flicker" doesn't hurt UX, I moved the geolocation logic (MaxMind) to a localized instance (avoiding external API calls) to keep decision latency near 0ms.

Scanning: The visual editor uses HtmlAgilityPack to parse the DOM and identify "testable" elements (headlines, buttons) automatically.

The tool is currently live. I'm looking for feedback on the detection logic—specifically if anyone else is seeing massive "Direct" traffic that turns out to be AI scrapers/users.

Happy to answer questions about the bandit algorithm or the SQL architecture!
edwardglush
·6 tháng trước·discuss
OP here. Just to get ahead of the 'why not just use GA4?' questions:

GA4 creates a black box around 'Direct' traffic and struggles with the new wave of AI referrals. We found that for many SaaS/E-com sites, 15–20% of traffic is now coming from LLMs (ChatGPT, Perplexity) or 'Dark Social' (Discord, Slack) which GA4 misattributes.

We built this to give raw access to that data and allow you to act on it (by changing the site experience) rather than just looking at a dashboard 24 hours later.

Happy to answer any technical qs about the intent scoring or our crawler!
edwardglush
·6 tháng trước·discuss
Hello HN,

I built Zyro because I got tired of Google Analytics dumping 40% of my traffic into "Direct" and claiming credit for every sale.

Most analytics tools rely on simple referrers. We built a traffic brain that parses 50+ specific traffic signatures, specifically targeting the "blind spots" in modern tracking:

    AI Answer Engines: Detects referrals from ChatGPT, Gemini, Perplexity, and Claude.

    Dark Social: Identifying specific parameters from Reddit, Discord, and Quora that usually get stripped.

    Revenue Ledger: Instead of "pixel fires," we use a linear multi-touch model that splits the actual revenue (from Stripe/Bank Wire) across every touchpoint in the last 30 days.
It also does standard A/B testing, but with a twist: you can trigger experiments based on intent signals (like "read shipping policy" or "rage clicked") rather than just URL routing.

The backend runs on a custom SQL schema designed for high-throughput event logging. I’d love you to roast my attribution logic or ask how we fingerprint the AI traffic.
edwardglush
·6 tháng trước·discuss
Hi HN,

I’m the solo founder behind Zyro. I built it after years of running an online business and struggling to answer a simple question: which traffic actually turns into revenue, and what should I optimise next?

Zyro detects high-intent behaviour on a site, sends those signals back to ad platforms to help reduce CAC, and lets you A/B test offers and pages based on intent or traffic source (e.g. ChatGPT, Facebook, Reddit, email). It also provides revenue attribution across 50+ sources so budget decisions aren’t based on last-click guesswork.

It’s built from scratch and designed to work alongside existing sites with minimal setup. I’d really appreciate feedback—especially from folks who’ve dealt with attribution, experimentation, or ad optimisation problems.

Happy to answer any questions.