content:
Playbook: Design a SKAN Conversion Value Schema That Actually Predicts ROAS

Don't waste 6 bits on vanity events. Build the schema this way:
— List every post-install event, then rank by correlation to D7 revenue, not by frequency
— Decide encoding mode: coarse-grained (low/medium/high) for low-volume, fine-grained (64 buckets) for scale
— Allocate bits — e.g. 3 bits for revenue tiers, 2 for funnel depth, 1 for a key retention flag
— Set revenue buckets on a log scale ($0, $1-5, $5-20, $20+), never linear
— Lock your measurement window to the activity window (24-48h typical) so the timer doesn't expire early
— Document the mapping table and version it; an undocumented schema is a future outage

✓ Turns 6 bits into a genuine early-ROAS signal
✓ Forces you to identify your real value events
✗ Re-engineering mid-flight resets your learning data
✗ Coarse mode loses revenue granularity entirely

Verdict: Use log-scale revenue buckets for monetization apps; skip fine-grained if you do under ~1k installs/day per campaign.
Best for: Performance teams optimizing iOS in-app spend toward revenue.


network: usawave

cluster: affiliate

channel_name: In-App Bench

format: evergreen

content:
Playbook: Migrate Between MMPs Without Losing 3 Months of Data

Switching from Adjust to AppsFlyer (or back)? Run dual-tracking, don't rip and replace:
— Stand up the new SDK alongside the old one for a 14-day overlap window
— Map every event name 1:1 — af_purchase vs Revenue naming will silently break dashboards
— Re-register all SKAN ad network IDs; missing one kills iOS attribution for that partner
— Rebuild deep link routing and test every Universal Link / App Link path
— Compare install + event counts daily during overlap; expect 2-5% variance, investigate over 10%
— Migrate audiences and cohorts last, only after counts reconcile
— Notify every ad network of the new MMP before you cut over postbacks

✓ Overlap window proves parity before you trust the new tool
✓ Catches event-mapping gaps while the old data still exists
✗ Two SDKs briefly inflate app size and init time
✗ Network re-registration can take partners days to confirm

Verdict: Never hard-cut an MMP — 14-day overlap is the difference between a clean migration and a quarter of blind spending.
Best for: Teams replacing their attribution stack on a live app.


content:
Playbook: Vet a New Rewarded Video Source in One Week

Before scaling a rewarded network, run this gauntlet:
— Day 1-2: cap spend low, isolate the source in its own campaign/segment
— Pull completion rate — under 85% on rewarded means broken reward delivery or incentive fraud
— Check time-to-reward distribution; a spike of sub-5-second 'completions' is bot or skip-fraud
— Compare post-install retention vs your blended baseline — rewarded users churn faster, but a cliff at D1 is junk traffic
— Inspect placement IDs: one placement dominating 90% of volume is a red flag for a single fraudulent app
— Run a quick incrementality check — does spend lift actually move installs, or just claim organics?

✓ Separates genuine engaged-reward traffic from incentivized junk fast
✓ Cheap — you're risking a small test budget
✗ One week isn't enough to judge true LTV
✗ Rewarded inflates early funnel metrics, masking weak users

Verdict: Use rewarded video for top-of-funnel scale and event volume; skip it if you're optimizing toward day-30 revenue.
Best for: Buyers testing new in-app supply with retention guardrails.


content:
Playbook: Triage an In-App Fraud Spike in Under an Hour

Dashboards screaming? Work top-down, not random:
— Segment installs by sub-publisher and sort by anomaly, not volume — fraud hides in mid-tier IDs
— Check click-to-install time (CTIT): a wall of installs under 10 seconds = click injection
— Look at the CTIT long tail too — installs days after click = click flooding / spam
— Pull new-device-rate per source; over 90% brand-new device IDs is device farming
— Cross-check IP concentration and datacenter ASNs against install clusters
— Inspect in-app event timing — events firing in identical intervals are scripted
— Freeze payouts on the worst sub-publishers before deeper analysis

✓ Isolates the bad source fast without pausing good traffic
✓ Uses signals every MMP already exposes
✗ CTIT alone mispredicts on slow-download geos
✗ Sophisticated fraud mimics human timing — needs deeper tooling

Verdict: Use CTIT + new-device-rate for the 80% case; escalate to a dedicated fraud tool when patterns look human.
Best for: UA and ad-ops triaging suspicious in-app volume in real time.


content:
Playbook: QA a Deferred Deep Link Flow So Installs Land Where You Promised

Broken deferred deep links silently tank conversion. Test the full matrix:
— New install + cold start: ad creative → store → first open → correct in-app screen
— Test on a fresh device or wiped simulator, never on a device with the app cached
— Verify the deferred payload survives the store round-trip (clipboard/fingerprint method varies by MMP)
— Re-run on iOS and Android separately — Universal Links and App Links fail differently
— Test the 'already installed' path — it should route via direct deep link, not deferred
— Confirm fallback: if the link breaks, does the user land on home or a dead screen?
— Log the resolved route in your MMP to confirm attribution still fires

✓ Catches the silent revenue leak between click and onboarding
✓ Forces testing of the install-vs-reopen branch most teams skip
✗ Fingerprint-based deferral degrades under iOS privacy limits
✗ Manual matrix is tedious; easy to skip an OS combo

Verdict: Use this matrix before every campaign with a non-home destination; skip deferred entirely if your value is on the home screen.
Best for: Growth teams running creative that promises a specific in-app destination.


content:
Playbook: Audit In-App Viewability Before You Pay for 'Viewable' Impressions

In-app viewability lies more than web. Verify it step by step:
— Confirm the measurement vendor is OM SDK (Open Measurement) integrated, not publisher self-reported
— Check whether the SDK is actually firing — OMID presence in the VAST/ad markup, not just claimed
— Separate display (50% pixels / 1 sec) from video (50% / 2 sec) thresholds in your report
— Pull viewable rate by exchange; a publisher at 99% viewable is reporting, not measuring
— Cross-reference with audibility for video — muted autoplay rewarded skews 'completion'
— Compare measured vs measurable rate; low measurability means blind impressions you're trusting on faith

✓ Exposes self-reported viewability inflation
✓ OM SDK gives a vendor-neutral, MRC-accredited baseline
✗ OM SDK adoption is patchy across smaller in-app exchanges
✗ High viewability still doesn't mean human or attentive

Verdict: Demand OM SDK measurement for brand budgets; for performance, trust installs over viewability and skip the upcharge.
Best for: Media buyers paying CPM premiums for in-app viewable inventory.


content:
Playbook: Decide In-App vs Mobile Web Inventory for a New Campaign

A structured decision instead of a gut call:
— Define the goal: app install / in-app action → in-app; lead form or content → mobile web
— Check measurement reality: in-app gives you SDK-level events; web gives you cookies that are mostly gone
— Map the latency budget — in-app SDK ads render faster and full-screen; web has slower, smaller formats
— Compare fraud surface: in-app SDK traffic is more verifiable; mobile web has heavy bot + made-for-arbitrage sites
— Price it: in-app rewarded/interstitial CPMs vs web banner CPMs at equal viewability
— Confirm creative fit — full-screen video belongs in-app, not in a 320x50 web slot

✓ Replaces 'in-app is always better' with a goal-driven choice
✓ Surfaces the measurement gap web buyers forget post-cookie
✗ Some verticals (finance, B2B) genuinely live on web
✗ Doesn't account for your specific supply-path deals

Verdict: Use in-app for app-goal + full-screen creative; use mobile web only when your conversion lives in a browser.
Best for: Planners allocating budget across in-app and web supply.


content:
Playbook: Pre-Launch SDK Integration Checklist for Attribution

Before submitting the build, walk this list — a bad SDK init breaks everything downstream:
— Initialize the MMP SDK on the very first line of app launch, before any other network call
— Verify the SDK fires the install/session event in a debug/sandbox mode, not blind in prod
— Implement ATT prompt timing — request after value is shown, but before the first attribution-relevant event
— Register every event name against your taxonomy doc; typos here are permanent in reporting
— Confirm revenue events pass currency + value, validated server-side against receipts
— Add all SKAN ad network IDs to Info.plist — missing ones = silent iOS attribution loss
— Test with the MMP's device-test mode to see live events before release

✓ Catches init-order and event-naming bugs while they're still cheap
✓ Device-test mode gives instant ground truth
✗ ATT timing is a UX vs measurement tradeoff with no perfect answer
✗ Plist mistakes only surface weeks later in iOS data

Verdict: Use device-test mode to verify every event live before submission; never trust an SDK you haven't watched fire.
Best for: Developers and growth leads shipping a new attribution integration.


content:
Playbook: Recover Signal When SKAN Returns Null Conversion Values

Crowd anonymity zeroing your data? Don't guess — restructure:
— Confirm it's a privacy threshold issue: nulls cluster on low-volume campaigns/geos
— Consolidate campaigns — fewer, larger campaigns clear Apple's anonymity tier sooner
— Drop to coarse-grained conversion values (low/medium/high) which need lower volume to unlock
— Pool low-volume geos into a single campaign instead of one-per-country
— Lean on postback tier 2/3 source-identifier digits only where volume supports them
— Backfill the gap with a SKAN-aware predictive model or your MMP's modeling, clearly labeled as modeled

✓ Trades unusable granularity for actual returned data
✓ Structural fix, not a dashboard band-aid
✗ Consolidation costs you per-geo/per-creative readability
✗ Modeled fill is an estimate, never ground truth

Verdict: Use campaign consolidation + coarse values for low-volume iOS; skip fine-grained schemas until you clear the privacy threshold.
Best for: iOS buyers drowning in null SKAN postbacks on fragmented campaigns.


content:
Playbook: Set Up a Clean Incrementality Test for In-App Spend

Last-touch lies. Measure true lift in 7 steps:
— Pick the method: geo holdout (simple, coarse) or PSA/ghost-ads holdout (granular, harder)
— Define test vs control with comparable baseline installs — match on size and seasonality, not randomly
— Size the holdout for statistical power; too small and your lift is noise
— Run for a full conversion cycle — minimum 2-4 weeks, never a long weekend
— Hold all other variables: don't change creative, budget, or geos mid-test
— Measure lift on the true KPI (revenue, retained users), not just installs
— Compute incremental cost-per-action, then compare to your last-touch CPA

✓ Reveals how much spend just claims credit for organics
✓ Geo holdout works without special ad-network tooling
✗ Geo tests are coarse and confounded by regional effects
✗ Needs enough volume for significance — small apps struggle

Verdict: Use geo holdouts for a quick directional read; invest in ghost-ads only when your platform supports it and spend justifies it.
Best for: Teams suspicious that their reported in-app ROAS is borrowing organic credit.


content:
Playbook: Read a Click-to-Install-Time Distribution Like a Fraud Analyst

One chart catches most in-app attribution fraud. Read it right:
— Pull CTIT distribution per source, bucketed in seconds then days
— Healthy curve: a hump around 20s-2min (download + open), thinning over hours
— Spike under ~10 seconds: click injection — clicks fired at install completion, not by a real user
— Fat tail at multiple days: click flooding / spam clicks fishing for organic installs
— Suspiciously uniform distribution: scripted, not human behavior
— Compare suspect source's curve against a known-clean source side by side
— Set automated alerts on sub-10s share and 24h+ share per publisher

✓ Single metric exposes the two most common attribution frauds
✓ Available in every major MMP's raw data
✗ Slow-network geos legitimately push CTIT longer
✗ Doesn't catch fraud that mimics realistic timing

Verdict: Use CTIT as your first-pass fraud screen on every source; pair it with device + IP signals before cutting a partner.
Best for: Analysts who want a fast, no-cost read on in-app traffic quality.


