← Back to Journal
The proofFebruary 3, 2026· 12 min read

Full-Funnel Measurement: The Dual-Send Architecture

Client-side pixels miss 30% of conversions. Server-side alone misses behavioral context. The dual-send architecture fires both — and achieves an EMQ score of 8.0+ that directly improves ad delivery.

The Measurement Crisis

Digital advertising has a measurement problem. Ad blockers, browser privacy features, iOS App Tracking Transparency, and the death of third-party cookies have progressively blinded the tracking systems that marketers depend on.

The result: Meta's pixel sees 70% of conversions. Google's tracking sees 65%. Your analytics shows 80%. None of them agree. And the gaps mean your optimization algorithms are making decisions on incomplete data.

For Celtic Knot, this wasn't abstract. When the BIOS media buying agents (particularly Saoirse) make bid optimization decisions, the quality of those decisions depends entirely on the quality of the data feeding them. Bad data → bad optimization → wasted spend.

The Full-Funnel Measurement System solves this with a dual-send architecture — every event fires both client-side and server-side, with deduplication and identity resolution ensuring nothing is counted twice.

How Dual-Send Works

Full-Funnel Measurement

Dual-Send Architecture

Client Pixel + Server CAPI = no lost conversions. Target EMQ ≥ 8.0.

PX
Client-Side PixelBrowser
JavaScript fires on page load, add-to-cart, purchase. Fast but blocked by ad blockers and iOS ATT.
CA
Server-Side CAPIBackend
Vercel Edge Functions fire to Meta. Can't be ad-blocked. Carries hashed PII for better matching.
DD
De-DuplicationEvent ID
Same event_id on both sends. Meta de-duplicates automatically — no double-counting.
IR
Identity ResolutionMatch
Progressive resolution: email → phone → click_id → browser fingerprint. Higher match = better optimization.
Celtic Knot · Event Match Quality ≥ 8.0

Client-Side (The Pixel)

Browser-based JavaScript tracking that fires when a user performs an action:

  • PageView: User lands on a page
  • ViewContent: User views a product
  • AddToCart: User adds to cart
  • InitiateCheckout: User starts checkout
  • Purchase: User completes payment

The pixel is fast to implement and captures behavioral context (scroll depth, time on page, hover patterns). But it's vulnerable to ad blockers (used by ~30% of desktop users), strict browser privacy settings, and page unload before the event fires.

Server-Side (CAPI)

Server-to-server event delivery that fires from your backend when a transaction is confirmed:

  • Purchase: Confirmed payment via Stripe webhook
  • Subscribe: Email signup confirmed via Resend webhook
  • Lead: Form submission processed in the API route

Server events are reliable — they're not subject to ad blockers, browser settings, or page unload issues. But they miss behavioral events (you can't server-fire a "user scrolled 50%" event without client input).

The Dual-Send

Both fire for every high-value event. The client sends the pixel event. The server sends the CAPI event. Meta receives both and deduplicates using the event_id parameter.

User completes purchase
├── Client: Meta Pixel fires Purchase event (event_id: "purchase_abc123")
└── Server: CAPI sends Purchase event (event_id: "purchase_abc123")
    → Meta deduplicates: counts as 1 purchase with higher confidence

The dual-send means Meta sees the conversion even if:

  • The user has an ad blocker (server event confirms it)
  • The user closes the browser before the pixel fires (server event confirms it)
  • The server-side event alone would lack behavioral context (pixel provides it)

Event Match Quality (EMQ)

Meta assigns an Event Match Quality score (1-10) to each event based on how well the event data matches a real human on their platform.

EMQ factors:

  • Email match: The hashed email in your event matches a Facebook account
  • Phone match: The hashed phone number matches
  • External ID match: Your customer ID maps to a Facebook user
  • IP address: The client IP matches recent Facebook activity
  • User agent: The browser fingerprint matches

Target: EMQ ≥ 8.0

Below 8.0, Meta's optimization algorithm has low confidence in the conversion data and will under-optimize your campaigns. Above 8.0, the algorithm trusts your data and allocates delivery more effectively.

The dual-send architecture typically achieves EMQ 8.0-9.2 because:

  • Client events provide browser-level signals (IP, user agent, cookie ID)
  • Server events provide identity-level signals (hashed email, phone, external ID)
  • Together, they give Meta multiple high-quality match parameters

Progressive Identity Resolution

The measurement system doesn't start with full identity. It builds it progressively:

Stage 1: Anonymous

  • Browser fingerprint (user agent + screen size + timezone)
  • GA4 client ID (first-party cookie)
  • IP address (geolocation)
  • EMQ: ~4.0

Stage 2: Identified

  • Email captured (newsletter, quiz, account creation)
  • Hashed and sent with server events
  • Links anonymous behavior to a real person
  • EMQ: ~7.0

Stage 3: Authenticated

  • Logged in user with verified email
  • Phone number captured (checkout)
  • Multiple match parameters available
  • EMQ: ~8.5

Stage 4: Transacted

  • Purchase completed with full identity
  • Shipping address, payment method, order history
  • Maximum match parameters
  • EMQ: ~9.0+

Each stage adds fidelity. The system doesn't wait for full identity to start tracking — it tracks from the first anonymous visit and progressively enriches the profile as the user reveals more information.

The Telemetry Schema

All events flow into a structured Supabase schema for persistence and analysis:

fact_events — every tracking event with full metadata

  • event_id: Deduplication key
  • event_type: PageView, Purchase, etc.
  • channel: web, email, ad
  • identity_stage: anonymous, identified, authenticated, transacted
  • emq_estimate: Calculated match quality
  • sent_client: Boolean — did the pixel fire?
  • sent_server: Boolean — did CAPI send?

bridge_attribution — multi-touch attribution paths

  • Maps the full journey from first ad click to final purchase
  • Captures every touchpoint with timestamp and channel
  • Enables time-decay, position-based, and data-driven attribution models

This schema enables queries that single-platform analytics can't answer:

"What's the average time from first Meta ad click to purchase for customers who also opened at least one email?" — a cross-platform attribution question that requires unified data.

Impact on Agent Decision-Making

Saoirse (media buying agent) uses the measurement data directly:

  • With single-platform tracking: "This campaign has a 1.8x ROAS based on pixel data"
  • With dual-send architecture: "This campaign has a 2.4x ROAS — the server events captured 33% more conversions that the pixel missed"

That 33% gap is the difference between "pause the campaign" and "scale the budget." Bad measurement leads to bad decisions. Complete measurement leads to correct decisions.

The feedback loop (Step 12) depends on measurement accuracy. If the data flowing back to the warehouse is incomplete, the BIOS updates based on that data will be wrong, and agents will optimize in the wrong direction.

Full-funnel measurement isn't a technical achievement. It's the infrastructure that makes the entire flywheel trustworthy.

Want to apply this to your brand?