Digital Marketing Interview Questions and Answers

Answer

Structure follows the levers, and in Google Ads the levers sit at campaign level: budget, bid strategy, location targeting, network settings, ad schedule and language. So anything you need to control or report separately becomes its own campaign. For this brief I would run one Search campaign per product line (three campaigns), a separate brand Search campaign so branded traffic never eats non-brand budget, and one Performance Max campaign per product line only once each has enough conversion volume to feed Smart Bidding.

Eight cities usually do not justify eight campaigns. Group them by economics instead: metro tier (Mumbai, Delhi NCR, Bengaluru) where CPCs and AOV are both higher, and the rest. Only split a geo out when you actually want a different daily budget or a different tROAS target for it.

Inside each campaign, ad groups should map to a tight intent theme with three to eight keywords and two or three responsive search ads plus one pinned headline for brand safety. Single keyword ad groups are a dead pattern in 2026 because close variants and Smart Bidding make that granularity meaningless while starving each ad group of data. Set location targeting to Presence rather than Presence or Interest, otherwise you will pay for someone in Dubai researching Bengaluru.

Keep negative keyword lists in the shared library and apply them at account level, and always add a brand negative to the non-brand campaigns. Naming convention matters more than people expect: something like IN_Search_NonBrand_Skincare_Metro makes filtering, scripts and Looker Studio reporting trivial six months later.

Answer

In GA4 a session begins when the session_start event fires and is identified by the ga_session_id parameter, which is a timestamp stamped on every subsequent event in that session. It ends after 30 minutes of inactivity by default, and that timeout is configurable in Admin, Data Streams, Configure tag settings, Adjust session timeout, anywhere from 5 minutes to 7 hours 55 minutes. Three behaviours differ from Universal Analytics and they explain most of the gap people see when they compare the two.

First, GA4 does not start a new session at midnight, so an overnight session stays one session. Second, GA4 does not restart the session when the campaign source changes mid-visit, where UA created a brand new session, which is why GA4 typically reports fewer sessions and attributes differently. Third, GA4 sessions are not deduplicated across devices unless User-ID or Google signals stitch them.

There is also a reporting subtlety worth knowing: in standard reports GA4 estimates unique session counts using HyperLogLog sketches, so the Sessions figure can differ slightly from a raw count of session_start events in the BigQuery export, and it will differ more on high-cardinality breakdowns. Add to that consent mode behavioural modelling and you should never expect GA4, Ads and BigQuery to agree to the last digit. Interviewers ask this to see whether you treat analytics numbers as directional instrumentation or as accounting truth. The correct posture is that GA4 is for trend and diagnosis, and the payment or CRM system is the source of truth for revenue.

-- Raw session count from the GA4 BigQuery export
-- (compare against the Sessions metric in the GA4 UI)
SELECT
  PARSE_DATE('%Y%m%d', event_date) AS day,
  COUNTIF(event_name = 'session_start') AS raw_sessions,
  COUNT(DISTINCT CONCAT(
    user_pseudo_id, '-',
    CAST((SELECT value.int_value FROM UNNEST(event_params)
          WHERE key = 'ga_session_id') AS STRING)
  )) AS distinct_session_ids
FROM `project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260701' AND '20260731'
GROUP BY day
ORDER BY day;

Answer

Every performance metric collapses into one chain, and interviewers use this question to check whether you can do the arithmetic without a dashboard. Start from impressions. Clicks equal impressions multiplied by CTR.

Spend equals impressions divided by 1000 multiplied by CPM, and also equals clicks multiplied by CPC. Setting those equal gives the identity CPC equals CPM divided by (1000 times CTR), which is the single most useful relationship in paid media: at a fixed CPM, your CPC is purely a function of CTR. Conversions equal clicks multiplied by CVR.

CPA equals spend divided by conversions, which expands to CPC divided by CVR, and further to CPM divided by (1000 times CTR times CVR). ROAS equals revenue divided by spend, which equals AOV divided by CPA. So if CTR doubles while CPM and CVR hold, CPC halves and CPA halves, and ROAS doubles.

That is why creative testing on Meta and ad relevance work on Google outperform bid tinkering: CTR sits in the denominator twice over. The caveat interviewers want to hear is that CPM is not actually fixed. On Meta a higher predicted action rate usually lowers delivered CPM as well, so gains compound, but a clickbait creative that lifts CTR while collapsing CVR moves CPA the wrong way.

Always quote the chain, then say which term you would attack first and why. For a checkout funnel the ordering is normally creative, then landing page CVR, then bid and budget, because the first two change the unit economics while bidding only changes how much volume you buy at those economics.

Spreadsheet model (one row per channel)

A: Impressions   B: CTR    C: CPM   D: CVR    E: AOV

Clicks       F2 = A2 * B2
Spend        G2 = A2 / 1000 * C2
CPC          H2 = G2 / F2                    -- equals C2/(1000*B2)
Conversions  I2 = F2 * D2
CPA          J2 = G2 / I2                    -- equals H2 / D2
Revenue      K2 = I2 * E2
ROAS         L2 = K2 / G2                    -- equals E2 / J2

Break-even ROAS given gross margin m:
M2 = 1 / m        (m = 0.40  ->  break-even ROAS = 2.5)

Max allowable CPA:
N2 = E2 * m       (AOV 2000, margin 40%  ->  CPA ceiling 800)

Answer

Quality Score is a 1 to 10 diagnostic reported at keyword level for exact-match search queries, and it is built from three components you can see as columns in the keyword view: Expected CTR, Ad Relevance and Landing Page Experience, each labelled Below Average, Average or Above Average. It is historical and diagnostic. The auction does not use the reported number, it recomputes a real-time quality estimate for every single query.

Ad Rank is the number that decides both position and price. It is a function of your bid, auction-time quality (expected CTR, ad relevance, landing page experience), the Ad Rank thresholds Google sets to keep low quality ads out, the competitiveness of the auction, the user's context (device, location, time, prior queries), and the expected impact of extensions and ad formats. That last piece matters practically: adding sitelinks and callouts can lift Ad Rank without raising your bid.

The pricing consequence is the generalised second price mechanic. Your actual CPC is roughly the Ad Rank of the competitor immediately below you divided by your quality, plus one paisa. So doubling quality can halve your CPC at the same position, which is exactly why fixing a Below Average landing page experience is often worth more than a bid increase. In interviews, the two things that separate a strong answer are saying explicitly that reported Quality Score is not the auction input, and pointing out that with Smart Bidding you no longer set the bid, so quality work and conversion tracking accuracy become the main levers you still control.

Ad Rank (conceptual)
  AdRank = Bid x AuctionTimeQuality x ExtensionsImpact  (subject to Ad Rank thresholds)

Actual CPC (second-price style)
  ActualCPC = (AdRank_of_competitor_below / YourQuality) + 0.01

Worked example (two advertisers, same position contest)
  You:        bid Rs 40, quality 8  -> AdRank 320
  Competitor: bid Rs 60, quality 4  -> AdRank 240
  You win, and pay 240 / 8 + 0.01 = Rs 30.01
  Competitor with the higher bid pays more and ranks lower.

Answer

Search campaigns buy declared intent on google.com and search partners. You keep keyword-level control, negative keywords, a search terms report and clean attribution, so they are the default for anything with an existing query volume. The trade-off is ceiling: you cannot buy more demand than people are searching for.

Performance Max buys across Search, Shopping, YouTube, Display, Discover, Gmail and Maps from one asset group with Smart Bidding driving allocation. It is the right call for ecommerce with a healthy Merchant Center feed and consistent conversion data, and the price is control: no per-channel bidding, limited search term visibility, and a real risk of cannibalising brand traffic unless you apply brand exclusions and account-level negative keywords. Demand Gen replaced Discovery campaigns and is the visual, interest-led format across YouTube feeds, Shorts, Discover and Gmail.

It is a prospecting tool for products that sell on imagery, and it needs creative volume plus a longer measurement window because clicks convert late. Display alone is now mostly useful for cheap remarketing and for placement-controlled brand work, not for cold prospecting, where its inventory quality and viewability problems are well documented. A clean 2026 answer sequences them: start with brand Search to defend, add non-brand Search on the queries that actually exist, layer Performance Max once you have thirty to fifty conversions a month feeding it, then use Demand Gen or YouTube to create demand you can later harvest in Search. Then say how you would measure the incremental effect of the upper funnel, because that is the follow-up question every interviewer asks.

Answer

The five classic parameters are utm_source, utm_medium, utm_campaign, utm_term and utm_content. GA4 adds utm_id (to join with the Campaign import), utm_source_platform, utm_creative_format and utm_marketing_tactic. Only source and medium drive channel classification, and that is where inconsistency does damage.

GA4 assigns a Default Channel Group by matching source and medium against fixed rules: Paid Search requires the source to be a known search engine and the medium to match a regex along the lines of cp.*, ppc, retargeting or paid.*; Organic Social requires a recognised social source with a medium that is not paid; Email requires source or medium containing email or e-mail. If someone tags a newsletter as utm_medium=Email with a capital E, it still matches because that particular check is case-insensitive, but utm_source=FaceBook versus facebook creates two distinct source rows in every report, and utm_medium=social-paid falls into Unassigned rather than Paid Social. The second failure is overwriting Google auto-tagging.

If auto-tagging is on and you also add manual UTMs to a Google Ads final URL, the gclid normally wins and your manual campaign name is ignored, which is why homegrown UTM values on Ads links quietly disappear. The third is stripped parameters: a redirect chain through a link shortener or a login wall that drops the query string turns paid traffic into Direct. The fix is a single documented convention (lowercase everything, fixed vocabulary for medium, campaign names with a date prefix), a shared spreadsheet or link builder that everyone uses, and a monthly audit query on the BigQuery export looking for near-duplicate source values.

https://www.example.in/offer
  ?utm_source=facebook          <- lowercase, fixed vocabulary
  &utm_medium=paid_social       <- must map to your channel grouping
  &utm_campaign=2026-08_diwali_prospecting
  &utm_content=carousel_v3_hindi
  &utm_term=lookalike_1pct_purchasers
  &utm_id=fb_2026_08_diwali     <- joins to the Campaign cost import

-- Audit for near-duplicate sources (GA4 BigQuery export)
SELECT
  LOWER(collected_traffic_source.manual_source) AS src_norm,
  ARRAY_AGG(DISTINCT collected_traffic_source.manual_source LIMIT 10) AS variants,
  COUNT(*) AS events
FROM `project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260701' AND '20260731'
  AND collected_traffic_source.manual_source IS NOT NULL