content:
Playbook: Optimize Your ATT Prompt to Lift Opt-In Without Breaking Trust

Every opt-in point is deterministic iOS data. Engineer the prompt:
— Add a pre-permission priming screen explaining the value before Apple's prompt — never trigger it cold
— Time it after the user hits an 'aha' moment, not on first launch
— Localize the priming copy; generic English copy tanks opt-in in non-English geos
— A/B test priming variants, not the system prompt (you can't change Apple's text)
— Measure opt-in rate by acquisition source — paid users often opt in lower than organic
— Don't dark-pattern it; a forced or misleading prompt risks App Store rejection
— Track downstream: higher opt-in means more deterministic attribution and richer LTV

✓ Lifts the share of users you can measure deterministically
✓ Priming screen is a cheap, high-leverage A/B test
✗ You can never edit Apple's actual prompt wording
✗ Aggressive priming risks rejection and user distrust

Verdict: Use a timed, localized priming screen before the prompt; skip ATT-dependent strategies if your opt-in stays under ~25%.
Best for: iOS growth teams trying to grow their deterministic measurement base.


content:
Playbook: Reconcile MMP Numbers vs Self-Attributing Networks

Google, Meta, TikTok grade their own homework. Reconcile them properly:
— Accept the model: SANs report their own attributed installs; your MMP arbitrates last-touch
— Pull both numbers for the same window and expect a gap — SANs over-claim by design
— Set a consistent attribution window across MMP and each SAN, or the gap is just window mismatch
— De-duplicate cross-network: one install can be claimed by two SANs; your MMP picks one winner
— Compare cost figures from the network with installs from the MMP — never mix sources for CPI
— Document the typical variance per network so a 30% SAN over-count doesn't trigger a false alarm
— Use MMP-attributed installs as your single source of truth for budget decisions

✓ Stops you double-paying for double-claimed installs
✓ Establishes one arbiter instead of three conflicting dashboards
✗ SANs limit MMP visibility, so reconciliation is never perfect
✗ Window and de-dupe rules differ subtly per network

Verdict: Use the MMP as arbiter for cross-network decisions; treat SAN self-reported installs as upper-bound marketing math.
Best for: Buyers splitting budget across self-attributing in-app networks.


content:
Playbook: Build a Sub-Publisher Blocklist That Actually Sticks

Whitelisting beats whack-a-mole. Build it systematically:
— Export installs + post-install events by sub-publisher ID over 30 days
— Score each on retention, conversion, fraud-rejection rate, and CTIT health
— Cut the long tail of zero-retention sub-pubs first — they're rarely worth the risk
— Move from blocklist to allowlist once you know your top performers
— Re-share the blocklist with the network/DSP and confirm enforcement — many ignore it silently
— Re-audit monthly; fraudulent sub-pubs rotate IDs constantly
— Keep a 'watch' tier between block and allow for borderline sources

✓ Shifts from reactive blocking to proactive allowlisting
✓ Scoring makes cuts defensible, not gut-feel
✗ Blocklists decay fast as bad actors re-register
✗ Some networks don't honor blocklists without account-manager pressure

Verdict: Use an allowlist of proven sub-pubs for performance budgets; skip pure blocklisting — it's a treadmill you can't win.
Best for: Ad-ops cleaning up a noisy in-app supply mix.


content:
Playbook: A/B Test Rewarded vs Interstitial Sources for the Same Goal

Same budget, two formats — pick with data, not folklore:
— Split equal spend across rewarded and interstitial, same geo and audience
— Hold creative concept constant; only the format and placement differ
— Measure install volume AND day-7 retention separately per format
— Expect rewarded to win on volume/CPI but lose on early retention
— Check event depth: rewarded users often complete fewer real in-app actions
— Compute cost-per-retained-user, not cost-per-install, as the deciding metric
— Run long enough to see retention, not just the install spike

✓ Settles the rewarded-vs-interstitial debate with your own data
✓ Cost-per-retained-user cuts through the CPI mirage
✗ Rewarded's volume advantage tempts the wrong call on CPI alone
✗ Needs a retention window, so it's not a same-day answer

Verdict: Use rewarded for cheap top-of-funnel volume, interstitial when retained-user cost matters more than install count.
Best for: Buyers choosing between in-app ad formats for a single KPI.


content:
Playbook: Stand Up Server-to-Server Events for In-App Attribution

Client-side events get blocked and spoofed. Move the important ones server-side:
— Inventory which events are revenue-critical — send those S2S, keep funnel events client-side
— Generate a stable user/device identifier you control, mapped to the MMP's ID on install
— Send the install/attribution from client, then post conversions S2S referencing that ID
— Validate revenue against your billing/receipt server before forwarding — never trust client value
— Add idempotency keys so retried postbacks don't double-count purchases
— Reconcile S2S event counts against client counts to catch drops
— Secure the endpoint — an open S2S event API is a fraud injection point

✓ Revenue events become spoof-resistant and ad-blocker-proof
✓ Server-side validation kills fake-purchase fraud
✗ More engineering than a drop-in SDK event
✗ A misconfigured ID map breaks attribution joins

Verdict: Use S2S for validated revenue events; keep lightweight funnel events client-side where speed beats trust.
Best for: Teams whose payout or optimization depends on trustworthy in-app revenue data.


content:
Playbook: Detect In-App Creative Fatigue Before CPI Balloons

Fatigue shows up before the CPI chart panics. Catch it early:
— Track creative-level CTR and install-rate daily, not just weekly spend
— Watch frequency per user — in-app fatigue hits fast on capped audiences
— Flag the early signal: CTR holding but install-rate falling = users clicking, not converting
— Compare each creative's age to its performance curve; most rewarded/interstitial creatives decay in 1-2 weeks
— Segment by source — a creative fatigued on one network may still be fresh on another
— Set an auto-pause rule when install-rate drops a set % below the creative's peak
— Rotate in variants before the winner dies, not after

✓ Buys you lead time to refresh before CPI spikes
✓ Install-rate decay catches fatigue earlier than CPI does
✗ Short test windows can mislabel normal variance as fatigue
✗ Needs per-creative granularity some networks hide

Verdict: Use install-rate decay as your early-warning metric; refresh creatives on a 1-2 week cadence for high-frequency in-app placements.
Best for: UA managers running rewarded/interstitial creative at scale.


content:
Playbook: Configure Attribution Windows So You Don't Over- or Under-Credit

Default windows rarely fit your funnel. Set them deliberately:
— Map your real conversion lag — how long from click to install to first purchase, by source
— Set the click-through window to cover that lag without inviting click-flood fraud (7d is common, not gospel)
— Set view-through separately and shorter; view-through over-claims if left wide
— Align the window with your SKAN measurement window so iOS and Android tell consistent stories
— Keep the same window across networks for fair cross-channel comparison
— Document every window value; an undocumented change silently shifts all your CPAs
— Re-test windows when you launch a new vertical with different purchase timing

✓ Stops over-crediting from windows that are too wide
✓ Consistent windows make cross-network math honest
✗ Too tight a window undercounts genuine slow converters
✗ View-through windows are a fraud magnet if generous

Verdict: Use a click window that matches your measured conversion lag and a short view-through window; never leave MMP defaults unexamined.
Best for: Anyone whose CPA comparisons feel inconsistent across in-app channels.


content:
Playbook: Run a Supply Path Audit on Your In-App Programmatic Buys

Every hop in the chain skims margin and adds fraud surface. Trace it:
— Pull the sellers.json and app-ads.txt for the apps you're buying
— Verify each reseller is authorized — unauthorized lines in app-ads.txt = spoofable inventory
— Count the hops from your DSP to the publisher; more intermediaries = more take rate and risk
— Identify direct vs resold paths to the same app and prefer the shortest authorized one
— Check the bundle ID and app name in bid requests against the real store listing for spoofing
— Measure win rate and CPM per path; redundant long paths usually cost more for the same impression
— Consolidate to the cleanest direct paths and block the rest

✓ Cuts hidden tech-tax and spoofed-inventory exposure
✓ Uses public app-ads.txt / sellers.json — no special tooling
✗ Path consolidation can shrink reach short-term
✗ Smaller apps have messy or missing app-ads.txt

Verdict: Use direct authorized paths for in-app programmatic; skip long resold chains unless they prove unique, cheaper reach.
Best for: Programmatic buyers tightening in-app supply quality and margin.


channel_name: Offer Clinic

content:
<b>How do I vet a brand-new offer before I send a single click?</b>
Q: A network just pitched me a fresh offer. How do I check it's not a trap?