GROUP BY src_norm
HAVING ARRAY_LENGTH(variants) > 1
ORDER BY events DESC;

Answer

Three levels, and knowing which lever lives where is what stops you from making an edit that resets learning. Campaign level holds the objective (Awareness, Traffic, Engagement, Leads, App promotion, Sales), the buying type (auction or reservation), Advantage campaign budget if you let Meta distribute spend across ad sets, the campaign bid strategy, and the Special Ad Category declaration. That last one matters a great deal in India for anyone advertising jobs, housing or credit: declaring Employment or Credit strips age, gender and detailed location targeting down to a 15 mile radius equivalent and blocks lookalikes built on protected attributes, and getting it wrong risks account restriction.

Ad set level holds the audience (saved, custom, lookalike, or Advantage+ audience where your inputs become a suggestion rather than a hard boundary), placements (Advantage+ placements is the default), the optimisation event and conversion location, the ad set budget if the campaign is not using Advantage campaign budget, the schedule, the bid or cost cap, and the attribution setting. Ad level holds the creative: format, primary text, headline, description, destination URL with its UTM parameters, the pixel or dataset used, and the call to action. Two practical points interviewers listen for.

First, the optimisation event lives at ad set level, so if you want to optimise separately for Add to Cart and Purchase you need separate ad sets, not separate ads. Second, editing the audience, budget by a large percentage, optimisation event or bid strategy pushes the ad set back into learning, while adding a new ad usually does not reset the ad set, it just puts that ad through its own delivery ramp.

Answer

The attribution setting sits at ad set level and defines the window in which Meta will claim a conversion. The default is 7-day click and 1-day view, with 1-day click, 7-day click and 1-day click plus 1-day view available as alternatives. Two things about it cause most of the reported versus real gap.

First, view-through credit. A 1-day view window means someone who scrolled past your ad without clicking, then bought the next day after arriving from an organic search, is counted as a Meta conversion. On a retargeting ad set aimed at people already in your funnel, that is close to pure credit theft from other channels.

Second, the reporting convention: Meta reports conversions against the date of the ad impression or click, not the date the purchase happened. That is why yesterday's ROAS looks weak and then quietly fills in over the following week, and why a Monday morning report on a Friday campaign is always pessimistic. Add cross-channel overlap and you get the classic symptom, Meta claims 4.2x, Google Ads claims 3.1x, and the two together claim more revenue than the payment gateway settled.

The professional handling is threefold: run comparison windows side by side in Ads Manager using the Compare attribution settings option to see how much of your result is view-through, hold the platform to a directional role and use a first-party source (Shopify, Razorpay, your order table) for total revenue, and prove real contribution with a geo holdout or a conversion lift test rather than arguing about which platform number is correct. In an interview, saying 'I would run an incrementality test' without first explaining these mechanics reads as a slogan.

Answer

The Performance report gives four metrics (clicks, impressions, CTR, average position) across dimensions for query, page, country, device, search appearance and date, with a rolling 16-month history. The highest-yield first pass is the striking distance analysis: filter to your target country, export query and page rows, then find queries sitting at average position 8 to 20 with meaningful impressions and near-zero clicks. Those are pages Google already considers relevant but is not rewarding, and moving them into the top five usually needs on-page and internal linking work rather than new content.

The second pass is CTR outliers: pages ranking in positions 3 to 5 with CTR far below the site average for that position usually have a weak title or a missing meta description, or they are being outranked by an AI Overview and a pack of sitelinks. The third is cannibalisation: the same query returning two or three of your URLs across the period, which you fix by consolidating or by clarifying intent. Now the traps.

Average position is an average of the best position per query per search, so a page that ranks 3 in Delhi and 40 in Chennai shows an unhelpful blended number. Query data is filtered for privacy, so the sum of query-level clicks never matches the site total, and low-volume queries disappear entirely. The UI caps exports at 1000 rows, so use the Search Analytics API or the BigQuery bulk export for anything serious. Finally, filtering by query and by page at the same time changes what the numbers mean, because you get the intersection, not the page total.

# Striking distance pull via the Search Console API (python)
body = {
  "startDate": "2026-05-01",
  "endDate": "2026-07-31",
  "dimensions": ["query", "page"],
  "dimensionFilterGroups": [{
    "filters": [{"dimension": "country", "operator": "equals", "expression": "ind"}]
  }],
  "rowLimit": 25000,
  "startRow": 0
}
rows = service.searchanalytics().query(siteUrl=SITE, body=body).execute()["rows"]

striking = [
  r for r in rows
  if 8 <= r["position"] <= 20 and r["impressions"] >= 200 and r["ctr"] < 0.01
]
striking.sort(key=lambda r: r["impressions"], reverse=True)

Answer

A session is engaged in GA4 if any one of three conditions is met: it lasts longer than 10 seconds, it includes two or more page or screen views, or it includes at least one key event (what used to be called a conversion). Engagement rate is engaged sessions divided by total sessions, and GA4's bounce rate is defined as exactly one minus that, so it is not the same metric Universal Analytics reported. The 10 second threshold is configurable in Admin, Data Streams, Configure tag settings, Adjust session timeout, where the engaged session timer can be set anywhere from 10 to 60 seconds.

The change was made because UA's bounce rate was structurally broken for large classes of pages. A UA bounce was a session with exactly one interaction hit, so a reader who spent nine minutes on a blog post and left satisfied was a bounce, while a user who bounced off a slow page after two seconds but triggered a scroll event was not. That made bounce rate a proxy for how many events you happened to fire, not for content quality.

GA4 also tracks user_engagement events with an engagement_time_msec parameter, which powers Average engagement time per session and is the metric you should actually use for content quality. In practice, on Indian traffic with a large share of budget Android devices on patchy networks, low engagement rate on landing pages is very often a page speed problem rather than a content problem, so check LCP and INP in the Core Web Vitals report before rewriting the copy.

Answer

I work top down from what Google parses first. Title tag: primary query plus a modifier plus brand, kept short enough that it is not rewritten in the SERP, and unique across every SKU rather than templated into thousands of near-identical strings. H1 matching intent, one per page.

Meta description written for click-through rather than for ranking, since it is not a ranking factor but does move CTR. Canonical: self-referencing on the primary URL, and pointing to the primary variant for colour or size parameter URLs, which is the single most common failure on Indian ecommerce sites where faceted navigation generates thousands of crawlable duplicates. Structured data: Product schema with offers, price, priceCurrency INR, availability, and aggregateRating or review only where genuine reviews exist, then validated in the Rich Results Test because a warning here silently kills rich snippets.

Content: unique description rather than the manufacturer's copy, specification table, real user questions answered inline, and images with descriptive alt text and next-gen formats. Internal links: the page should be reachable within three clicks from the homepage, linked from its category page and from related products, with descriptive anchors. Then the technical layer: rendering (can Googlebot see the content without JavaScript execution), indexation status in the URL Inspection tool, hreflang if you serve multiple locales, and Core Web Vitals, where INP replaced FID as the responsiveness metric and should be under 200 milliseconds while LCP stays under 2.5 seconds. On page two specifically, the usual culprits are thin duplicated copy and weak internal linking rather than backlinks.

<!-- Minimum viable Product schema for an Indian ecommerce PDP -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Blue Light Blocking Glasses, Matte Black",
  "sku": "LK-BL-1042",
  "brand": { "@type": "Brand", "name": "ExampleOptics" },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.in/p/lk-bl-1042",
    "price": "1499.00",
    "priceCurrency": "INR",
    "availability": "https://schema.org/InStock",
    "shippingDetails": { "@type": "OfferShippingDetails" }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.4",
    "reviewCount": "318"
  }
}
</script>

<link rel="canonical" href="https://www.example.in/p/lk-bl-1042" />

Answer

Start by classifying your audience sources by how fragile they are. Client-side pixel audiences are the most fragile. Safari's Intelligent Tracking Prevention caps JavaScript-written cookies at seven days, Firefox blocks known trackers outright, and Chrome users who decline consent produce no identifiers at all, so a 90-day website custom audience quietly shrinks to something closer to a seven-day audience for a meaningful slice of traffic.

Server-side and first-party sources are far more durable. On Meta, engagement audiences built from video views, Instagram profile interaction, lead form opens and page follows live on Meta's own platform, so they are unaffected by browser restrictions. Customer list audiences uploaded as SHA-256 hashes of normalised email addresses and phone numbers (trim, lowercase, strip formatting, prefix the phone with the country code 91 for India) are the strongest signal you own.

Google's equivalent is Customer Match, which needs policy compliance and a minimum list size before it will serve. On GA4, audiences have a maximum membership duration of 540 days and only export to Google Ads when the accounts are linked and Google signals is enabled, and with consent mode v2 users who deny ad_storage cannot enter an Ads remarketing list at all, though they may still be modelled in reporting. The practical architecture is to move identifiers server-side: set a first-party cookie from your own domain with a long lifetime, capture email or phone at the earliest genuine value exchange, and push events with hashed identifiers through the Conversions API and Google's Enhanced Conversions. Then remarketing depends on your CRM, not on a browser's cookie policy.

Answer

First the arithmetic, out loud, because interviewers want to see you compute rather than estimate. CTR is 3,000 divided by 2,00,000, which is 1.5 percent. CPM is 90,000 divided by 200, which is ₹450.

CPC is 90,000 divided by 3,000, which is ₹30. Lead rate is 240 divided by 3,000, which is 8 percent, giving a cost per lead of ₹375. Lead to sale is 36 divided by 240, which is 15 percent.

CPA is 90,000 divided by 36, which is ₹2,500. Revenue is 36 times 4,500, which is ₹1,62,000, so ROAS is 1.8. Now the judgement.

ROAS of 1.8 is only healthy if gross margin exceeds 55 percent, because break-even ROAS is one divided by margin. At a typical D2C margin of 40 percent, break-even is 2.5 and this campaign is losing money on first purchase, which is defensible only if repeat rate and LTV justify it. Where is the leak?

CTR at 1.5 percent and CPC at ₹30 are unremarkable but not broken. An 8 percent click to lead rate on a form is acceptable. The 15 percent lead to sale rate is the weak stage: it is doing the most damage to CPA and it is the stage furthest from the ad platform, which usually means lead quality or sales follow-up speed rather than media.

So my first two actions are a lead-quality audit by source and creative, and a check on time to first call, since response inside five minutes typically doubles contact rates in Indian inside-sales teams. Only after that would I touch bids.

Stage            Volume     Rate         Cost per unit
----------------------------------------------------------
Impressions      200000      -           CPM   Rs 450
Clicks             3000     1.50% CTR    CPC   Rs 30
Leads               240     8.00% CVR    CPL   Rs 375
Sales                36    15.00% close  CPA   Rs 2500

Revenue = 36 x 4500 = Rs 1,62,000
ROAS    = 162000 / 90000 = 1.8

Break-even ROAS = 1 / gross_margin
  margin 40%  -> 2.50  (this campaign loses money)
  margin 60%  -> 1.67  (this campaign is marginally profitable)

Sensitivity: lift close rate 15% -> 20%
  Sales 48, CPA Rs 1875, ROAS 2.4  (bigger gain than halving CPC)

Answer

Reach is unique people who saw the ad at least once, impressions is total times it rendered, and frequency is impressions divided by reach over the selected date range. The date range caveat matters: frequency over a 30-day window and frequency over a 7-day window tell you different things, and lifetime frequency on an evergreen campaign is nearly meaningless. Frequency is a delivery diagnostic, not a target.

On a small retargeting pool of 20,000 people a weekly frequency of 5 can be fine, while the same number on a 20 lakh prospecting audience means you have exhausted the interesting part of that audience. The useful early-warning signals for fatigue are ordered by how early they move. First, CTR and outbound CTR decline while frequency climbs, usually the earliest measurable signal.

Second, CPM rises without an auction-wide event to explain it, because Meta's predicted action rate for your creative is falling. Third, the first-time impression ratio drops, meaning delivery is recycling the same people rather than finding new ones. Fourth, and last, CPA rises and ROAS falls, which is the signal most teams wait for and by then you have already burned budget.

The fix depends on which signal moved: falling first-time impression ratio means audience saturation, so broaden the audience or raise budget with new creative; falling CTR at stable reach means the creative itself is stale, so change the hook in the first three seconds rather than re-editing the whole asset. In Indian accounts the cheapest fix is very often a language or festival variant, since the same offer in Hindi or with a regional festival hook behaves as genuinely new creative to the auction.

Answer

SPF is a DNS TXT record listing which IP addresses and services may send mail for your domain, checked against the envelope sender. DKIM signs each message with a private key so the receiver can verify it against a public key in DNS and confirm the body and headers were not altered in transit. DMARC ties the two together: it requires that SPF or DKIM pass and that the passing domain aligns with the visible From address, then tells receivers what to do on failure (p=none, p=quarantine or p=reject) and where to send aggregate reports.

Alignment is the part people miss. An email sending platform can produce a passing SPF for its own bounce domain while the From header shows your domain, which passes SPF but fails DMARC alignment, so mail still lands in spam. Since the 2024 Gmail and Yahoo bulk sender rules, anyone sending roughly 5,000 or more messages a day to those providers must authenticate with both SPF and DKIM, publish a DMARC record (p=none is the minimum), send from a domain with valid forward and reverse DNS, support one-click unsubscribe via the List-Unsubscribe and List-Unsubscribe-Post headers with the request honoured within two days, and keep the spam complaint rate in Google Postmaster Tools below 0.3 percent, ideally under 0.1. For Indian lifecycle marketing you should also know the adjacent rule set: SMS and WhatsApp promotional traffic requires TRAI DLT registration of the sender header and message templates, and an unregistered template is rejected by the operator rather than merely filtered.

; DNS records for a sending domain
example.in.            TXT  "v=spf1 include:_spf.google.com include:sendgrid.net -all"
selector1._domainkey.example.in.  TXT  "v=DKIM1; k=rsa; p=MIGfMA0GCSq..."
_dmarc.example.in.     TXT  "v=DMARC1; p=quarantine; rua=mailto:dmarc@example.in; pct=100; adkim=s; aspf=s"

# Required unsubscribe headers on bulk mail
List-Unsubscribe: <https://example.in/u/abc123>, <mailto:unsub@example.in>
List-Unsubscribe-Post: List-Unsubscribe=One-Click

# Rollout order that avoids blackholing your own mail
# 1. p=none + rua reporting for 2-4 weeks
# 2. fix every failing source found in the aggregate reports
# 3. p=quarantine pct=25 -> 100
# 4. p=reject

Answer

The three match types remain, but their meaning has drifted a long way from the literal definitions. Exact match, written in square brackets, no longer means the exact string. Since the same-meaning expansion, [running shoes] can serve on shoes for running, running shoe, and reordered or implied-intent variants, provided meaning is preserved.

Phrase match, in quotation marks, absorbed the old broad match modifier behaviour and now matches queries that include the meaning of your phrase, with words allowed before and after but the core meaning preserved. Broad match, unquoted, considers the whole query context: other keywords in the ad group, your landing page content, and your recent search history signals, and it is designed to be used with Smart Bidding rather than manual CPC. When several of your keywords are eligible for one query, Google no longer simply prefers the most literal match, it uses relevance ranking to pick which keyword serves, which is why duplicating the same term across match types achieves very little.

Practical consequences for how you build lists in 2026: keep ad groups themed rather than single keyword, use exact and phrase for your proven money terms with tight budgets, and use broad only where conversion tracking is reliable and Smart Bidding has enough volume, because broad without a good conversion signal is just an expensive discovery tool. Negative keyword hygiene becomes the main control surface, and you must accept that the search terms report hides low-volume and privacy-filtered queries, so a share of your spend will always land on terms you cannot see. For Indian accounts, add transliteration and Hinglish negatives early, since queries mixing scripts generate a lot of irrelevant broad matches.

Answer

I treat this as five candidate explanations and rule them out in order of how cheap they are to check. One, attribution window inflation. Switch the Ads Manager comparison to 1-day click only and see how much of the 4.2x survives.

If most of the result was 1-day view or 7-day click on retargeting, Meta is claiming credit for purchases that would have happened anyway. Two, double counting between browser pixel and Conversions API. If the server event does not carry the same event_id as the browser event, Meta cannot deduplicate and every purchase is counted twice, which shows up as reported purchases being close to exactly double the order count in your database.

Check the Events Manager deduplication rate, which should be well above 90 percent for a healthy setup. Three, event configuration errors: a Purchase event firing on the thank-you page that is reachable by refresh, or on a page that also renders after a failed payment, or a value being sent including GST and shipping while the finance number is net. Four, cross-channel overlap.

Add Google Ads reported revenue and organic-attributed revenue together and see whether the total exceeds actual settlement, which it almost always does. Five, mix shift: total revenue can be flat while new-customer revenue grew and repeat revenue fell, so ask for the split. The resolution is not to pick a winner between the two numbers.

It is to reconcile at order level by joining Meta's reported orders to your order table on a first-party identifier, then to size true contribution with a geo holdout or a Meta conversion lift test. Say that last part, but only after showing you can find the mechanical bugs first.

-- Reconcile platform-reported orders against the order table
-- Requires the fbclid or a click id captured at checkout
WITH platform AS (
  SELECT order_id, reported_revenue, platform
  FROM ads_reported_conversions
  WHERE month = '2026-07'
),
ledger AS (
  SELECT o.order_id, o.net_revenue, o.first_touch_channel
  FROM orders o
  WHERE o.status = 'paid' AND o.created_at >= '2026-07-01'
)
SELECT
  COUNT(DISTINCT p.order_id)                       AS platform_orders,
  COUNT(DISTINCT l.order_id)                       AS ledger_orders,
  ROUND(SUM(p.reported_revenue) - SUM(l.net_revenue), 0) AS revenue_gap,
  COUNTIF(l.order_id IS NULL)                      AS claimed_but_missing