A: Run this 30-minute pass before paying for traffic:
— Read the terms twice: allowed traffic sources, allowed geos, prohibited keywords. If anything you plan to do is on the banned list, stop.
— Ask your manager the payout trigger: is it a confirmed sale, a deposit, or just a registration? Get it in writing.
— Confirm hold time and chargeback rules (how long until you're paid, what gets clawed back).
— Check the cap (daily/total click or conversion limit) and whether it resets.
— Pull the landing page on mobile. Slow or broken = your conversion rate dies regardless of payout.

Short version: terms, payout trigger, hold, cap, landing speed — all five before you spend.

More Qs? Drop them.


content:
<b>I have traffic but keep picking offers that flop. What's my matching checklist?</b>
Q: My clicks are fine but offers convert terribly. How do I match better?

A: Work top-down, not by payout:
— Name your traffic's intent. Is someone searching to buy, bored and scrolling, or comparing options? That decides everything.
— Match the ask to that intent. Cold scroll traffic hates a credit-card upfront offer; it loves a free trial or email submit.
— Match the geo. Your audience country must be in the offer's allowed list at full payout, not a lower-tier rate.
— Match the device. Push and in-app traffic needs mobile-first flows.
— Match the temperature. Warm search traffic can handle a longer, higher-commitment funnel.

Short version: intent, ask, geo, device, temperature — line all five up before payout even enters the chat.

More Qs? Drop them.


content:
<b>How do I structure the first week testing a new offer?</b>
Q: I never know how long to test or when to kill an offer. Give me a plan.

A: Treat week one as data collection, not profit:
— Day 1-2: Run one clean angle, one geo, no fancy optimization. Goal is a baseline conversion rate.
— Set a kill budget upfront — usually 2-3x the payout in spend with zero conversions means pause and review.
— Day 3-4: Once you have 100+ clicks per variant, cut the worst creative/placement, not the offer.
— Day 5-7: Only now compare against another offer in the same vertical.

Don't judge an offer on 40 clicks. Don't change five things at once — you'll never know what moved.

Short version: baseline first, preset a kill budget, get 100+ clicks before cutting, change one thing at a time.

More Qs? Drop them.


content:
<b>How do I decide between a smartlink and picking single offers?</b>
Q: Everyone says smartlinks are lazy money. When should I actually use one?

A: A smartlink auto-routes each click to the best-converting offer for that geo/device. Run this decision list:
— Is your traffic messy — many countries, mixed devices, unknown intent? Smartlink wins; it sorts the chaos.
— Is your traffic tight — one geo, one clear intent? Single offer wins; you control the funnel and keep more margin.
— Do you have time to optimize daily? If no, smartlink. If yes, single offer pays more per click.
— Just starting in a vertical? Smartlink first to learn what converts, then break out winners into single offers.

Short version: messy traffic and low time = smartlink; tight traffic and hands-on = single offer. Start smart, graduate to single.

More Qs? Drop them.


content:
<b>How do I check if an offer is evergreen or about to die seasonally?</b>
Q: I keep building funnels right before the offer goes cold. How do I spot that?

A: Audit demand before you commit:
— Drop the product category into Google Trends, 5-year view. Flat line = evergreen. Sharp annual spikes = seasonal.
— Ask the manager when volume historically peaks and dips. They know.
— Check if the offer solves an everyday need (dating, finance, health) or a calendar event (tax season, holidays, summer diet).
— For seasonal, count backward: are you entering on the rise or the downslope?

Seasonal isn't bad — it's bad timing that hurts. Build seasonal funnels 6-8 weeks before peak, harvest, then rotate out.

Short version: Trends 5-year view + manager history. Everyday need = evergreen; calendar-driven = enter early, exit before the slump.

More Qs? Drop them.


content:
<b>High payout or high conversion rate — how do I actually compare two offers?</b>
Q: One offer pays $40 at a low rate, another pays $12 but converts way more. Which?

A: Stop comparing payout. Compare earnings per click (EPC). Walk it:
— EPC = payout x conversion rate. Offer A: $40 x 1% = $0.40 EPC. Offer B: $12 x 4% = $0.48 EPC. B wins.
— Now layer in your cost per click. EPC minus CPC = your real margin per click.
— Check volume: can the higher-EPC offer take your full traffic, or does its cap choke you?
— Check hold and reversals: a high payout with 30% chargebacks is a lower effective payout.

Short version: rank by EPC, not payout. Then subtract your click cost, sanity-check the cap, and discount for reversals.

More Qs? Drop them.


content:
<b>What exactly do I ask my affiliate manager about caps?</b>
Q: I don't want to sound clueless. What cap questions should I send my AM?

A: Copy-paste this list to your manager:
— What's the daily cap, and is it on conversions or clicks?
— Does the cap reset at midnight, and in which timezone?
— Is there a total/lifetime cap on this offer?
— If I hit the cap consistently, can you raise it?
— What happens to clicks after the cap — do they still get tracked, or wasted?
— Is there a minimum volume I need to keep the offer open?

Asking precise questions makes you look pro, not green. A good AM respects it and prioritizes you.

Short version: ask cap type, reset time+zone, lifetime cap, raise path, overflow behavior, and minimum volume.

More Qs? Drop them.


content:
<b>I'm new. How do I pick my first vertical instead of guessing?</b>
Q: Total beginner. Which vertical should I start in and how do I decide?

A: Don't chase the highest payout vertical. Score candidates on four things:
— Traffic access: which vertical can you reach with sources you already have or can legally buy?
— Learning curve: nutra and dating are forgiving; finance and crypto have strict compliance.
— Cash cycle: some verticals pay weekly, some net-30. Beginners need fast feedback, pick short cycles.
— Creative supply: can you make or source angles, or is it a creative arms race you'll lose?

Pick the vertical where you score highest across all four, not the one with the fattest payout. Master one before adding a second.

Short version: rank verticals by traffic access, learning curve, pay speed, creative supply — start with your best total, master it, then expand.

More Qs? Drop them.


content:
<b>My offer is profitable. How do I scale without blowing the cap or angering the AM?</b>
Q: Found a winner. How do I scale it cleanly?

A: Scale in controlled steps:
— Message your AM first: tell them you want to scale and ask for a cap raise before you push.
— Increase spend 20-30% a day, not 3x overnight. Sudden spikes spook networks and trip fraud flags.
— Watch conversion rate and reversal rate as you scale. If quality drops, you scaled past your good traffic.
— Add one new traffic source or geo at a time, keep the winner running untouched as your control.
— Keep a buffer below the daily cap so you never get throttled mid-day.

Short version: warn the AM, raise the cap, scale 20-30%/day, watch quality, expand one variable at a time, stay under cap.

More Qs? Drop them.


content:
<b>How do I tell an offer is dying before it tanks my margin?</b>
Q: A winner is slowly slipping. How do I catch decay early?

A: Watch these warning signs as a weekly ritual:
— Conversion rate drifting down on stable traffic — the offer or its landing page is fatiguing.
— Reversal/hold rates creeping up — advertiser is tightening quality or the offer's running out of budget.
— AM goes quiet or starts pushing you toward a "newer" offer. That's a tell.
— Cap suddenly shrinks — advertiser is throttling on their side.
— Competitor angles flooding your feeds — the market's saturated.

When two or more fire, line up a replacement offer before you're forced to. Always test the next offer while the current one still earns.

Short version: falling CR, rising reversals, quiet AM, shrinking cap, copycat flood. Two signals = start your replacement test now.

More Qs? Drop them.


content:
<b>A network offered me exclusivity on an offer. What do I check before saying yes?</b>
Q: AM dangled an exclusive deal. Sounds flattering — what's the catch list?

A: Exclusivity means you're the only affiliate running it (or you get a private payout). Vet it:
— What's the bump? A higher payout or just the "honor"? Only the payout matters.
— Is there a minimum volume commitment, and what happens if you miss it?
— How long is the lock — can you exit if it underperforms?
— Is the offer proven, or are you the guinea pig de-risking it for them?
— Does exclusivity restrict you from running competing offers? Read that clause hard.

Exclusive only wins if the payout premium beats what you'd make spreading traffic across open offers.

Short version: confirm payout premium, volume commitment, lock length, proof of performance, and any compete-ban before signing.

More Qs? Drop them.


content:
<b>How do I build a shortlist of offers instead of picking randomly?</b>
Q: I browse the network dashboard and pick on vibes. Give me a real selection system.

A: Build a simple scoring sheet. For each candidate offer, log:
— EPC or network-reported EPC (a rough demand signal).
— Payout and conversion definition.
— Allowed geos that match your traffic.
— Cap size vs your expected volume.
— Landing page quality (load speed, mobile, clarity) scored 1-5.
— Vertical fit with your existing creatives.

Rank the sheet, take your top three, test the top one first. A spreadsheet beats memory and stops you chasing shiny payouts.

Short version: score every offer on EPC, payout, geo fit, cap, landing quality, creative fit — rank, top three, test number one.

More Qs? Drop them.


content:
<b>Offer is getting clicks but zero conversions. What's my debugging order?</b>
Q: Traffic's flowing, conversions are flat zero. Where do I even start?

A: Debug from the click outward, in this order:
— Fire a test conversion yourself (where allowed) — does the pixel/postback actually record? Tracking breaks silently all the time.
— Check geo match: are your clicks landing where the offer pays, or getting filtered out?
— Check the landing page on the same device your traffic uses. Broken mobile flow = zero conversions.
— Re-read the conversion definition. You might be sending registration traffic to a deposit offer.
— Check the cap — if it's hit, conversions stop counting.

Short version: test the postback, verify geo, load the page on your traffic's device, re-check the conversion event, check the cap.

More Qs? Drop them.


content:
<b>Two networks carry the same offer. How do I pick which to run?</b>
Q: Same advertiser, two networks. Same payout. How do I choose?

A: Payout parity is rare and rarely the whole story. Compare:
— Actual payout after any network shave, and the conversion definition (sometimes it differs).
— Cap size — one network often gets a bigger allocation from the advertiser.
— Hold and payment terms — net-7 vs net-30 changes your cash flow a lot.
— Tracking reliability and postback support — flaky tracking quietly loses you conversions.
— AM responsiveness — the one who answers fast can raise caps and fix issues.

Run a small split test on both for a few days; let real EPC and payment behavior decide.

Short version: compare real payout, cap, hold terms, tracking, and AM speed — then split-test and let EPC pick the winner.

More Qs? Drop them.


content:
<b>How do I rotate to a new offer without losing my optimization data?</b>
Q: Current offer is fading. How do I swap in a new one cleanly?

A: Don't rip and replace. Transition:
— Clone your best campaign, point the clone at the new offer, keep the old one live as control.
— Carry over winning angles and audiences first — they're your validated assets, separate from the offer.
— Split traffic gradually: 80/20 old/new, then shift as the new offer proves out.
— Log baseline metrics for the new offer separately; don't blend them with old numbers.
— Only kill the old offer once the new one beats it on EPC over a full cycle, not one good day.

Short version: clone, keep old as control, reuse winning angles, ramp traffic 80/20 to new, switch only after a full-cycle EPC win.

More Qs? Drop them.


content:
<b>How do I audit an offer's landing page before running it?</b>
Q: The offer looks great but how do I judge its landing page myself?

A: The advertiser's page makes or breaks your conversion rate. Check it:
— Load it on a real phone over mobile data, not your fast wifi. Time it — over 3 seconds bleeds conversions.
— Count the steps to the conversion event. Fewer fields and clicks = higher rate.
— Check the headline matches what your traffic was promised, or you get bounce.
— Look for trust signals: secure checkout, reviews, clear pricing. Missing = hesitation.
— Test the form actually submits and the thank-you/postback fires.

If the page is weak and you can't use your own pre-lander, the offer's ceiling is low no matter the payout.

Short version: time it on mobile data, count the steps, check message match, look for trust signals, confirm the form fires.

More Qs? Drop them.


content:
<b>What's the launch timeline for a seasonal offer so I don't miss the window?</b>
Q: I want to run a holiday/seasonal offer. How do I time the whole thing?

A: Count backward from peak demand:
— 8 weeks out: lock the offer, confirm caps will be large enough for peak, build creatives.
— 6 weeks out: soft-launch small to test angles while CPMs are still cheap.
— 4 weeks out: scale the winners as demand and competition start climbing.
— Peak week: push hard, watch the cap, keep a backup offer ready in case the main one caps out.
— Post-peak: cut spend fast on the downslope — chasing a fading trend burns margin.

The mistake is launching at peak when CPMs are highest and you've done zero testing.

Short version: lock at 8 weeks, test at 6, scale at 4, push at peak with a backup, then exit fast on the downslope.

More Qs? Drop them.


content:
<b>How do I read a network's listed EPC without getting fooled?</b>
Q: The dashboard shows an EPC number per offer. Can I trust it for picking?

A: Network EPC is a hint, not a promise. Read it carefully:
— Ask the timeframe: a 7-day EPC reacts faster than a 90-day average that hides recent decay.
— Ask whose traffic made it — a top affiliate's EPC won't match your beginner traffic or geo.
— Check if it's blended across all geos; a great tier-1 number can mask a dead tier-3 you'd be running.
— Treat it as a relative ranking tool between offers, not an income forecast.
— Always confirm with your own small test before believing the number.

Short version: check the timeframe and whose traffic, watch for geo-blending, use it to rank not to forecast, then verify with your own test.

More Qs? Drop them.


content:
<b>How do I decide to kill or keep an offer that's break-even?</b>
Q: An offer is hovering at break-even. Cut it or keep grinding?

A: Break-even isn't a verdict yet — run this checklist:
— Is it break-even because of the offer, or one bad creative/placement dragging the average? Segment first.
— Have you tested a pre-lander or new angle, or just the raw offer? Untested upside = keep.
— Is the conversion rate stable or trending down? Stable break-even can be optimized; declining can't.
— Check reversals — your "break-even" might actually be a loss after clawbacks.
— Is there a higher-EPC offer in the same vertical ready to test? If yes, the bar to keep rises.

Short version: segment out the dead weight, confirm you've tried angles/pre-landers, check the trend and reversals, weigh against alternatives — then decide.

More Qs? Drop them.


channel_name: Nutra Trench

content:
<b>Build a nutra pre-lander in 90 minutes flat</b>
Trench note: stop redesigning. Here's the exact run order I use.

— Min 0-15: rip the structure (not copy) of a competitor's top-spending preland off a spy tool. Just the skeleton: hook, agitate, mechanism, social proof, CTA.
— Min 15-40: write the hook block. 3 variants, one number in each ('down 14 lbs in 6 weeks' style — framed as a story, not a promise).
— Min 40-60: mechanism paragraph. WHY it works. This is what gets you past compliance review and warms the click.
— Min 60-75: drop 3 fake-but-realistic testimonials with first name + city + ugly real photo. No stock smiles.
— Min 75-90: CTA button x3 (top, mid, bottom), sticky on mobile.

No hero video v1. Ship ugly.
Go test it.


content:
<b>Your first native nutra campaign, step by step</b>
Launching native cold? Run this list top to bottom, don't freelance it.

— Pick ONE GEO, one offer, one device. Mobile + tier-1 to start.
— Pull 15 winning creatives from spy tools in your vertical. Don't run them — study the thumbnail logic.
— Build 4 ad images: curiosity object, before/after-adjacent, 'doctor says', weird-food. Headlines as questions.
— Whitelist nothing yet. Run RON (run-of-network) for 48h to find pockets.
— Day 3: cut every widget/site below 0.3x payout ROI. Whitelist the top 10.
— Day 5: scale winners 20% daily, never more.

Budget the first 3 days as tuition, not profit.
Go test it.


content:
<b>The upsell flow that doubled my AOV</b>
Trench note: the money isn't on the order form. It's the 3 screens after.

Step by step:
— Screen 1 (post-purchase, before thank-you): 'Add 2 more bottles at 50% off — most customers run out.' One-click, no re-enter card.
— Screen 2: different SKU. If they bought weight-loss, offer the 'cleanse companion.' Logic, not random.
— Screen 3: subscription downsell. 'Not ready for 6 bottles? Lock in monthly auto-ship.'
— Every screen: ONE yes button, one tiny 'no thanks' text link below.
— Timer on screen 1 only. Overdo timers and trust tanks.

Measure take-rate per screen, kill any below 8%.
Go test it.


content:
<b>Campaign went red overnight — recovery checklist</b>
Woke up to a bleeder? Don't pause in a panic. Work the list.

— Pull last 72h by placement. 90% of the time one widget ate your budget. Blacklist it, don't touch the rest.
— Check landing load time. Native traffic + 4s load = dead. Test on real mobile, throttled.
— Look at hour-of-day. Red is often just bad dayparting — cut the 1am-5am dead zone.
— Creative fatigue? CTR dropped 30%+ week over week = swap, don't lower bids.
— Offer still converting on the network side? Ping your AM before you blame yourself.

Fix one variable. Re-read in 24h.
Go test it.


content:
<b>How to test creatives without burning $2k</b>
Trench note: test 3 angles, not 30. Here's the grid.

— Lock everything except the variable. Same GEO, same preland, same bid.
— Round 1: 3 ANGLES only (e.g. weight-loss → 'doctor secret' vs 'lazy-person hack' vs 'one weird food'). $50 each, 24h.
— Kill 2, keep the angle that printed CTR.
— Round 2: 3 HOOKS inside the winning angle. Same budget, same window.
— Round 3: 3 thumbnails. Now you scale the survivor.

Never change angle + hook + image at once — you'll learn nothing.
Log every round in a sheet. Your next vertical starts from data, not vibes.
Go test it.


content:
<b>Self-audit your nutra preland before it gets flagged</b>
Trench note: review your own page like a pissed-off compliance bot. Run this before you spend a dollar.

— Search the page for: 'cure', 'treat', 'guaranteed', 'FDA', 'clinically proven.' Delete or soften every hit.
— Any before/after photo? Add a disclaimer near it. 'Results not typical' — small but present.
— Testimonials: add first name + 'individual results vary.'
— No disease names as claims. 'Supports healthy blood sugar' lives; 'reverses diabetes' dies.
— Footer: privacy, terms, contact, disclaimer block. Empty footer = instant flag.

Frame everything as a story and a testing angle, never medical fact.
Go test it.


content:
<b>How to actually use a spy tool (not just scroll it)</b>
Trench note: spy tools are a research weapon, not a netflix. Workflow:

— Filter: your vertical + your GEO + last 30 days + sort by 'days running.'
— Anything live 60+ days = proven. That's your study list, ignore the rest.
— Screenshot the top 10. Note: the angle, the first 5 words of the hook, the thumbnail object.
— Find the PATTERN across all 10. If 7 use a 'food to avoid' angle, that's the GEO's hot button.
— Don't clone the winner. Clone the pattern, write fresh.

One hour of this beats a week of guessing.
Go test it.


content:
<b>Build a skin/beauty offer angle from scratch</b>
Trench note: beauty buyers don't want product, they want the mirror moment. Build for that.

— Pick the enemy: wrinkles, dark spots, sagging — ONE, not all three.
— Mechanism over magic: 'collagen scaffolding' beats 'glows.' Sounds like science, frames as testing claim.
— Age-gate the hook. '50+' or '40+' in the headline filters and converts harder.
— Before/after is king here, but use 'real woman' ugly-light photos, not glam.
— CTA emotion: not 'buy now' — 'see the 4-week change.'

Upsell path: serum buyer → the 'night routine' bundle.
Go test it.


content:
<b>Build a native whitelist from a cold RON run</b>
Trench note: the whitelist IS the asset. Here's how to mine it.

— Run RON (run-of-network) 3-5 days, enough for 200+ clicks per top source.
— Export by source/widget ID. Sort by ROI, then by conversions (1 fluke conv lies, 5 don't).
— Tier them: A = 1.5x+ ROI, B = breakeven, C = bleeders.
— Blacklist all C immediately. Park B for a creative retest.
— Build a campaign that targets ONLY A-tier. Bid up 15% — you want to own those spots.

Reuse this whitelist on your NEXT offer in the same vertical. That's the compounding part.
Go test it.


content:
<b>Anatomy of a weight-loss preland that converts</b>
Trench note: ship the page in this exact block order. Tested across a dozen GEOs.

— Block 1: a question hook tied to a specific frustration ('Still bloated by noon?').
— Block 2: relatable villain — not the reader, the cause. 'It's not your willpower, it's X.'
— Block 3: the mechanism. One paragraph, sounds scientific, stays a creative claim.
— Block 4: the 'ordinary person' story arc with a number and a timeline.
— Block 5: 3 testimonials, ugly photos, varied body types.
— Block 6: CTA + scarcity (real-ish stock count, not a fake 90s timer).

Delete anything that doesn't move them to the next block.
Go test it.


content:
<b>Tracker setup checklist before you spend a cent</b>
Trench note: launching without clean tracking = lighting money on fire blindfolded. Run this.

— Postback fires a TEST conversion end-to-end. Don't trust 'it should work.'
— Tokens passing: source ID, widget/site ID, creative ID, GEO. If you can't see widget ID, you can't optimize.
— Cost passing in (CPC or CPM) so ROI is automatic, not manual math.
— Redirect chain under 2 hops. Every hop leaks clicks.
— Mobile redirect tested on a real phone, not just desktop devtools.
— S2S, not pixel, wherever the network allows.

Break tracking and your whole data set is fiction.
Go test it.


content:
<b>Mine winning angles from the comment section</b>
Trench note: your best hooks are already written — by customers. Go dig.

— Find 3 competitor offers or Amazon listings in your vertical.
— Sort reviews/comments by 'most helpful' and by 1-3 stars (pain) AND 5 stars (dream outcome).
— Copy the exact phrases people use. 'I finally stopped hiding in photos' beats any copywriter line.
— Tag them: fear, frustration, dream, objection.
— Build hooks from the frustration tags, CTAs from the dream tags.

Real language out-converts clever language every time.
Go test it.


content:
<b>Set up a rebill flow that doesn't get chargebacks</b>
Trench note: rebills make the LTV, chargebacks kill the merchant account. Walk the line.

— Disclose the auto-ship ABOVE the buy button, not buried in terms. Plain English.
— Confirmation email day 0 restating: amount, date of next charge, how to cancel.
— Reminder email 3 days before each rebill. This single email cuts disputes hard.
— One-click cancel link in every email. Friction here = chargebacks later.
— Soft descriptor on the card statement that matches the brand they bought.

Make canceling easy and fewer people will. Counterintuitive, works.
Go test it.


content:
<b>Make your nutra landing load in under 2 seconds</b>
Trench note: on native mobile, every extra second eats ~10% of clicks. Fix it in order.

— Compress hero image to under 100kb. WebP, not PNG. This alone often halves load.
— Strip every tracking script you don't read daily. Most pages carry 4 dead pixels.
— Inline critical CSS, defer the rest. No render-blocking junk above the fold.
— Lazy-load everything below the fold — testimonials, footer images.
— Host on a CDN, not your $4 shared box.
— Re-test on throttled 'Fast 3G' in devtools, not your wifi.

Speed is the cheapest conversion lift you'll ever ship.
Go test it.


content:
<b>Vet a nutra offer before you commit budget</b>
Trench note: a hot payout on a dead offer just bleeds you faster. Vet first.

— Ask the AM: what's the current EPC and how old is the offer? New + high EPC = real. Old + declining = dying.
— Check the cap. Tiny cap means you scale and get cut at the good part.
— Look at the actual landing/checkout. Ugly, slow, or sketchy = your traffic dies there, not your fault but your loss.
— Confirm the GEOs and traffic sources allowed. Run native on a 'search only' offer = wasted week.
— Ask which angles are converting NOW. AMs know, just ask straight.

No straight answers? Different offer.
Go test it.


content:
<b>Build an advertorial bridge that warms cold native clicks</b>
Trench note: cold native traffic isn't ready to buy — it's ready to READ. Build the bridge.

— Frame it as editorial, not an ad. 'Local mom discovers...' news skin, with a 'sponsored' tag (keep it honest).
— Open with the story, not the product. 200 words before any brand name shows up.
— Drop the mechanism mid-story, casually.
— First CTA only after they're invested — roughly 60% down the page.
— Match the bridge's vibe to the ad creative. Mismatch = bounce.

The bridge does the selling. The offer page just takes the order.
Go test it.


content:
<b>When to call a split test (without a stats degree)</b>
Trench note: most buyers call winners way too early and ship noise. Use this rule of thumb.

— Don't even look until each variant has ~25-30 conversions. Below that it's vibes.
— A 5% CTR gap at 100 clicks means nothing. Same gap at 2,000 clicks is real.
— Run a full 7 days if you can — weekday and weekend buyers behave differently.
— Same daypart for both, or you're testing time-of-day, not creative.
— If two variants are within ~10% after enough data, call it a tie and keep the cheaper one to run.

Patience is an edge. Most won't have it.
Go test it.


content:
<b>Scale a winner from $100 to $1k a day without killing it</b>
Trench note: scaling isn't a slider, it's a staircase. Climb it.

— Step 1: budget +20% per day on the SAME campaign. Algo needs to re-learn, don't shock it.
— Step 2: duplicate the winner into 2-3 new campaigns with fresh budgets — parallel, not bigger.
— Step 3: clone the whitelist into a NEW geo of the same language tier.
— Step 4: refresh creatives BEFORE fatigue, not after. New angle queued and ready.
— Step 5: watch frequency. Native frequency creep = rising CPMs = thinning margin.

Double too fast and the algo resets your whole learning. Slow is fast.
Go test it.


content:
<b>Squeeze a dead thank-you page for extra revenue</b>
Trench note: your thank-you page is prime real estate sitting empty. Fill it.

— Drop a second relevant offer right there — they just proved they buy in your vertical.
— Add a 'refer a friend, get a free bottle' line. Costs nothing, occasionally prints.
— Push them to the email list with a content hook ('5 foods making it worse' PDF).
— If you run a network, slot in a content-recommendation widget for residual cents per visitor.
— Survey them: 'what made you buy?' One question. Free angle research forever.

Every converter touches this page. Stop wasting the visit.
Go test it.


content:
<b>A creative-refresh system so you never run dry</b>
Trench note: the buyers who never go red are the ones with creatives in the bank. Build the system.

— Every Monday: produce 5 new creatives, win or lose. Non-negotiable cadence.
— Keep a 'morgue' folder of old winners — rotate them back after 30 days, they re-perform.
— Track CTR by creative day over day. The day it drops 20% from peak, the replacement is already queued.
— Vary ONE element per new batch (angle / thumbnail / headline) so you keep learning while you refresh.
— Steal your own winners across GEOs before you ever start from a blank page.

Fatigue is scheduled, not surprising. Plan for it.
Go test it.


channel_name: Arb Files

content:
The 3-touch kill rule that saved my account

I used to let ads die slow. Now I run a fixed kill protocol on every new creative, and it stopped me from torching budgets on hope.

The setup
New offer, push traffic, $7 target CPA. I launch 12 creatives at $15/day each = $180/day live.

The move
Three hard gates, checked in order:
— Gate 1, at 1x payout spend ($7): zero clicks to LP? Kill. No data needed, the angle is dead.
— Gate 2, at 2x payout ($14): traffic but zero conversions and CTR under 0.4%? Kill.
— Gate 3, at 3x payout ($21): one conversion but CPA over $11 (1.5x target)? Pause, don't scale.

The numbers
Of 12 creatives, 7 died at Gate 1-2 having spent ~$95 total. Survivors got the remaining budget. Day-7 blended CPA landed at $6.40, ROI +9%.

The lesson
Most losers reveal themselves by 2x payout spend. Waiting for "statistical significance" on a dead angle is just paying tuition twice.

What I'd do differently
I'd write the gates into a saved automated rule instead of checking manually at 2am. I missed a Gate-2 kill once and that one creative ate $40 alone. Numbers here are illustrative, the discipline is the point.


content:
My 9-point pre-launch checklist (built from blown launches)

Every item on this list exists because skipping it once cost me money. Run it before a single dollar goes live.

The checklist
— Pixel fires? Open the LP, trigger the event, confirm in the platform's test tool. (Skipped once, ran blind 3 days, ~$220 unattributable.)
— Postback test conversion logged in the tracker? Send one manually.
— Cloaker, if used, shows safe page to the bot IP and money page to the geo? Test with a VPN.
— Offer cap not already hit for the day? Ask the manager.
— Geo/device targeting matches the offer's allowed list, not just "all".
— LP load under 2.5s on 3G throttle? Slow LP = bleeding the top of funnel.
— Capping/frequency set so you don't pay for the same user 6 times.
— Daily budget cap set, not just bid. One typo on a CBO and you wake up to $900 spent.
— Tracking links have the right sub-IDs to slice later.

The numbers
This list takes ~20 minutes. The launch it saved most: a broken postback would've hidden $1,100 in real conversions, making me kill a winner.

The lesson
The expensive mistakes aren't bad creatives, they're invisible plumbing failures.

What I'd do differently
Laminate it. Figures illustrative, the order is not.


content:
How I scale a winner without killing it: the 20% ladder

The fastest way to murder a profitable campaign is to double the budget overnight. Here's the slow ladder that actually holds ROI.

The setup
Winning campaign: $50/day spend, $11 CPA on a $14 payout, ROI +27%, stable for 5 days.

The move
Two lanes, run in parallel:
— Vertical: raise budget by 20% max per day, only if yesterday's CPA stayed under target. $50 to $60 to $72. Anything above 20% retriggers the learning phase and resets your math.
— Horizontal: duplicate the winning ad set into 1 new geo and 1 new placement at $20/day each, fresh, not as a budget bump.

The numbers
Vertical lane reached $124/day over 8 days, CPA crept to $12.10 (still green). Horizontal lane found a second geo at $9.80 CPA, better than the original.

The lesson
Vertical scaling compresses margin as you exhaust the cheap audience. Horizontal scaling finds new cheap audiences. You need both, and horizontal is usually where the real money hides.

What I'd do differently
I moved vertical too aggressively on day 6, CPA spiked to $15 for a day, lost ~$40 reclaiming stability. Cap it at 20%, period. Illustrative numbers.


content:
The creative test grid: stop guessing which variable matters

I wasted months changing five things at once and learning nothing. Then I built a variable grid.

The setup
Nutra offer, native traffic, flat results from random creatives.

The move
Isolate ONE variable per round. Round 1 = hook only. Pick one image, one body, write 4 different headlines. Everything else identical.
— Round 1: headlines (4 variants)
— Round 2: take winning headline, test 4 images
— Round 3: winning headline + image, test 4 angles in the body
— Round 4: winning combo, test 3 CTAs

Each round runs to ~2x payout spend per variant, then you lock the winner and move down.

The numbers
Headline round alone swung CTR from 0.6% to 1.4%. By round 3 the compounded combo hit $5.20 CPA vs the $9 I started with. Total testing spend: ~$310 across four rounds.

The lesson
The headline usually carries 60-70% of the lift. Test it first, in isolation, before you touch anything else.

What I'd do differently
Fewer variants per round (3, not 4) to spend less reaching a verdict. Numbers illustrative.


content:
How to read the break-even window before you trust ROI

Day-1 ROI lies. Here's the playbook I use to know when a number is real.

The setup
Lead-gen offer, payout confirmed on a 7-day hold. My tracker shows ROI instantly, but money lands later.

The move
— Step 1: find the offer's actual payment terms. Confirmed vs pending vs scrubbed. Ask, don't assume.
— Step 2: build two ROI lines. "Reported ROI" (what the tracker says now) and "Confirmed ROI" (after expected scrub %).
— Step 3: apply a scrub haircut. New offer with no history? Assume 15-20% of leads reject until you have data.
— Step 4: only scale on Confirmed ROI, never Reported.

The numbers
Reported ROI showed +34%. Manager's scrub came in at 22%. Confirmed ROI: +5%. I almost scaled hard on a campaign that was barely green.

The lesson
Reported ROI is a hypothesis. Confirmed ROI is the business. The gap between them is where over-scaling kills accounts.

What I'd do differently
Log the scrub rate per offer in a sheet so the haircut gets accurate over time instead of a guess. Figures illustrative.


content:
The 6-question post-mortem I run on every dead campaign

A failed campaign you don't autopsy is just an expensive feeling. Here's the form I fill out before I move on.

The setup
Dating offer, $400 spent, $260 revenue, ROI -35%. Dead. Now what.

The move
Six questions, answered in writing:
— Where did it break? Funnel stage: impression, click, LP, or conversion?
— My CTR was fine (1.1%) but LP-to-conversion was 0.8% vs offer average ~2%. Break was the LP.
— Was it the offer, the angle, or the traffic source? (Cross-check: same angle on a different source.)
— What did I assume that turned out false? I assumed the offer's own LP was optimized. It wasn't.
— What's the cheapest test to confirm the diagnosis?
— Keep, kill, or rebuild?

The numbers
LP was the culprit. I built my own pre-lander, relaunched the SAME traffic, LP-to-conversion went 0.8% to 1.9%. The campaign that lost $140 turned +18%.

The lesson
Most "bad offers" are bad funnels. Diagnose the stage before you blame the whole thing.

What I'd do differently
Run the post-mortem at $200 spend, not $400. Illustrative numbers.


content:
Source-to-offer matching: the playbook for not forcing bad pairs

Half my early losses were great offers on the wrong traffic. Here's how I match before I launch.

The setup
I had a high-intent finance offer paying $40/lead and kept losing money on it.

The move
Match on three axes before committing budget:
— Intent: high-payout finance/insurance wants high-intent (search, in-feed native with strong pre-sell), not impulse pop traffic.
— Speed of decision: sweepstakes and dating convert fast, fit interruptive sources (pops, push). Considered purchases don't.
— User mindset on the source: push = re-engagement, native = discovery, search = active demand. Pick offers that fit the mindset.

Grid it: list your offer's intent level, then only test sources in the matching tier.

The numbers
Finance offer on pops: -50% ROI over $180. Same offer on native with an advertorial pre-sell: +22% over the next $300.

The lesson
A good offer on mismatched traffic looks exactly like a bad offer. You'll blame the wrong thing.

What I'd do differently
Build the source-tier grid once, reuse it on every new offer. Figures illustrative.


content:
The playbook for fighting margin compression as you scale

Every scaled campaign decays. Here's the checklist I run when ROI starts sliding from green to gray.

The setup
Campaign was +30%, now drifting toward +8% at higher spend. Classic compression.

The move
Work the levers in this order (cheapest fix first):
— Refresh creatives. Frequency over 2.5 usually means fatigue. New angle, same offer.
— Exclude the worst placements/sub-IDs. Pull the report, cut the bottom 20% of sources by ROI.
— Renegotiate payout. At volume, ask the manager for a bump. A $1 raise on a $14 offer is ~7% margin back, free.
— Add a fresh geo to dilute the saturated one.
— Last resort: lower bid and accept less volume at better margin.

The numbers
Creative refresh recovered +6%. Cutting bottom sub-IDs added +4%. A negotiated $1.50 payout bump added the rest. Back to +21%.

The lesson
Compression is rarely one cause. Pull levers in order of cost, the payout bump is the most overlooked and the cheapest.

What I'd do differently
Ask for the payout bump earlier, managers reward volume you already have. Illustrative numbers.


content:
When is a split test actually done? My stopping rules

I used to call winners at 30 clicks and waste money on noise. Here are the rules I use now to stop a test honestly.

The setup
Two landing pages, A vs B, $14 payout offer.

The move
Three stopping conditions, whichever hits first:
— Conversions, not clicks: wait until the leading variant has at least 25-30 conversions, not 30 clicks. Conversions are the unit that pays you.
— Spend floor: each variant must spend at least 3x payout before any verdict. Below that it's a coin flip.
— Gap test: if after the floor the CPA difference is under 15%, call it a tie and pick the cheaper-to-run one. Tiny gaps don't survive scale.

The numbers
LP-A looked like a winner at 8 conversions (CPA $9). By 28 conversions it had reverted to $12.50, dead even with LP-B. I'd have scaled the wrong page.

The lesson
Early leaders regress. The first 10 conversions are mostly luck.

What I'd do differently
Write the stopping rule before launch so I'm not tempted to call it early when I'm impatient. Figures illustrative.


content:
The 7 questions I ask an affiliate manager before I run their offer

The vetting call is the cheapest risk reduction in arbitrage. Here's my exact script.

The setup
New offer in the network, great payout on paper. Before budget, I get the manager on a call.

The move
Seven questions:
— What's the current scrub/rejection rate, and over what window?
— What's the daily cap, and is it close to full?
— Which traffic sources are top performers right now? (Tells me what's working.)
— What's the average EPC other affiliates are seeing?
— Are there hidden restrictions: incent, brand bidding, specific geos inside the geo?
— What's the payment term and minimum payout?
— If I send quality volume, can we discuss a payout bump?

The numbers
On one call the manager admitted the cap was 90% full by noon daily. I'd have scaled into a wall and torched ~$200 on capped-out traffic. Skipped it.

The lesson
Managers know which campaigns are dying and which are exploding. They'll tell you if you ask the right way.

What I'd do differently
Record answers per offer so I can hold them to the scrub number later. Illustrative figures.


content:
How I split a $1,000 test budget across offers (the 70/20/10 rule)

Throwing equal money at everything is how you learn nothing slowly. Here's my allocation playbook.

The setup
Monthly test budget $1,000. Three buckets of offers competing for it.

The move
— 70% to proven: campaigns already green get the bulk. Defend and scale what works.
— 20% to promising: campaigns that broke even or showed one good signal. Give them a real shot.
— 10% to wild: brand-new offers/angles with no data. Cheap lottery tickets.

Rebalance weekly. A wild that hits graduates to promising, a promising that wins graduates to proven, losers free their budget.

The numbers
The 10% wild bucket ($100) found a sweepstakes angle that became my top earner at +40%. The 70% kept the lights on. Without a dedicated wild slice I'd never have tested it, the proven stuff always felt safer.

The lesson
With no forced exploration budget, you over-invest in known winners and miss the next one. The 10% is insurance against staleness.

What I'd do differently
Never let the wild bucket roll into proven mid-week, the discipline is the point. Numbers illustrative.


content:
The pre-flight checklist before running a gray-hat campaign

If you run aggressive verticals, sloppy setup gets your account and your money gone. This is the safety pass, framed as risk control.

The setup
Aggressive vertical, compliance-sensitive platform. One mistake = ban and frozen balance.

The move
— Separate everything: dedicated card, dedicated profile, dedicated domain age. No reuse across accounts.
— Warm the account: small clean spend for a few days before the real push.
— Domain check: fresh domain with no prior flags, SSL valid, privacy WHOIS.
— Test the safe page from a real reviewer-geo IP, confirm it's genuinely innocuous.
— Keep balance low: never hold more in the account than you can lose. Withdraw earnings fast.
— Have account #2 fully built and warmed BEFORE you need it.

The numbers
Kept account balances under $150 each. When one got banned mid-campaign, the frozen loss was $130, not $1,400, and account #2 went live in 20 minutes.

The lesson
Assume the ban is coming. Build so it costs you a rounding error, not the business.

What I'd do differently
Warm account #2 a week earlier. Numbers illustrative, not an endorsement, manage your own risk.


content:
How to build a pre-lander that lifts CR: my 5-step build

The pre-lander is the cheapest CR lever most people ignore. Here's the exact build order.

The setup
Direct-linking an offer's own LP, CR stuck at 1.2%.

The move
— Step 1, the hook bridge: the pre-lander's headline must continue the ad's promise, not restate it. Seamless thought, not a repeat.
— Step 2, the agitation: one short paragraph on the pain, in the reader's own words.
— Step 3, the mechanism: why this solution works, plausibly. Builds the belief the offer page assumes.
— Step 4, social proof: 2-3 specific, modest testimonials. Not "amazing!!!", but "dropped 6 lbs in 3 weeks."
— Step 5, the soft CTA: a single button, no menu, no distractions, pre-frames the offer page.

The numbers
Adding the pre-lander took CR from 1.2% direct to 2.6%. CPA dropped from $11 to $5.40. Build time: ~2 hours.

The lesson
The offer page assumes the user is already warm. The pre-lander does the warming. That's the whole job.

What I'd do differently
Test 2 pre-lander angles from the start instead of one. Figures illustrative.


content:
My 15-minute daily optimization routine (same order every day)

Random dashboard-staring burns hours and finds nothing. Here's the fixed sequence I run each morning.

The setup
6-8 campaigns live, limited time, easy to fiddle aimlessly.

The move
Same five passes, in order:
— Pass 1: check spend vs cap, catch any runaway from overnight. (Caught a $200 overspend once from a bad rule.)
— Pass 2: kill anything past its kill-gate from yesterday.
— Pass 3: pull sub-ID/placement report, cut the bottom performers bleeding budget.
— Pass 4: check frequency, flag creatives over 2.5 for refresh.
— Pass 5: note winners eligible for a 20% scale, queue them.

No creative building, no new launches in this window. Optimization only.

The numbers
Separating "optimize" from "build" cut my screen time from ~90 min of fidgeting to 15 focused minutes, and ROI improved because I stopped over-tinkering with stable campaigns.

The lesson
Over-optimization is a real tax. A fixed routine stops you from "fixing" things that are fine.

What I'd do differently
Do the routine once a day, not five times. Touching stable campaigns resets learning. Illustrative numbers.


content:
How to read a sub-ID report and cut the dead weight

Most campaigns are profitable on average and bleeding underneath. The sub-ID report is where you find the leak.

The setup
Campaign at break-even, $300 spent, $300 back. Looks dead. It wasn't.

The move
— Step 1: pull conversions by sub-ID (placement, site, widget, whatever your source exposes).
— Step 2: sort by spend, then look at ROI per source, not the blended average.
— Step 3: find the "whales of waste", the 3-4 sources eating big budget with zero or terrible conversions.
— Step 4: blacklist them. Then re-evaluate, don't kill the campaign on the blended number.
— Step 5: find the hidden gems, low-spend sources with great ROI, and bid them up.

The numbers
Four placements had eaten $90 with ONE conversion between them. Blacklisted. The remaining traffic was running at +35%. The "dead" campaign was a winner with four parasites attached.

The lesson
Blended averages hide both your winners and your leaks. The money is in the breakdown.

What I'd do differently
Check sub-IDs at $150 spend, not $300. Figures illustrative.


content:
How to expand a winner into a new geo without restarting from zero

A proven angle in one country is a head start in the next, if you transplant it right. Here's my expansion order.

The setup
Winning campaign in tier-1 country A, +28%. Want to test country B.

The move
— Step 1: confirm the offer actually pays in geo B and check the payout, it's often lower in tier-2.
— Step 2: localize properly, real translation of the pre-lander, not machine output. Currency, formats, names.
— Step 3: reset CPA expectations to geo B's economics. Lower payout means lower acceptable CPA, recalc break-even before launch.
— Step 4: launch the winning angle FIRST, don't re-test angles you already proved. Test only what's geo-specific (language, local proof).
— Step 5: separate campaign, separate budget, never bolt geo B onto geo A's ad set.

The numbers
Geo B payout was $9 vs $14 in geo A. Same angle, but I recut break-even, found CPA had to stay under $7. It landed at $6.20, +18%. Skipping step 3 would've made me scale a loser thinking it matched geo A.

The lesson
Transplant the angle, recalculate the economics. Both, or you'll misread the result.

What I'd do differently
Check the localized translation with a native speaker first. Illustrative numbers.


content:
The tracker audit I run before trusting a single number

A misconfigured tracker turns every decision into a guess with extra steps. Here's the audit I run on every new setup.

The setup
New tracker, new offer, new source. Everything connected "correctly" in theory.

The move
— Check 1: fire a real test conversion end to end. Click, convert, confirm it shows in the tracker with the right payout.
— Check 2: verify the postback passes the sub-IDs through, not just the conversion. No sub-IDs = blind optimization later.
— Check 3: confirm cost data is flowing (S2S or API), so ROI is automatic, not hand-typed.
— Check 4: test a duplicate-click, make sure it's not double-counting.
— Check 5: check timezone alignment between source, tracker, and network. Mismatched days wreck daily reports.

The numbers
Found a timezone mismatch once, my "today" and the network's "today" were 7 hours off. Made a profitable day look like a loss, almost killed a +25% campaign.

The lesson
You're not optimizing a campaign, you're optimizing what the tracker tells you about it. Garbage in, account dead out.

What I'd do differently
Keep a saved test-conversion checklist per source. Figures illustrative.


content:
How I find a fresh angle before competitors do: my research loop

The creative is downstream of the angle. Here's the exact loop I run to find one that isn't burned out.

The setup
Saturated vertical, everyone running the same three angles. Need a fourth.

The move
— Step 1: read the offer's negative reviews and complaints. The objections people have ARE the next angle ("but does it work without X?").
— Step 2: scrape forum/Reddit threads in the niche for the language real users use, not marketer-speak.
— Step 3: spy on what's running, then deliberately do the opposite emotional angle (everyone's using fear? Test curiosity).
— Step 4: list 5 angle hypotheses, rank by how different they are from what's saturated.
— Step 5: test the most-different one first.

The numbers
The winning angle came straight from a complaint thread, people doubted the offer worked for a specific subgroup. Built a creative addressing exactly that. CTR 1.6% vs the 0.7% the tired angles were getting, CPA $4.90.

The lesson
The fresh angle is usually sitting in the objections, not in a swipe file everyone already copied.

What I'd do differently
Keep a running doc of objections per vertical. Illustrative numbers.


content:
The cash-flow playbook that keeps you alive between payouts

Profitable arbers go broke on timing, not on ROI. Here's how I manage the gap between spending and getting paid.

The setup
Spend is daily and instant. Network pays net-7, net-15, sometimes net-30. The gap is where accounts die.

The move
— Step 1: know every offer's exact payment term, write it down. Sort offers by how fast they pay.
— Step 2: size your daily spend to your float, not your ambition. Float = cash you can deploy before the first payout lands.
— Step 3: on a new network, run weekly payouts even at a fee until trust is built. Faster cash beats slightly higher net.
— Step 4: keep a reserve equal to your worst-case payment gap, never deploy it.
— Step 5: scale spend only as confirmed payouts actually hit the bank, not as the tracker turns green.

The numbers
I once had +30% ROI on paper but $4,000 stuck in net-30 while my cards were maxed. Couldn't scale the winner because I had no cash. The reserve I built after that was ~1.5x my biggest payment gap.

The lesson
ROI is the scoreboard. Cash flow is whether you're still in the game to play it.

What I'd do differently
Negotiate weekly payouts from day one. Figures illustrative.


content:
The creative refresh cadence that beats ad fatigue: my system

Winning creatives die on a schedule. Here's the rotation I run so the campaign never goes cold.

The setup
Winning creative, +25%, but I know fatigue is coming. The question is when and what to do.

The move
— Trigger 1: frequency hits 2.5, or CTR drops 20% off its peak. That's the fatigue signal, not a calendar date.
— Step 1: keep the winning ANGLE, change the execution, new image, new hook framing, same core promise.
— Step 2: always have 2 fresh variants queued BEFORE the winner fatigues, so there's no gap.
— Step 3: rotate the new variant in alongside the tiring one, don't kill the old one cold, let it taper.
— Step 4: log which executions of the angle worked, so you build a library, not start blank each time.

The numbers
Waiting for fatigue with nothing queued cost me a 2-day dip to +6% while I scrambled. With variants pre-built, the next refresh held the campaign at +22% through the transition, zero gap.

The lesson
Fatigue is inevitable and predictable. The cost isn't the fatigue, it's not having the next creative ready.

What I'd do differently
Queue variants when the creative first wins, not when it starts dying. Illustrative numbers.


cluster: webmaster

channel_name: Bid Stack 101

content:
<b>How to pick your first timeout (in 5 steps)</b>

A timeout is the deadline you give partners to bid. After it passes, the auction closes — even if money is still coming in.

The playbook:
— 1. Open your browser dev tools, Network tab, and reload your page 10 times.
— 2. Watch how long your bid requests take to come back.
— 3. Find the point where 8 out of 10 partners have answered.
— 4. Set your timeout slightly above that number (often 1000-1500ms).
— 5. Watch revenue and page speed for one week before changing anything.

Too short, you leave money on the table. Too long, your page feels slow.

In plain English: time how fast bids arrive, then set the deadline just past where most of them land.


content:
<b>Adding your first demand partner, step by step</b>

A demand partner is a company that pays to show ads on your site — they 'bid' for your ad space.

The checklist:
— 1. Sign their agreement and get your account approved (this can take days).
— 2. Ask them for your 'bidder code' and 'placement IDs' — the labels that tell them which ad slot is which.
— 3. Add their code to your setup, one ad slot at a time.
— 4. Load your page and check their bid request actually fires.
— 5. Wait 48 hours, then look at whether they're winning any auctions.

Don't add five partners on day one. Add one, confirm it works, then add the next.

In plain English: onboard one partner fully, prove it bids, then move on.


content:
<b>Setting a floor price without guessing</b>

A floor price is the lowest amount you'll accept for an ad. Bids below it get ignored.

The method:
— 1. Pull your last 30 days of winning bids for one ad slot.
— 2. Find the price that 20% of winners paid below (your 20th percentile).
— 3. Set your floor just under that number — not at your average.
— 4. Run it for a week and watch your 'fill rate' (how often the slot gets an ad).
— 5. If fill drops hard, lower the floor a little. If revenue rises, hold.

A floor that's too high means empty ad slots and zero earnings there.

In plain English: floor below your weakest real winners, then nudge it carefully.


content:
How to confirm your wrapper actually loaded

A wrapper is the bit of code that runs the whole auction on your page — it calls all the partners and picks the winner.

The check:
— 1. Open your page, then open dev tools and go to the Console tab.
— 2. Type the name of your wrapper object (for Prebid it's pbjs) and press Enter.
— 3. If you see an object, not 'undefined', the wrapper is alive.
— 4. Type pbjs.getBidResponses() to see who actually bid.
— 5. Empty result? Your partners aren't wired in yet.

Many 'it's not working' problems are just a wrapper that never loaded.

In plain English: ask the page directly if the auction code woke up before blaming anything else.


content:
<b>Choosing client-side or server-side (a quick decision tree)</b>

Client-side means the auction runs in the visitor's browser. Server-side means it runs on a remote computer instead.

Walk the tree:
— 1. Do you have under 6 partners? Stay client-side — it's simpler.
— 2. Is your page getting slow with each new partner? Lean server-side.
— 3. Do you need precise control and easy debugging? Client-side wins.
— 4. Are you adding 10+ partners? Server-side keeps the browser light.
— 5. Unsure? Start client-side, move heavy partners to server later.

Most sites run a mix: a few in the browser, the rest on a server.

In plain English: few partners stay in the browser; once it gets crowded, push the extras to a server.


content:
Nobody's bidding — a 5-step diagnosis

When an ad slot earns nothing, work through the chain in order, not at random.

The playbook:
— 1. Confirm the wrapper loaded (in the Console, pbjs should exist).
— 2. Check the bid request fired — look in the Network tab for calls to your partners.
— 3. Confirm your placement IDs match what the partner gave you (one typo kills it).
— 4. Make sure your timeout isn't so short that bids arrive too late.
— 5. Check your floor price isn't set above every bid.

Fix the earliest broken link first; later steps often heal themselves.

In plain English: follow the bid from code, to request, to ID, to timeout, to floor — top down.


content:
Installing Prebid for the first time, in order

Prebid is free, popular software that runs your header bidding auction.

The steps:
— 1. Go to the Prebid download page and pick only the partner 'modules' you actually use.
— 2. Build the file (the site does it for you) and host it on your own server.
— 3. Add it to the very top of your page's head section, before your ad code.
— 4. Define your ad slots and which partners bid on each.
— 5. Load the page and run pbjs.getBidResponses() to confirm bids land.

Downloading every module makes a huge, slow file. Pick only what you need.

In plain English: grab just your partners' modules, host it yourself, put it first, then test.


content:
<b>Measuring how much header bidding slows your page</b>

Every auction adds a little delay. You want to know exactly how much.

The test:
— 1. Note your page's load time with the auction code switched on.
— 2. Comment out the wrapper and load the page again — that's your baseline.
— 3. Subtract: the difference is your real header bidding cost in milliseconds.
— 4. If it's over 500ms, your timeout is likely too generous.
— 5. Trim the timeout by 200ms and re-measure before touching anything else.

Do this on a phone over a normal connection, not just fast office WiFi.

In plain English: load the page with and without the auction, and the gap is what header bidding costs you.


content:
<b>How to fire a partner that never wins</b>

Dead-weight partners still send requests, slowing your page while earning nothing.

The cleanup:
— 1. Pull 30 days of data: how often each partner bid vs how often they won.
— 2. Flag anyone with a win rate near zero who still adds load time.
— 3. Email them once — sometimes a config fix wakes them up.
— 4. No improvement in two weeks? Remove their module from your build.
— 5. Re-measure page speed; you'll usually see it drop.

More partners isn't always more money. Three strong ones beat ten lazy ones.

In plain English: track who bids but never wins, give one warning, then cut them and enjoy the faster page.


content:
<b>Giving each ad slot its own floor price</b>

One floor for the whole page is lazy — your top banner is worth more than a footer ad.

The playbook:
— 1. List your ad slots from most to least valuable (top of page usually wins).
— 2. Pull 30 days of winning bids per slot, separately.
— 3. Set each slot's floor just below its own weak winners.
— 4. Give your best slot a higher floor; your weakest a lower one.
— 5. Review fill rate per slot after a week and adjust the outliers.

A blanket floor either chokes your weak slots or undersells your strong ones.

In plain English: price each ad spot on its own merit, not with one number for the whole page.


content:
<b>Checking your ads.txt is correct, line by line</b>

ads.txt is a public file listing who's allowed to sell your ad space. Buyers check it before bidding.

The audit:
— 1. Visit yoursite.com/ads.txt in a browser — it must load, plain text, no errors.
— 2. Confirm every demand partner gave you their exact line to paste.
— 3. Check there are no duplicate or expired lines from old partners.
— 4. Match each partner's seller ID character for character.
— 5. Re-upload and wait — buyers re-crawl it every day or two.

A missing line means some buyers silently refuse to bid on you.

In plain English: make sure the public 'who can sell my ads' file loads and lists every current partner correctly.


content:
<b>Setting different timeouts for desktop and mobile</b>

Mobile visitors are on slower connections, so bids take longer to arrive there.

The approach:
— 1. Time your bid responses separately on desktop and on a phone.
— 2. You'll usually find mobile is 200-400ms slower.
— 3. Set a tighter timeout for desktop where bids come back fast.
— 4. Give mobile a little more room so good bids aren't cut off early.
— 5. Re-check both after a week — connections and partners change.

Using one timeout for both either rushes mobile or drags desktop.

In plain English: time bids on each device and give the slower one a slightly longer deadline.


content:
<b>Testing a server-side setup before you trust it</b>

Server-side means the auction runs on a remote computer, so you can't watch it in your own browser as easily.

The checklist:
— 1. Move just one partner to server-side first, keep the rest in the browser.
— 2. In the Network tab, find the single call to your server endpoint.
— 3. Confirm it returns bids, not an error code like 400 or 500.
— 4. Compare that partner's win rate before and after the move.
— 5. Win rate held steady? Move the next partner. Dropped? Roll it back.

Never switch every partner to server-side in one go — you'll have no idea what broke.

In plain English: move one partner to the server, prove it still wins, then move the next.


content:
Reading your auction results like a report card

After every auction, your wrapper keeps a record of who bid and how much.

The routine:
— 1. In the Console, run pbjs.getBidResponses() to see all bids for the page.
— 2. Note each partner's price and whether their bid arrived in time.
— 3. Run pbjs.getAllWinningBids() to see who actually won each slot.
— 4. Spot partners who bid high but always arrive 'too late' — a timeout clue.
— 5. Do this weekly; patterns matter more than one page load.

These two commands answer most 'why am I not earning more' questions for free.

In plain English: ask the wrapper who bid and who won, and let the pattern guide your next change.


content:
<b>Turning on lazy loading the safe way</b>

Lazy loading means an ad's auction only runs when the visitor scrolls near it, saving speed and unseen requests.

The steps:
— 1. Pick your below-the-fold slots first — never the ad people see instantly.
— 2. Set the trigger distance to about one screen-height before the slot.
— 3. Confirm the auction fires only on scroll, in the Network tab.
— 4. Watch your 'viewability' (how often ads are actually seen) — it should rise.
— 5. Check revenue didn't fall; if it did, widen the trigger distance.

Lazy-loading your top banner is a classic mistake — it delays the ad everyone sees.

In plain English: only lazy-load the ads below the fold, fire them just before they're seen, then watch viewability climb.


content:
<b>Matching placement IDs without errors</b>

A placement ID is the label a partner uses to know which of your ad slots is which. One wrong character and they won't bid.

The cross-check:
— 1. Get the partner's official list of placement IDs in writing.
— 2. Open your config and put the two lists side by side.
— 3. Check each ID character by character — copy-paste, never retype.
— 4. Confirm the slot sizes match too (a 300x250 ID won't fill a 728x90 slot).
— 5. Load the page and verify each placement returns a bid.

This single mismatch is the most common reason a new partner 'doesn't work'.

In plain English: copy-paste each ID, line them up, and confirm the sizes agree before testing.


content:
<b>Your monthly header bidding review checklist</b>

Once a month, sit down and run the same five checks so problems never hide for long.

The routine:
— 1. Compare each partner's win rate to last month — flag big drops.
— 2. Recalculate floor prices from the latest 30 days of winners.
— 3. Re-time bid responses; if partners got slower, adjust the timeout.
— 4. Open ads.txt and remove any partner you've dropped.
— 5. Re-measure page speed with and without the auction.

Setups drift. Partners change pricing, connections shift, and old config rots.

In plain English: every month, recheck win rates, floors, timeouts, ads.txt, and speed — the same five, every time.


content:
<b>Correcting a partner that overbids then underpays</b>

Some partners bid high to win, then pay less than promised. A bid adjustment quietly discounts their bids so the auction stays fair.

The method:
— 1. Pull a partner's promised bids vs what they actually paid over 30 days.
— 2. Calculate the average shortfall — say they pay 85% of what they bid.
— 3. Apply a bid adjustment of 0.85 to that partner so their bids count honestly.
— 4. Re-run for two weeks and confirm your real revenue didn't drop.
— 5. Recheck quarterly — these gaps move over time.

Without this, an inflated bidder steals wins from partners who actually pay more.

In plain English: if a partner pays less than it bids, discount its bids by that gap so honest partners can win.


content:
<b>Testing your setup on a real phone, step by step</b>

Fast office WiFi hides timeout problems. Most of your visitors are on phones with patchy signal.

The playbook:
— 1. Connect your phone to your computer and open remote dev tools (it's built in).
— 2. Throttle the connection to 'Slow 4G' to mimic a real visitor.
— 3. Reload your page and time how long bids take to return.
— 4. Note how many partners miss your current timeout on that slower link.
— 5. If many miss it, your mobile timeout needs to be longer.

A setup that's perfect on WiFi can lose half its bids on real mobile data.

In plain English: test on a throttled phone, count the bids that arrive late, and size your mobile timeout to reality.


content:
<b>Building a rollback plan before you change anything</b>

Before touching a live auction, plan how to undo it fast — earnings are on the line.

The safety steps:
— 1. Save a copy of your current working config with today's date.
— 2. Write down your current numbers: revenue, fill rate, page speed.
— 3. Change one thing only — never the timeout and the floor together.
— 4. Watch the same numbers for 48 hours.
— 5. Worse? Restore the saved config in minutes, no guessing required.

Changing two things at once means you'll never know which one helped or hurt.

In plain English: save a backup, record your numbers, change one thing, and keep a one-click way back.


channel_name: RPM Receipts

content:
Viewability under 60%? Run this 5-step audit
Viewability = % of ad impressions actually seen (50% of pixels, 1+ sec). Median display viewability sits at 62% (n=210 sites, 28d). Below that, you leave 15-30% RPM on the table.

— Step 1: Pull viewability per ad unit in your ad manager, not the blended number.
— Step 2: Kill or lazy-load units below 40%.
— Step 3: Add a sticky anchor (typical 80%+ viewability).
— Step 4: Set lazy-load threshold to 200px, not 0.
— Step 5: Recheck at 14d.

Most gains come from one dead footer unit.

So what: 62% → 78% viewability lifts display RPM ▲ 9-14%.


content:
Build a first-party audience signal in one afternoon
Sites passing first-party segments to bidders earn 8-18% higher CPM on the open auction (CPM = cost per 1,000 impressions the buyer pays; RPM = what you keep per 1,000 pageviews). Sample: n=64 mid-size publishers.

— Step 1: Tag content into 6-10 topic buckets at the URL level.
— Step 2: Bucket users by sessions: 1 / 2-4 / 5+.
— Step 3: Pass both as key-values into the ad request.
— Step 4: Build a 'returning + topic' segment in your SSP.
— Step 5: Watch fill on that segment for 28d.

So what: Returning-reader segments price ▲ 11% vs anonymous.


content:
Calibrate ad density without nuking RPM
Benchmark: revenue per pageview peaks near 1 ad per 350-450 words, then flattens (n=140 sites, 28d). Past 8 units on a 1,200-word post, each added unit earns less than the prior one.

Unit count → incremental RPM gain
4 units  ▮▮▮▮▮▮▮  baseline
6 units  ▮▮▮▮  ▲ 12%
8 units  ▮▮  ▲ 4%
10 units ▮  ▲ 1% (and viewability sags)

— Step 1: Count current units per template.
— Step 2: Add one mid-content unit, measure 7d.
— Step 3: Stop when incremental EPMV gain drops below 3%.

So what: The 7th unit usually pays ▼ 60% less than the 3rd.


content:
Quarterly header-bidding partner cull: the checklist
More bidders ≠ more money. Past 6-7 partners, added latency costs more than incremental bid lift (n=80 sites). Each partner should clear its own keep-bar.

Keep a partner only if, over 28d:
— Win rate ≥ 3% of auctions it enters.
— It wins ≥ 1% of total impressions.
— Its timeout rate < 15%.
— It raised the clearing price on ≥ 2% of auctions (bid density).

— Step 1: Export per-partner win + timeout.
— Step 2: Drop anyone failing two bars.
— Step 3: Re-measure page latency.

So what: Cutting 3 dead partners trims load ▼ 280ms, RPM flat.


content:
Set price floors without starving fill
A price floor is the minimum CPM you'll accept. Set too high, fill rate craters; too low, you sell cheap. Optimal floors recover 4-9% RPM (n=58 sites, 28d).

— Step 1: Pull the bid distribution per unit (the histogram of all bids).
— Step 2: Set floor at the 25th percentile of winning bids, not the median.
— Step 3: Segment floors by geo — US floor ≠ Tier-3 floor.
— Step 4: A/B at ±20% for 14d, watch fill AND RPM together.
— Step 5: Lock the version where RPM × fill is highest.

So what: Geo-split floors beat one global floor by ▲ 6%.


content:
Fix ad-driven layout shift, recover the RPM tax
CLS (cumulative layout shift) from late-loading ads tanks Core Web Vitals, and slow pages lose viewable impressions. Reserved-slot sites hold 5-8% more RPM (n=72).

— Step 1: Audit every ad slot in DevTools, log shift score per slot.
— Step 2: Set fixed min-height on every container (largest expected size).
— Step 3: Reserve space BEFORE the ad call fires.
— Step 4: For responsive units, lock the slot to one size per breakpoint.
— Step 5: Re-test CLS, target < 0.1.

So what: Reserved slots add ▲ 6% viewable impressions, near-zero shift.


content:
Q4 CPM ramp prep: the September checklist
CPMs swing ~40-55% peak-to-trough across the year; the climb starts mid-September and tops in the last 10 days of December (n=120 sites, 3-yr avg). Capacity has to be ready before demand arrives.

Monthly RPM index (Jan=100)
Jan ▮▮▮▮▮▮▮  100
Jun ▮▮▮▮▮▮▮▮  108
Nov ▮▮▮▮▮▮▮▮▮▮  142
Dec ▮▮▮▮▮▮▮▮▮▮▮▮  165

— Add a seasonal 4th/5th unit by Oct 1, not Dec 1.
— Raise floors 10-15% for the Dec window.
— Pre-publish gift/buying-guide content by early Oct.

So what: A Dec pageview is worth ▲ 65% vs a Jan one.


content:
Tune ad refresh without killing fill
Ad refresh (reloading a unit after N seconds in view) adds impressions, but too-fast refresh burns advertiser trust and clearing prices. Sweet spot: 30-35s viewable refresh (n=66 sites).

— Step 1: Refresh only viewable units, and only after they've been seen.
— Step 2: Start at 35s, cap at 4 refreshes per session per unit.
— Step 3: Exclude the top unit from refresh (protects CPM).
— Step 4: Watch CPM per refreshed impression vs first — expect ▼ 20-30%, that's fine if net RPM rises.
— Step 5: Cut interval to 30s only if CPM holds.

So what: 35s viewable refresh nets ▲ 10-15% RPM at flat CPM.


content:
Rebalance content toward high-RPM niches
Session RPM varies 4-6x by topic; shifting 15% of new posts toward high-value verticals moves blended RPM fast (n=140 sites, 28d).

Median session RPM by niche
Finance/Insurance ▮▮▮▮▮▮▮  $42
B2B/SaaS ▮▮▮▮▮  $31
Tech reviews ▮▮▮  $19
Lifestyle ▮▮  $13
Recipes ▮  $9

— Step 1: Tag each post's niche, pull RPM per cluster.
— Step 2: Find your top-RPM cluster with traffic headroom.
— Step 3: Aim 30% of next quarter's posts there.
— Step 4: Add a finance/insurance angle to existing how-tos.

So what: +15% high-RPM mix lifts blended RPM ▲ 8-12%.


content:
Fill rate below 92%? Recover it step by step
Fill rate = % of ad requests that returned a paid ad. Healthy programmatic fill is 95-99% (n=88 sites). Every unfilled request is a wasted pageview.

— Step 1: Split fill by geo — Tier-3 traffic naturally fills lower, don't panic.
— Step 2: Add a backfill/house chain for unsold inventory.
— Step 3: Check if a high floor is rejecting bids (lower 15%, retest).
— Step 4: Confirm passback tags fire on no-bid.
— Step 5: Add one more demand partner for thin geos only.

So what: 90% → 97% fill on US traffic adds ▲ 7% RPM directly.


content:
Above-the-fold ad audit: the 6 checks
The first viewport carries 35-45% of page revenue but is where layout shift and slow loads do the most damage (n=70 sites). Get it right before touching anything below.

— 1. One premium unit ATF, sized to the breakpoint — not three small ones.
— 2. That unit loads in the first ad call, no lazy-load.
— 3. Slot height reserved to prevent shift.
— 4. Viewability on it should hit 70%+ (if not, it's too high or hidden).
— 5. No interstitial competing with it on mobile.
— 6. CPM on ATF unit ≥ 1.5x your site median.

So what: A correctly-set ATF unit alone runs ▲ 50% above median CPM.


content:
Close the mobile-vs-desktop RPM gap
Mobile RPM runs 35-50% below desktop on most content sites (n=95, 28d), but half that gap is fixable layout, not demand.

RPM by device (indexed to desktop)
Desktop ▮▮▮▮▮▮▮▮▮▮  100
Tablet  ▮▮▮▮▮▮▮  72
Mobile  ▮▮▮▮▮▮  58

— Step 1: Add a mobile sticky anchor (often +15% mobile RPM alone).
— Step 2: Use a properly-capped mobile interstitial.
— Step 3: Match in-content unit count to mobile reading length.
— Step 4: Kill desktop-only 728x90 leaderboards on mobile.
— Step 5: Re-check mobile viewability — it should beat desktop.

So what: Anchor + interstitial closes the gap by ▲ 18%.


content:
Onboard a new demand partner the right way
A new SSP can add 3-7% incremental RPM — or just add latency for nothing. The difference is the onboarding test (n=52 sites).

— Step 1: Run them at 50% traffic A/B for 14d, not 100% day one.
— Step 2: Measure incremental bid density, not just their wins.
— Step 3: Confirm they raised clearing price on ≥ 2% of auctions.
— Step 4: Check timeout rate < 15% and added latency < 80ms.
— Step 5: Verify they didn't just steal wins from a partner you keep (cannibalization).

So what: Truly incremental partners lift RPM ▲ 4%; cannibals lift it 0%.


content:
Segment pageview value to find hidden money
Blended RPM hides huge spread. Top-decile pages often earn 5-8x the bottom decile (n=140 sites, 28d). Your average is a lie until you cut it.

— Step 1: Pull RPM per URL, sort into deciles.
— Step 2: Tag each decile by source: search / social / direct.
— Step 3: Find high-traffic + low-RPM pages — that's the leak.
— Step 4: Check if they're under-monetized (too few units) or low-intent traffic.
— Step 5: Add units to high-traffic/low-RPM pages first.

So what: Fixing the bottom-RPM high-traffic decile lifts site RPM ▲ 6-9%.


content:
Dial in lazy-load thresholds: the test
Lazy-loading ads boosts viewability but, set too aggressive, fires the call after the user scrolls past — a viewable-but-unsold miss. Optimal threshold: load 150-300px before slot enters viewport (n=60 sites).

Threshold → viewability / fill
0px (on-enter)   ▮▮▮  high viewability, low fill
200px (before)   ▮▮▮▮▮▮  best net RPM
800px (early)    ▮▮▮▮  low viewability, high fill

— Step 1: Set threshold to 200px globally.
— Step 2: A/B vs 0px and 600px for 14d.
— Step 3: Compare RPM, not viewability in isolation.

So what: 200px beats on-enter loading by ▲ 5% net RPM.


content:
Roll out a video unit without tanking page speed
Outstream video CPMs run $8-25 vs $1-4 for display (n=48 sites), but a heavy player wrecks Core Web Vitals and the net loss eats the gain. Sequence matters.

— Step 1: Pick one in-content slot, mid-article, one player only.
— Step 2: Lazy-load the player; never autoplay before viewport.
— Step 3: Reserve the slot height to kill layout shift.
— Step 4: Measure incremental EPMV AND page-speed delta together.
— Step 5: Cap to one player per page — a second rarely clears its weight.

So what: One well-placed outstream unit lifts EPMV ▲ 12-20% at < 0.1 CLS.


content:
Build an RPM dashboard that catches leaks in 24h
Most publishers find revenue drops days late. A 5-metric daily view catches a broken unit or dead partner same-day (n=40 sites using daily monitoring).

Track these, segmented by device + geo:
— 1. EPMV (the headline — nets density vs engagement).
— 2. Fill rate (flags broken passbacks fast).
— 3. Viewability per unit (flags a unit that died).
— 4. CPM per demand partner (flags a partner collapse).
— 5. Sessions (separates traffic drops from monetization drops).

— Set a ±15% day-over-day alert on each.

So what: Daily alerting cuts revenue-leak detection time ▼ from 6 days to 1.


content:
Recover RPM lost to low consent rates
In GDPR regions, non-consented traffic monetizes 50-80% lower — buyers can't target it. Lifting consent acceptance from 60% to 80% is pure RPM (n=55 EU-heavy sites).

— Step 1: Measure your actual consent-accept rate per CMP (consent platform), per geo.
— Step 2: Move the consent prompt above the fold, single clear accept.
— Step 3: Remove the dark-pattern friction that triggers reject-all.
— Step 4: Ensure the consent string passes to ALL bidders, not just Google.
— Step 5: Re-measure EU RPM at 14d.

So what: 60% → 80% consent lifts EU traffic RPM ▲ 20-30%.


content:
Trade page speed for RPM — measure the real curve
Faster pages serve more viewable impressions per session; slower pages lose bottom-of-page units to bounces. The crossover sits near a 2.5s LCP (largest content paint) (n=78 sites).

LCP → revenue per session (indexed)
1.5s ▮▮▮▮▮▮▮▮▮▮  100
2.5s ▮▮▮▮▮▮▮▮▮  96
4.0s ▮▮▮▮▮▮▮  82
6.0s ▮▮▮▮▮  68

— Step 1: Pull LCP per template from field data.
— Step 2: Defer non-ad third-party scripts first (they're the usual killer).
— Step 3: Async the ad library, reserve slots.
— Step 4: Re-measure revenue/session, not just the speed score.

So what: Cutting LCP 6s → 2.5s recovers ▲ 28% revenue per session.