FROM platform p
FULL OUTER JOIN ledger l USING (order_id);

Answer

Meta deduplicates on the pair of event_name and event_id. If the browser pixel fires Purchase with event_id abc-123 and your server sends the same Purchase with the same event_id inside the deduplication window, Meta keeps one and discards the other, preferring whichever arrived first. So the entire design rests on generating one identifier per business event, not per request, and passing it to both paths.

The usual implementation is to generate a UUID at order creation on the server, render it into the pixel call as eventID, and include it as event_id in the CAPI payload. Secondary matching on fbp and fbc helps quality but is not the deduplication key. A broken setup has recognisable symptoms.

Reported purchases roughly double your real order count. Events Manager shows a low or zero deduplication rate and often a warning that server events are missing event_id. The Event Match Quality score sits low because you are sending no hashed email, phone or external_id.

Or the opposite failure: over-deduplication, where you reuse the same event_id across genuinely different orders, so real conversions vanish. Other things interviewers probe: user data must be SHA-256 hashed and normalised (lowercase, trimmed, phone in E.164 without the plus for some fields), action_source must be website for browser-originated events, event_time must be a Unix timestamp within seven days, and test_event_code should be used in the Test Events tab and then removed before going live because leaving it in keeps events out of optimisation. Server-side is not optional in 2026 for anyone serious, because it is the only path that survives ad blockers, ITP and iOS restrictions.

// Browser: pass the SAME id you will send from the server
fbq('track', 'Purchase',
  { value: 4499.00, currency: 'INR', content_ids: ['LK-BL-1042'] },
  { eventID: order.eventId }   // e.g. '9f1c0b2a-7d31-4b4f-a1c2-8e6f0d3b5a11'
);

// Server: Conversions API payload (POST /v21.0/{dataset_id}/events)
{
  "data": [{
    "event_name": "Purchase",
    "event_time": 1785312000,
    "event_id": "9f1c0b2a-7d31-4b4f-a1c2-8e6f0d3b5a11",
    "action_source": "website",
    "event_source_url": "https://www.example.in/checkout/success",
    "user_data": {
      "em": ["<sha256 of trimmed lowercase email>"],
      "ph": ["<sha256 of 919876543210>"],
      "external_id": ["<sha256 of internal user id>"],
      "fbp": "fb.1.1785311000.1234567890",
      "fbc": "fb.1.1785311000.IwAR2xyz",
      "client_ip_address": "49.36.x.x",
      "client_user_agent": "Mozilla/5.0 ..."
    },
    "custom_data": { "value": 4499.00, "currency": "INR" }
  }]
}

Answer

GA4 has no hit types. Everything is an event with a name and up to 25 parameters, plus user properties that persist across events for that user. A page view is just an event called page_view carrying parameters like page_location, page_title and page_referrer.

This is why GA4 can model web and app in one property, and why migrating a UA category, action, label taxonomy directly into GA4 produces a mess. To use a custom parameter as a breakdown in reports you must register it in Admin, Custom definitions, either as an event-scoped or user-scoped or item-scoped custom dimension, and registration is not retroactive: data collected before registration will not appear against that dimension. The limits interviewers probe are 50 event-scoped custom dimensions, 25 user-scoped, 50 custom metrics, and 500 distinct event names per property on the standard tier.

Cardinality is the trap that bites in production. GA4 stores a limited number of unique dimension values per day, and once a dimension exceeds that, extra values are bucketed into a row literally labelled (other). Register something like a full URL with query strings, an order id, or a user email as a custom dimension and within days a large share of your report collapses into (other), destroying the breakdown you built it for. The rules that keep you out of trouble: never register a high-cardinality identifier as a dimension, keep event names to a small controlled vocabulary and push variation into parameters, use recommended event names such as purchase, add_to_cart, begin_checkout so the ecommerce reports populate, and if you genuinely need per-order granularity, read it from the BigQuery export where there is no cardinality limit at all.

// Send a purchase with the recommended schema (gtag)
gtag('event', 'purchase', {
  transaction_id: 'ORD-88231',        // do NOT register this as a dimension
  value: 4499.00,
  currency: 'INR',
  coupon: 'DIWALI15',                 // low cardinality: safe to register
  payment_method: 'upi',              // low cardinality: safe to register
  items: [{
    item_id: 'LK-BL-1042',
    item_name: 'Blue Light Glasses',
    item_category: 'Eyewear',
    price: 4499.00,
    quantity: 1
  }]
});

// Rule of thumb before registering a custom dimension:
//   expected distinct values per day  <  ~500   -> safe
//   thousands or unbounded (ids, URLs) -> read it from BigQuery instead

Answer

The GA4 export puts one row per event in a daily sharded table named events_YYYYMMDD, with parameters nested in a repeated event_params record of key plus a value struct that has string_value, int_value, float_value and double_value populated selectively. That nesting is the whole difficulty of the query and it is exactly what interviewers are testing. To read a parameter you UNNEST event_params and filter on key, or use a scalar subquery inline, which is usually cleaner.

Session identity is user_pseudo_id concatenated with ga_session_id, since ga_session_id is only unique within a user. Engagement comes from the session_engaged parameter, which arrives as a string value of 1 in most implementations, so cast defensively. Traffic source has three flavours in the export and mixing them up is the classic error: traffic_source is the user's first-touch acquisition source and never changes, collected_traffic_source is what was collected on that specific event, and session_traffic_source_last_click gives last-click attribution per session in newer exports.

For channel reporting you almost always want session scope, not the user-level traffic_source field. Cost control matters too: always constrain _TABLE_SUFFIX rather than scanning every shard, and remember that the intraday table events_intraday_ has a different suffix pattern and duplicate rows against the finalised daily table, so exclude it or you will double count today. Purchases should be counted from the purchase event and revenue read from ecommerce.purchase_revenue rather than a custom parameter, so that refunds and currency handling stay consistent with the UI.

WITH base AS (
  SELECT
    CONCAT(user_pseudo_id, '-', (
      SELECT CAST(value.int_value AS STRING) FROM UNNEST(event_params)
      WHERE key = 'ga_session_id')) AS session_key,
    event_name,
    (SELECT value.string_value FROM UNNEST(event_params)
     WHERE key = 'session_engaged') AS session_engaged,
    IFNULL(collected_traffic_source.manual_source, traffic_source.source) AS source,
    IFNULL(collected_traffic_source.manual_medium, traffic_source.medium) AS medium,
    ecommerce.purchase_revenue AS revenue
  FROM `project.analytics_123456789.events_*`
  WHERE _TABLE_SUFFIX BETWEEN '20260701' AND '20260731'
)
SELECT
  LOWER(source) AS source,
  LOWER(medium) AS medium,
  COUNT(DISTINCT session_key) AS sessions,
  COUNT(DISTINCT IF(session_engaged = '1', session_key, NULL)) AS engaged_sessions,
  COUNTIF(event_name = 'purchase') AS purchases,
  ROUND(SUM(IF(event_name = 'purchase', revenue, 0)), 0) AS revenue,
  SAFE_DIVIDE(COUNTIF(event_name = 'purchase'),
              COUNT(DISTINCT session_key)) AS session_cvr
FROM base
GROUP BY source, medium
HAVING sessions > 100
ORDER BY revenue DESC;

Answer

Incrementality is the revenue that would not have happened without the spend. Platform-reported conversions are correlational, they tell you who saw an ad and later bought, not who bought because of it. Retargeting is the extreme case: a large share of people in your retargeting pool were going to return anyway, so reported ROAS can be 8x while true incremental ROAS is close to 1.

A geo holdout is the most practical clean test for an Indian advertiser because geography is easy to target and outside the user's control. Design: pick a set of comparable markets, for example ten tier-two cities, and split them into treatment and control. Do not split randomly on city name alone, match on pre-period revenue trend, order volume and seasonality, either by paired matching or by building a synthetic control as a weighted combination of untreated cities that reproduces the treatment group's history.

Verify with a pre-period placebo test: run the analysis on a period before the intervention and confirm you see no effect. Then turn spend off (or on) in the control group only, hold everything else constant, and run long enough to cover your purchase cycle plus a buffer, typically four to six weeks for considered purchases. Measure on first-party revenue by delivery pincode or billing city, never on platform-reported conversions, since that is the metric under suspicion.

Compute lift as the difference in differences between treatment and control, then convert to incremental ROAS by dividing incremental revenue by incremental spend. Two practical warnings: geo targeting leaks, since people travel and IP geolocation is imperfect, and if your brand runs national television or cricket sponsorships the contamination can swamp the effect you are trying to detect.

Difference-in-differences on geo holdout

                    Pre-period   Test-period   Delta
Treatment (ads on)   84,00,000    96,00,000    +12,00,000
Control   (ads off)  61,00,000    64,50,000    + 3,50,000

Control growth rate            = 3.5 / 61   = +5.74%
Treatment counterfactual       = 84 x 1.0574 = 88.82 lakh
Incremental revenue            = 96 - 88.82  = 7.18 lakh
Incremental spend in treatment = 2.60 lakh
Incremental ROAS               = 7.18 / 2.60 = 2.76

Platform-reported ROAS for the same period = 5.10
Over-reporting factor = 5.10 / 2.76 = 1.85x

Answer

Order matters here, and the first move is always to establish whether traffic actually fell or whether measurement did. Check Search Console clicks and impressions alongside GA4 sessions, because if GSC clicks are stable and GA4 sessions collapsed you have a tracking problem: a container removed on a deploy, a consent banner change, or a redesign that stopped firing page_view. Next, separate a drop in impressions from a drop in CTR.

Falling impressions with stable position means the queries themselves lost volume, so check seasonality and whether a large festival or exam cycle just ended. Falling position across many pages at once points to an algorithm update, so cross-check the date against known update rollouts and check whether competitors moved in the same window. Stable position with collapsed CTR usually means the SERP changed around you, most often an AI Overview or an expanded pack pushing the classic result below the fold.

Then run the technical checklist: robots.txt diff, a rogue noindex shipped with a release (a staging robots file promoted to production is the single most common cause of a sudden cliff), canonical tags pointing somewhere wrong, hreflang breakage, a CDN or firewall rule blocking Googlebot user agents, an expired certificate, or a site migration where redirects were mapped to the homepage instead of one to one. Check the Pages report in GSC for a spike in Crawled, currently not indexed or Discovered, currently not indexed, and check server logs for Googlebot crawl volume and 5xx rates. Finally, segment the loss: is it one template, one directory, or the whole site?

A single template collapsing is nearly always technical. A site-wide gradual slide over the same nine days is nearly always algorithmic.

# Fast triage commands
curl -s https://www.example.in/robots.txt
curl -sI https://www.example.in/category/eyewear | grep -iE 'x-robots-tag|location|http/'
curl -s https://www.example.in/category/eyewear | grep -iE '<meta[^>]+robots|rel="canonical"'

# Does the CDN treat Googlebot differently from a browser UA?
curl -sI -A "Mozilla/5.0" https://www.example.in/ | head -1
curl -sI -A "Googlebot/2.1 (+http://www.google.com/bot.html)" https://www.example.in/ | head -1

# Googlebot 5xx rate from access logs, by day
awk '$0 ~ /Googlebot/ {split($4,d,":"); print substr(d[1],2), $9}' access.log \
  | sort | uniq -c | sort -rn | head -30

Answer

Last click assigns 100 percent of the conversion to the final channel before the conversion, with Google's paid channels version excluding direct so that direct traffic does not swallow credit. It is simple, stable, reproducible and easy to explain to a CFO, and it is systematically biased toward bottom-funnel channels: brand search, retargeting and email get flattered, while YouTube, Demand Gen, display and top-funnel content look worthless. Data-driven attribution builds a model over your own property's paths, comparing paths that converted with paths that did not to estimate each touchpoint's marginal contribution, and it uses features such as time since touchpoint, ad format, position in the path and device.

Google's implementation is a Shapley-value style approach and it needs a minimum volume of conversions and paths before it will produce a model, so low-volume properties silently fall back. What you give up with DDA is reproducibility and explainability: fractional credit changes when the model retrains, you cannot audit why a touchpoint got 0.17 of a conversion, and the model only sees what GA4 observed, so it is blind to offline touchpoints, cross-device journeys it could not stitch, and any channel with no click. It is also still correlational, so it can only redistribute observed credit, never tell you what was incremental. The honest position for an interview: use DDA inside GA4 for directional channel comparison and for bidding inputs, use last click as a stable reporting baseline that finance recognises, and settle genuine budget questions with holdout tests or marketing mix modelling rather than with either attribution model.

Answer

CAC is CPC divided by CVR, so the first thing to do is decompose the 60 percent rise into how much came from a more expensive click and how much came from a worse conversion rate. Pull last quarter and this quarter side by side for impressions, clicks, CTR, CPC, conversions and CVR, then compute each factor's contribution. If CPC drove it, the causes are auction-side: check Auction Insights for new entrants and rising overlap rate, check Search impression share lost to rank versus lost to budget, check whether your Quality Score components degraded after a landing page change, and check for mix shift where a higher share of spend moved to expensive non-brand or high-CPC metros.

If CVR drove it, the causes are on your side of the click: a landing page change, a checkout regression, a price increase, out-of-stock SKUs, a form field added, mobile page speed degradation, or a broken conversion tag that is undercounting. That last one is important because a tag that fires only 70 percent of the time both inflates apparent CAC and starves Smart Bidding, so it degrades reality as well as reporting. Also check query mix in the search terms report, since broad match expansion or a Performance Max campaign spilling into your keyword space will shift traffic toward lower-intent queries without changing anything you configured. In an Indian account there is one more seasonal factor worth naming: auction prices in the run-up to Diwali and the Great Indian Festival period rise sharply as ecommerce budgets flood in, so a quarter-on-quarter comparison spanning that window is not like for like and you should compare year on year instead.

Decomposition of CAC change (multiplicative)

           Q1        Q2       Change
CPC     Rs 24     Rs 31      +29.2%
CVR      3.20%     2.55%     -20.3%
CAC     Rs 750   Rs 1216     +62.1%

Check: (1 + 0.292) / (1 - 0.203) - 1 = 0.621   (62.1%, reconciles)

Contribution split (log decomposition)
  ln(1.292) = 0.256   -> CPC contributes 0.256 / 0.483 = 53%
  ln(1/0.797) = 0.227 -> CVR contributes 0.227 / 0.483 = 47%

So roughly half the damage is auction-side and half is on-site.
Never answer 'CPCs went up' without running this split.

Answer

You have more control than the black box reputation suggests, but you have to use all of it. Structure: asset groups are the unit of creative and audience signal control, and for Shopping inventory you can split by listing group so a campaign can be scoped to one product category, one margin band, or one price tier. Feed hygiene is a real lever, since product titles, GTINs, product types and custom labels drive what Performance Max shows.

Custom labels are the standard way to segment by margin or by seasonality so you can set different tROAS targets per campaign. Exclusions: account-level negative keywords are now available and are the main defence, plus brand exclusion lists to keep the campaign off your own brand terms and off competitor brands, plus placement exclusions for mobile apps and specific YouTube channels, plus a content suitability setting. Turn off Final URL expansion if you do not want Google choosing landing pages from your site, or restrict it.

Reporting: the search terms and search categories insight report, asset performance ratings, the Insights page for audience and search category trends, and the Combinations report. What you cannot get natively is a clean channel split of spend and conversions, which is why teams use a Google Ads script against the reporting API to approximate the Search, Shopping, Display, Video and Discover breakdown. On cannibalisation the answer is threefold: run a separate brand Search campaign so brand queries have a keyword to match with a strong Ad Rank, apply the brand exclusion list to Performance Max, then verify with a brand-only holdout that new-customer acquisition, not total conversions, actually rose.

Answer

The governing principle is that a page should exist only if it can satisfy a real query with real data. Start from demand: pull query volume for the entity combinations you can generate (category by city, brand by category, role by location) and only generate templates where there is genuine search volume and you have enough inventory to make the page useful. A page listing two results for jobs in Kanpur for a niche skill will be classed as thin and will drag the template's overall quality down.

Set a minimum content threshold in the template logic, for example do not publish and do not include in the sitemap unless there are at least ten live listings, and de-index automatically when inventory falls below that. Handle the crawl budget explicitly: an XML sitemap index split into files of no more than 50,000 URLs each with accurate lastmod, robots.txt disallowing faceted parameter combinations you never want crawled, canonical tags collapsing sort and pagination variants, and noindex plus follow on filter permutations that have value for users but not for search. Internal linking is what actually gets these pages crawled and ranked: a hub structure where category pages link to city pages, city pages link to related cities and to sibling categories, plus a breadcrumb trail with BreadcrumbList schema.

Monitor in Search Console using the Pages report, watching Crawled currently not indexed and Duplicate without user-selected canonical as your bloat indicators, and validate crawl reality against server log analysis, which is the only way to know how much of Googlebot's budget is being spent on pages you do not care about. Expect to prune aggressively, most marketplaces publish far too many pages before learning this.

Answer

Compute on contribution margin, on cohorts, and never on a whole-account average. CAC for a cohort is total acquisition spend in the period, including agency fees, creative production and the salaries of the acquisition team if you are being honest, divided by new customers acquired in that period. LTV should be gross-margin LTV, not revenue LTV: monthly revenue per user times gross margin, divided by monthly churn, gives the simple steady-state formula, but the simple formula fails on real Indian subscription data because churn is heavily front-loaded.

Month one churn on a consumer subscription can be five times month twelve churn, so a single blended churn number produces an LTV that is wildly optimistic. Use a cohort retention curve instead, project it with a decay fit, and cap the horizon at 24 or 36 months rather than integrating to infinity, because nobody can defend a 5-year projection in a board meeting. Payback period is the number of months until cumulative contribution margin per customer equals CAC, and for consumer subscriptions in India anything beyond 6 to 9 months creates real working capital pressure unless you have committed annual plans or upfront payments. The other common errors interviewers listen for: mixing organic and paid customers into one LTV, which flatters paid; using revenue rather than margin; ignoring payment gateway fees and refunds, which on Indian UPI and card mixes are not negligible; and comparing LTV to CAC without stating the time horizon, since 3:1 over five years and 3:1 over one year are entirely different businesses.

-- Cohort retention and cumulative contribution margin per customer
WITH cohorts AS (
  SELECT
    user_id,
    DATE_TRUNC(first_paid_at, MONTH) AS cohort_month,
    acquisition_channel
  FROM subscribers
),
mrr AS (
  SELECT
    c.cohort_month,
    c.acquisition_channel,
    DATE_DIFF(DATE_TRUNC(p.paid_at, MONTH), c.cohort_month, MONTH) AS month_index,
    COUNT(DISTINCT p.user_id) AS active_users,
    SUM(p.net_amount) AS revenue
  FROM payments p
  JOIN cohorts c USING (user_id)
  WHERE p.status = 'captured'
  GROUP BY 1, 2, 3
)
SELECT
  cohort_month,
  acquisition_channel,
  month_index,
  active_users,
  ROUND(revenue * 0.72, 0) AS contribution_margin,   -- 72% after COGS + gateway fees
  ROUND(SUM(revenue * 0.72) OVER (
    PARTITION BY cohort_month, acquisition_channel
    ORDER BY month_index
  ) / FIRST_VALUE(active_users) OVER (
    PARTITION BY cohort_month, acquisition_channel ORDER BY month_index
  ), 0) AS cumulative_margin_per_acquired_user
FROM mrr
ORDER BY cohort_month, acquisition_channel, month_index;
-- Payback month = first month_index where the last column >= cohort CAC

Answer

Sizing comes first, before the test runs. You need the baseline conversion rate, the minimum detectable effect you care about commercially, the significance level and the power. The standard two-proportion sample size formula gives roughly 16 times baseline p times (1 minus p) divided by the absolute MDE squared, per variant, at 95 percent confidence and 80 percent power.

Plug in a 3 percent baseline and a desire to detect a relative 10 percent lift, meaning an absolute MDE of 0.003, and you need around 51,700 visitors per variant. That number is the whole point of the exercise: most Indian mid-market landing pages simply do not get that traffic in a sensible timeframe, so the honest recommendation is often to test bigger changes with larger expected effects rather than button colours, or to test on a higher-traffic upstream step. Peeking is the second failure.

Classic fixed-horizon significance testing assumes you look once, at the end. If you check every day and stop the first time p drops below 0.05, your real false positive rate can exceed 30 percent, which is why so many wins fail to replicate. The fixes are to commit to the sample size and duration in advance, or to use a method designed for continuous monitoring such as a sequential test or a Bayesian approach with a defined loss threshold.

Run for whole weeks to cover the weekly cycle, because Indian B2B traffic behaves very differently on Sunday. Finally, check the guardrails: a variant can lift form submissions while destroying lead quality, so define the success metric as far down the funnel as your data allows.

Sample size per variant (two-sided, alpha 0.05, power 0.80)

  n = 16 * p * (1 - p) / MDE^2

  Baseline CVR p            = 0.030
  Relative lift target      = 10%   -> absolute MDE = 0.003
  n = 16 * 0.03 * 0.97 / 0.000009 = 51,733 per variant

  At 1,200 visitors/day split 50/50 -> 86 days. Too slow.
  Options: raise MDE to 25% relative -> n = 8,277 -> 14 days
           or test on a higher-traffic step in the funnel.

Spreadsheet check on the observed result:
  pooled  = (c1 + c2) / (n1 + n2)
  se      = SQRT(pooled * (1 - pooled) * (1/n1 + 1/n2))
  z       = (p2 - p1) / se
  p_value = 2 * (1 - NORM.S.DIST(ABS(z), TRUE))

Answer

Allocate on marginal return, not average return, and say that explicitly because it is the whole answer. A channel showing 6x average ROAS may be delivering 1.5x on its next rupee if it is already saturated, while a channel at 2.5x average may still be at 4x on the margin because it is under-funded. The way to see this is a spend response curve per channel: plot weekly spend against incremental conversions over the last six to twelve months, fit a concave curve (a log or Hill saturation shape), and read off the slope at your current spend level.

Where curves are unreliable, generate the data deliberately by running staged budget changes, moving one channel plus or minus 20 percent for two to three weeks at a time and observing the response, which doubles as a crude incrementality read. Then set the split so the marginal ROAS is roughly equal across channels, because that is the condition for an optimum, and impose constraints on top: a floor for brand search defence, a floor for upper funnel so you are not harvesting demand you never created, and a cap where a channel cannot absorb more spend without frequency or impression share problems. Reserve 10 to 15 percent as a test budget for new channels and formats, otherwise you never learn anything.

Report it as a plan with review checkpoints, not a fixed annual split, and be explicit about the measurement you will use to judge it, since platform-reported ROAS will not settle disagreements between Meta and Google. For a business at ₹40 lakh a month in India, that usually means quarterly geo holdouts plus a lightweight marketing mix model once you have two years of weekly data.

Marginal ROAS comparison at current spend

Channel        Spend/mo   Avg ROAS   Fitted curve            dRev/dSpend
-------------------------------------------------------------------------
Brand Search   Rs  3.0L     11.4      near-flat (capped)        1.2
Non-brand      Rs 12.0L      3.1      a*ln(1+b*S)               2.6
Perf Max       Rs 14.0L      4.0      a*ln(1+b*S)               1.9
Meta prospect  Rs  8.0L      2.4      a*ln(1+b*S)               3.4
YouTube        Rs  3.0L      0.9*     lagged, measure by lift   ?

* YouTube last-click ROAS is not the right metric; size it with a lift test.

Action: shift Rs 2L from Perf Max and Rs 1L from brand into Meta prospecting
and non-brand, then re-measure the slopes in 3 weeks.

Answer

Learning phase is the period during which Meta's delivery system is still building a reliable model for an ad set, so performance is more volatile and usually worse than it will be afterwards. An ad set exits learning after roughly 50 optimisation events within a 7-day rolling window at the ad set level, and the count is of the event you chose to optimise for, not of any conversion. That is the practical reason teams optimise for Add to Cart or Lead instead of Purchase on low-volume accounts: if you get 12 purchases a week you will never exit learning on Purchase, and you will sit permanently in the unstable state, which Ads Manager labels Learning limited.

The fixes for Learning limited are consolidation (fewer ad sets sharing the same audience so events concentrate), a higher budget, a broader audience, moving to an upper-funnel optimisation event, or switching to Advantage campaign budget so the campaign redistributes across ad sets. Significant edits restart learning: changing the audience, the optimisation event, the placements, the bid strategy or bid amount, adding a new ad or materially changing creative, and budget changes beyond roughly 20 percent in one move. Which is why the standard operating discipline is to scale budgets in steps of 20 percent or less every couple of days rather than doubling overnight, and to batch creative refreshes rather than trickling one new ad in per day. Two nuances worth adding in an interview: pausing an ad set for more than a short period can also cost you the learned state, and the 50-event rule is a guideline rather than a hard switch, since delivery stability depends on event consistency as much as raw count.

Answer

Consent Mode v2 added two signals to the original pair. You now send ad_storage and analytics_storage, which control cookie usage, plus ad_user_data (may user data be sent to Google for advertising) and ad_personalization (may it be used for personalised advertising and remarketing). For traffic from the EEA and UK, Google requires these signals to be transmitted or it will stop populating remarketing audiences and degrade measurement for that traffic.

Implementation has two flavours. Basic consent mode blocks the Google tags entirely until consent is granted, so no ping is sent and Google has nothing to model from. Advanced consent mode loads the tags in a denied state, sends cookieless pings carrying no identifiers, and lets Google's conversion modelling estimate the unobserved conversions, which requires enough volume before modelling activates.

Advanced preserves substantially more measurement and is the right default, but it does mean a request is made before consent, which your legal team must be comfortable with. The order of operations matters technically: set the default consent state before the Google tag fires, then update it when the user chooses, otherwise the first page view is recorded with the wrong state. For an Indian company, do not treat this as an EU-only exercise.

India's Digital Personal Data Protection Act establishes notice and consent obligations with operational rules being phased in, so build the consent layer once, region-aware, rather than bolting on a second implementation later. Practically that means a consent management platform that writes the Google signals and also gates your Meta pixel, and a server-side tagging layer that respects the same state so you do not create a privacy bypass through the back door.

// Set defaults BEFORE the Google tag loads
gtag('consent', 'default', {
  ad_storage: 'denied',
  ad_user_data: 'denied',
  ad_personalization: 'denied',
  analytics_storage: 'denied',
  wait_for_update: 500,
  region: ['DE', 'FR', 'IT', 'ES', 'NL', 'GB']   // region-scoped default
});

// Looser default outside the strict regions, if legal signs off
gtag('consent', 'default', {
  ad_storage: 'granted',
  ad_user_data: 'granted',
  ad_personalization: 'granted',
  analytics_storage: 'granted'
});

// On banner interaction
gtag('consent', 'update', {
  ad_storage: choice.marketing ? 'granted' : 'denied',
  ad_user_data: choice.marketing ? 'granted' : 'denied',
  ad_personalization: choice.marketing ? 'granted' : 'denied',
  analytics_storage: choice.analytics ? 'granted' : 'denied'
});

Answer

Both sides are usually partly right, and the argument only ends when you can show qualification rate by source, campaign and creative rather than lead count. Step one is to make the CRM stage the reporting metric. Pass source, campaign, ad set and creative into the lead record at capture time, either as hidden form fields populated from the URL or through a click id stored in a first-party cookie and resolved server-side, then report MQL rate, connect rate, qualified rate and closed-won by that dimension.

Without this join the conversation is opinion versus opinion. Step two is to segment the scale-up itself. When spend rises, four things commonly change at once: broader audiences and broad match reach lower-intent users, placements shift toward cheaper inventory such as Audience Network and Display where accidental clicks are common, lead form formats change (an on-platform Instant Form pre-filled from a Facebook profile converts far more cheaply and far worse than a landing page form), and geography widens into markets your sales team cannot service.

Compare each of those splits before and after. Step three is to check for junk and bot traffic: duplicate phone numbers, sequential submissions from one IP, invalid Indian mobile prefixes, disposable email domains, and a suspicious share of submissions in the small hours. Step four is process: if time to first call went from 8 minutes to 6 hours because volume overwhelmed the sales team, quality did not fall, responsiveness did, and that shows up as connect rate falling while qualified-per-connect stays constant. The fix set follows from whichever diagnosis wins: add qualifying fields and a higher-friction form, exclude placements, use Meta's higher intent form option, or feed offline conversion data back so the platforms optimise toward qualified leads rather than raw submissions.

-- Qualification rate by campaign, before vs after the scale-up
SELECT
  l.utm_campaign,
  l.utm_content AS creative,
  CASE WHEN l.created_at < '2026-06-01' THEN 'before' ELSE 'after' END AS period,
  COUNT(*)                                              AS leads,
  ROUND(100 * AVG(IF(l.stage_reached >= 2, 1, 0)), 1)   AS connect_pct,
  ROUND(100 * AVG(IF(l.stage_reached >= 4, 1, 0)), 1)   AS qualified_pct,
  ROUND(SUM(l.spend_allocated) / NULLIF(SUM(IF(l.stage_reached >= 4, 1, 0)), 0), 0)
                                                        AS cost_per_qualified
FROM crm_leads l
WHERE l.created_at BETWEEN '2026-04-01' AND '2026-07-31'
GROUP BY 1, 2, 3
HAVING leads >= 30
ORDER BY cost_per_qualified DESC;

Answer

MMM regresses an outcome, usually weekly revenue or orders, on media spend and control variables, and its value is that it needs no user-level tracking at all, which makes it the natural complement to a broken click-attribution stack. Data: at least two years of weekly observations, ideally three, since annual seasonality needs multiple cycles to estimate. Media spend by channel by week, with impressions or GRPs alongside spend where available.

Controls that matter in India specifically: festival calendar (Diwali, Onam, Durga Puja, regional new years), the big marketplace sale events, price and discount depth, stockouts, competitor activity, weather where relevant to the category, and any cricket tournament window if the brand advertises around it. Two transformations do the real work. Adstock captures carryover, so this week's response includes a decayed share of prior weeks, with a decay rate per channel (television and YouTube carry longer than search) and optionally a delayed peak.

Saturation captures diminishing returns, usually a Hill or negative exponential curve applied after adstock, and it is what makes the model able to answer the marginal question rather than just the average one. Fit with a Bayesian approach rather than plain OLS, because media channels are heavily collinear and priors let you inject sensible bounds, for example that a channel's contribution cannot be negative and that search carryover is short. Validation is where interviews are won: hold out the last 8 to 13 weeks and check out-of-sample MAPE, run time-series cross validation rather than a random split, inspect residuals for autocorrelation, and most importantly calibrate the model against a geo holdout or lift test, treating the experimental result as a prior on that channel's coefficient. An MMM never validated against an experiment is a well-dressed opinion.

# Adstock then saturation, the two transformations that make MMM work
import numpy as np

def adstock(x, decay=0.6, max_lag=8):
    w = decay ** np.arange(max_lag + 1)
    w = w / w.sum()
    return np.convolve(x, w)[:len(x)]

def hill(x, half_sat, slope=1.0):
    # returns 0..1, half_sat is spend at 50% of maximum response
    return x**slope / (x**slope + half_sat**slope)

# Weekly design matrix
# revenue ~ base + trend + seasonality + festival_dummies + price_index
#           + sum_over_channels( beta_c * hill(adstock(spend_c)) )

# Marginal ROAS at current weekly spend for one channel:
#   dRevenue/dSpend evaluated numerically
s = current_spend
mroas = (response(s + 10000) - response(s - 10000)) / 20000

# Validation checklist
#  - rolling-origin CV, not random k-fold (time series)
#  - out-of-sample MAPE on the last 8-13 weeks
#  - Durbin-Watson on residuals
#  - calibrate beta priors with geo-holdout lift results

Answer

Rule-based models (first touch, last touch, linear, time decay, position based 40-20-40) allocate credit by an assumption you invented. They are transparent and cheap and they answer nothing, because the split is a policy choice rather than an estimate. Markov chain attribution treats the customer journey as a state machine where states are channels plus conversion and null absorbing states, estimates transition probabilities from observed paths, and computes each channel's removal effect: the drop in overall conversion probability when that channel is removed from the graph.

Credit is then distributed proportionally to removal effects. It handles ordering and repetition naturally and it is computationally cheap on a few million paths. Shapley value attribution comes from cooperative game theory and allocates each channel its average marginal contribution across all possible coalitions, which is theoretically the fairest allocation but explodes combinatorially, so real implementations restrict to channel sets present rather than full orderings, or approximate by sampling.

Both are meaningfully better than rule-based, and both share the same hard ceiling: they only see touchpoints you tracked, they treat correlation as contribution, and they cannot represent a channel that influenced a purchase without generating a click, which is most of upper funnel. So they systematically undervalue video and display just like last click does, only with more mathematics. When is it worth building?

When you have high path volume, a long consideration cycle, several genuinely different channels, and reliable cross-device identity, typically a marketplace or a B2B SaaS company with logged-in users. Below that, spend the same effort on incrementality tests and a lightweight MMM. The senior answer is a triangulation stack: MTA for day-to-day channel routing, experiments for truth on specific channels, MMM for the annual budget, and a reconciliation habit when they disagree.

Markov removal effect, worked small example

Observed paths (simplified)
  Search > Meta > Convert      1,200
  Search > Convert               800
  Meta > Convert                 400
  Meta > Search > Convert        600
  Search > Null                4,000
  Meta > Null                  6,000

Baseline conversion probability from Start  = 0.226
Remove Meta   -> recompute graph -> P = 0.121   removal effect 0.105
Remove Search -> recompute graph -> P = 0.089   removal effect 0.137

Credit share
  Search = 0.137 / (0.137 + 0.105) = 56.6%
  Meta   = 0.105 / (0.137 + 0.105) = 43.4%

Compare with last click on the same data: Search 45.9%, Meta 54.1%.
The reordering is the entire point of building the model.

Answer

Build it in four layers, each with a defined job, and be explicit that no single layer is the truth. Layer one, first-party data collection. Move tagging server-side with a server container (Google Tag Manager server-side on Cloud Run or an equivalent) so events are collected on your own domain, cookies are set with an HttpOnly server-side Set-Cookie that survives ITP, and you control what is forwarded to each vendor.

Capture a durable internal user id at the first genuine identification point and stamp it on every event. Layer two, conversion delivery back to the ad platforms: Meta Conversions API with event_id deduplication and hashed em, ph and external_id; Google Enhanced Conversions for web plus offline conversion imports using gclid or the wbraid and gbraid parameters for iOS app-to-web journeys; and offline conversion upload from the CRM so bidding optimises on qualified pipeline rather than form fills. This layer is what restores platform optimisation quality, which matters more than reporting because it changes what the algorithms buy.

Layer three, a warehouse as the single reporting surface. Land the GA4 BigQuery export, ad platform cost data through a connector, and the order or CRM tables, then model them into one sessions table and one conversions table with a documented attribution definition. Every dashboard reads from that, so the argument about whose number is right happens once, in code review, rather than weekly in a meeting.

Layer four, causal measurement: a standing calendar of geo holdouts and platform lift tests, plus an MMM once you have the history. Finally, governance: one owner for the tracking plan, a naming convention enforced in CI, and a monthly reconciliation report that shows warehouse revenue against finance revenue, because trust is rebuilt by publishing the gap, not by hiding it.

Event flow after the rebuild

  Browser / App
     |  first-party endpoint  (sgtm.example.in)
     v
  Server container  --> GA4 (measurement protocol)
     |               --> Meta CAPI          (event_id dedup, hashed PII)
     |               --> Google Ads         (Enhanced Conversions)
     |               --> BigQuery raw events
     v
  Warehouse
     dbt models: stg_events -> fct_sessions -> fct_conversions
     attribution logic lives HERE, versioned, one definition
     |
     v
  Looker Studio / Metabase   (read-only, no business logic)

CRM (Salesforce / HubSpot / internal)
     nightly offline conversion upload keyed on gclid / fbclid / hashed email

Answer

The CFO's intuition is reasonable and sometimes correct, so do not defend the budget on principle. Frame it as an incrementality question with a cheap experiment attached. First, decompose the brand traffic.

Separate pure navigational queries (the brand name alone) from brand plus modifier queries (brand plus review, brand plus coupon, brand plus a competitor, brand plus a specific product), because those behave very differently. Pure navigational clicks are the most likely to be non-incremental, since the user was coming anyway. Brand plus modifier queries frequently have competitors bidding on them, and there the ad is defending a click you would otherwise lose.

Second, check the SERP for those queries: if a competitor ad, an aggregator, or a coupon site occupies the top slot, your organic first position is below the fold on a phone, which is where most Indian traffic is. Third, run the test rather than arguing. A brand search holdout is one of the easiest experiments in marketing: pause brand ads in a matched set of states or cities for two to four weeks and measure total brand-driven sessions and orders (paid plus organic combined) against the control group.

What you are looking for is the recapture rate, the share of paid clicks that simply reappear as organic clicks. Fourth, present the economics honestly: incremental orders from brand ads, cost per incremental order, and the risk exposure of competitor conquesting if you go dark. The credible answer usually is not all or nothing.

It is typically that pure navigational brand spend can be reduced substantially with a low-position bidding strategy for defence, while brand plus modifier and competitor conquesting terms are worth full funding. Bringing that nuance, plus a two-week test plan and a defined success metric, is what makes the CFO agree.

Brand holdout readout (4 weeks, 6 matched cities each arm)

                        Control (ads on)   Treatment (ads off)
Paid brand clicks             41,200                 0
Organic brand clicks          58,400            88,900
Total brand clicks            99,600            88,900
Brand-driven orders            3,180             2,845

Recapture rate = (88,900 - 58,400) / 41,200 = 74%
Lost orders    = 3,180 - 2,845 = 335 over 4 weeks
Brand spend saved in treatment arm = Rs 4,94,000
Cost per incremental order = 4,94,000 / 335 = Rs 1,475

If blended CAC target is Rs 900, this brand spend is NOT justified
at current levels. If it is Rs 2,000, it is. State the target first.

Answer

Start by accepting the measurement gap. AI surfaces do not hand you a Search Console. What you can measure: Search Console impressions and CTR shifts on queries where AI Overviews appear, which typically shows stable or rising impressions with falling CTR, and that gap is your first proxy.

Referral traffic in GA4 from chatgpt.com, perplexity.ai, gemini.google.com and copilot.microsoft.com, which is small in volume but usually converts unusually well because the user arrives pre-qualified. Server log analysis for AI crawler user agents such as GPTBot, OAI-SearchBot, PerplexityBot, ClaudeBot and Google-Extended, which tells you whether your content is even being fetched. And a prompt-tracking process: define fifty prompts a real buyer in your category would type, run them on a schedule across the main assistants, and record whether you are mentioned, cited with a link, or absent, plus which competitors and which third-party sources are cited instead.

That last dimension is the strategic finding, because AI answers cite listicles, review sites and forums far more than brand pages, so the lever is often getting into the sources rather than optimising your own page. On the influence side: make content extractable, meaning clear question-shaped headings, a direct answer in the first two sentences under each heading, tables for comparisons, and explicit entities rather than pronouns. Keep facts, prices and dates current and dated, because assistants prefer sources that look maintained.

Ship real structured data (Organization, Product, FAQPage where genuinely applicable, and consistent sameAs links) so entity resolution connects your brand across sources. Earn mentions on the third-party pages that actually get cited for your category. And decide deliberately whether to allow the AI crawlers in robots.txt, since blocking GPTBot removes you from the citation pool entirely.

# 1. Are AI crawlers fetching you at all?
awk '/GPTBot|OAI-SearchBot|PerplexityBot|ClaudeBot|Google-Extended|Bytespider/ {print $12, $7, $9}' \
  access.log | sort | uniq -c | sort -rn | head -25

# 2. robots.txt: an explicit decision, not a default
User-agent: GPTBot
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

# 3. AI referral traffic in GA4 (BigQuery)
SELECT
  collected_traffic_source.manual_source AS src,
  REGEXP_EXTRACT((SELECT value.string_value FROM UNNEST(event_params)
                  WHERE key = 'page_referrer'), r'https?://([^/]+)') AS referrer_host,
  COUNT(DISTINCT user_pseudo_id) AS users,
  COUNTIF(event_name = 'generate_lead') AS leads
FROM `project.analytics_123456789.events_*`
WHERE _TABLE_SUFFIX BETWEEN '20260701' AND '20260731'
GROUP BY src, referrer_host
HAVING referrer_host LIKE '%chatgpt%' OR referrer_host LIKE '%perplexity%'
    OR referrer_host LIKE '%gemini%'  OR referrer_host LIKE '%copilot%'
ORDER BY users DESC;

Answer

A CFO signs off when three things are true: the revenue figure ties to the accounts, the cost figure includes everything, and the method is stable enough to compare month over month. Start with cost. Blended CAC uses total sales and marketing cost divided by total new customers, and total means media spend plus agency retainers plus creative production plus marketing salaries plus tooling.

Marketers habitually quote media-only CAC, finance always means fully loaded, and half the arguments in the room come from that mismatch, so publish both, labelled. Revenue must come from the ledger, net of refunds, cancellations, GST and payment gateway fees, on the transaction date, which is where platform reporting always diverges because it reports on impression date and gross value. New customers must be defined explicitly (first paid order, deduplicated on hashed phone number rather than on email, because Indian consumers frequently reuse phone numbers across accounts and rarely reuse email).

For shared credit, do not pretend to solve attribution in the CFO deck. Present three columns side by side: blended CAC, which is unarguable and is the number the board should track; channel CAC on a single stated attribution rule such as last non-direct click, labelled as directional; and incremental CAC for the channels where you have run a holdout, labelled with the test date. Then add a payback view: cumulative contribution margin by monthly cohort against fully loaded CAC, with the payback month highlighted.

Include a reconciliation block at the bottom showing warehouse revenue versus the finance figure and the size of the gap, and never let that gap be invisible. A dashboard that admits a two percent unexplained variance is trusted far more than one that silently rounds it away.

-- Monthly blended CAC and cohort payback, fully loaded
WITH cost AS (
  SELECT month,
         SUM(media_spend)      AS media,
         SUM(agency_fees)      AS agency,
         SUM(creative_cost)    AS creative,
         SUM(salaries + tools) AS overhead
  FROM marketing_costs GROUP BY month
),
new_customers AS (
  SELECT DATE_TRUNC(first_paid_at, MONTH) AS month,
         COUNT(DISTINCT customer_key)     AS new_customers
  FROM (
    SELECT SHA256(LOWER(TRIM(phone))) AS customer_key,
           MIN(paid_at)               AS first_paid_at
    FROM orders WHERE status = 'paid' GROUP BY 1
  ) GROUP BY 1
)
SELECT
  c.month,
  ROUND(c.media / n.new_customers, 0)                              AS cac_media_only,
  ROUND((c.media + c.agency + c.creative + c.overhead)
        / n.new_customers, 0)                                      AS cac_fully_loaded,
  n.new_customers
FROM cost c JOIN new_customers n USING (month)
ORDER BY c.month;

Answer

Ten times spend in six months means the constraint moves from optimisation to supply: supply of creative, supply of addressable audience, and supply of margin. Plan against all three. Structure first: consolidate rather than fragment.

A small number of broad prospecting ad sets under Advantage campaign budget concentrates conversion events so the ad sets stay out of Learning limited, whereas ten narrowly targeted interest ad sets will each starve. Keep a separate retargeting campaign with its own budget cap, and hold it deliberately small, because retargeting ROAS looks wonderful and is the least incremental spend in the account. Creative next, and this is the real bottleneck.

At ₹50 lakh a month you need a production pipeline capable of shipping a meaningful number of genuinely distinct concepts per week, not variants of one concept, plus a testing structure that gives each concept enough budget to reach statistical relevance. Track first-time impression ratio and CTR decay per concept so you retire creative before CPA rises. Audience: expect frequency to climb and marginal returns to fall as you saturate the addressable pool, so plan geographic and language expansion (Hindi and regional-language creative regularly unlocks cheap reach that English-only accounts never see) and new placements such as Reels and Advantage+ catalogue.

Bidding: stay on highest volume or a value target while scaling and accept that a cost cap will throttle delivery precisely when you need volume, then reintroduce caps once you are at target scale. Ramp discipline: raise budget in steps of roughly 20 percent every two to three days rather than in jumps, or use a duplicate campaign at a higher budget to preserve the learned state. Finally, set expectations honestly with the business.

ROAS will fall as you scale, because you are buying further down the response curve. Agree the target as marginal ROAS and contribution margin, not the blended number that made the case at ₹5 lakh.

Answer

Sequence matters more than ambition, and the failure mode for this role is launching campaigns in week two on a funnel nobody has measured. Days 1 to 30, establish ground truth. Interview ten to fifteen customers and every salesperson, and ask specifically how the deals that closed actually started, because founder-led sales usually hides the real acquisition channel.

Audit the data: is there a single definition of a lead, does the CRM record source, does the website even fire analytics correctly, and can you produce a pipeline number by channel today. Fix the tracking plan and the CRM field mapping before anything else, because every later decision depends on it. Build a baseline: traffic, MQL, SQL, opportunities, win rate, ACV, sales cycle length, and CAC payback.

Days 31 to 60, find the wedge. B2B SaaS in India usually has three plausible motions: outbound to a defined ICP, inbound content and SEO on problem-aware queries, and partnerships or marketplaces. Run cheap tests on two of them rather than committing to one, with pre-declared success criteria.

For paid, start with high-intent search on competitor and category terms with a small budget, because it tells you within three weeks whether the category has search demand at all, which for a new category it often does not. Set up LinkedIn conversion tracking and offline conversion upload so bidding optimises on opportunities rather than form fills. Days 61 to 90, pick and instrument.

Kill what did not clear the bar, double the budget on what did, publish a weekly dashboard the founders read, and put a quarterly experiment roadmap in place. The organisational trap to name explicitly: if sales and marketing do not share one definition of a qualified lead and one number they are both measured on, none of this survives the first bad month.