Santosh Mahanty • AdTech Solutions Engineer

Santosh Mahanty
AdTech Solutions Engineer

Programmatic • CTV • APIs • Ad Serving • Technical Operations

I build, troubleshoot and explain advertising technology systems across programmatic advertising, CTV, ad serving, APIs, integrations and data.

💼 View Technical Work 📄 Download Resume ⚡ Explore AdTech Labs
10+ Years Experience Programmatic CTV OpenRTB GAM APIs SQL Python
SOLUTIONS ENGINEERING DOMAINS

What I Solve

Bridging commercial ad operations, partner integration pipelines, and engineering infrastructure. Here are the six technical areas I diagnose and automate daily.

AUCTION MECHANICS & PROTOCOLS

Programmatic Troubleshooting

Bid requests, auctions, delivery and optimization.

Resolving bid request drops, timeout (tmax) tuning, invalid ext.eids, floor price blocks, and Prebid.js client vs server auction latency.

OpenRTB 2.6 Prebid.js tmax Floors ext.eids
STREAMING & SSAI

CTV & Video

VAST, VMAP, SSAI, ad pods, playback and measurement.

Triaging VAST 100–901 error cascades, SCTE-35 cue marker detection, dynamic transcoding, ad pod duration limits, and manifest stitching.

VAST 4.2 SSAI SCTE-35 HLS Ad Pods
DECISIONING & YIELD

Ad Serving

GAM, targeting, line items, pricing and yield.

Configuring Google Ad Manager 360 priority hierarchy (Sponsorship P4, Standard P8, Price Priority P12), Unified Pricing Rules (UPR), and Delivery in Full (DIF) pacing.

GAM 360 Dynamic Allocation UPR P4/P8/P12 Pacing
REST & WEBHOOKS

APIs & Integrations

REST APIs, webhooks, postbacks and platform integrations.

Architecting OpenAPI 3.0 ad management endpoints, webhook event delivery with exponential backoff, rate limiting, and partner onboarding workflows.

REST APIs OpenAPI 3.0 Webhooks OAuth 2.0 cURL
TELEMETRY & PRIVACY

Measurement & Attribution

Pixels, MMPs, conversion tracking and discrepancies.

Validating 1×1 tracking beacon firing parity, cache-busting macros, IAB TCF v2.2 / GPP consent bitstream parsing, and zero-PII client attribution.

1×1 Pixels MMPs TCF v2.2 GPP Discrepancies
SQL & LOG AUTOMATION

Data & Automation

SQL, Python and automation for campaign/platform analysis.

Automating discrepancy audits with advanced SQL (CTEs, Window Functions), Python log parsing, billing reconciliation, and pacing anomaly detection.

SQL CTEs Python Log Parsing Pandas Reconciliation
PRIMARY DIFFERENTIATOR

Try the AdTech Labs

Don't just read about AdTech. Debug it.

Protocol AST Parser

OpenRTB Debugger

What it does:

Parses raw OpenRTB 2.5 and 2.6 JSON bid request payloads in real time against 20+ IAB schema rules, CTV podding arrays, and user consent parameters.

What you learn:

How DSPs evaluate bid requests, why bids get silently dropped due to timeout thresholds (tmax) or schema errors, and how to debug auction payloads.

Why would I use it:

Validate publisher and SSP payload compliance before sending live traffic to DSP bidders and investigate auction timeout drops.

Waterfall Simulation

GAM Simulator

What it does:

Interactive ad server decisioning simulator modeling line item priority tiers (1–16), Unified Pricing Rules (UPR), and real-time Prebid.js CPM competition.

What you learn:

How dynamic allocation selects winning creatives, why guaranteed reservations outrank high CPMs, and how price floors block eligible inventory.

Why would I use it:

Simulate complex line item priority conflicts, forecast dynamic allocation wins, and audit floor pricing impact on yield.

Video Protocol Workbench

VAST Debugger

What it does:

In-depth VAST 2.0–4.2 XML specification analyzer with complete 100–901 error code matrix, multi-wrapper chain resolution, and quartile beacon inspection.

What you learn:

How video players parse XML instructions, resolve wrapper redirects, handle CORS headers, and triage playback failure cascades.

Why would I use it:

Decode mysterious video player drop-offs, pinpoint wrapper redirect depth violations, and resolve CORS beacon delivery failures.

Streaming Architecture

CTV / SSAI Lab

What it does:

Server-Side Ad Insertion workbench demonstrating SCTE-35 cue marker detection, dynamic transcoding, and #EXT-X-DISCONTINUITY manifest manipulation.

What you learn:

Why SSAI buffering and audio loudness jumps occur, how live manifest timing works, and how to verify client vs server beacon firing parity.

Why would I use it:

Test live streaming ad pod insertion, identify discontinuity timestamp drift, and troubleshoot SSAI tracking discrepancies.

REST API Testbench

API Sandbox

What it does:

Live OpenAPI 3.0 testbench with interactive endpoints, query parameter controls, instant cURL snippet generator, and response latency telemetry.

What you learn:

How to authenticate, paginate, filter, and debug programmatic ad management and performance telemetry APIs.

Why would I use it:

Test live API request payloads, inspect JSON schemas, and generate production-ready integration cURL commands.

Bitstream Parser

Consent Decoder

What it does:

Binary bitstream decoder for IAB Europe TCF v2.2 and Global Privacy Platform (GPP) strings, decoding Purpose 1–10 grants and vendor permissions.

What you learn:

How user consent signals are encoded into base64 bitmasks and how CMP consent strings govern programmatic bid eligibility under GDPR.

Why would I use it:

Verify whether user consent strings permit programmatic ad selection and diagnose why European DSPs are no-bidding.

Analytics & Triage

SQL / Data Lab

What it does:

AdTech analytics workbench featuring advanced SQL query templates for discrepancy detection, eCPM calculation, and multi-partner billing reconciliation.

What you learn:

How to write CTEs, window functions, and log aggregations to isolate billing discrepancies and pacing anomalies across partner logs.

Why would I use it:

Audit multi-million record ad server logs, reconcile publisher vs advertiser discrepancies, and automate revenue reporting.

SOLUTIONS ENGINEERING PLAYBOOKS

Featured Case Studies

Structured root-cause investigations, architectural remediations, and yield optimizations across CTV, programmatic, and ad serving ecosystems.

Production-Inspired Case Study Tier-1 Connected TV (CTV) OEM Streaming Platform & Ad Server

CTV Ad Pod Delivery & Pacing Governance

Problem:

Critical under-delivery on high-value CTV guaranteed line items during peak viewing hours, accompanied by unallocated pod slots and client escalations.

Investigation:

Analyzed SSAI manifest logs, player VAST request timeouts, and ad server pacing algorithms. Correlated pod duration (poddur) limits with creative duration mismatches.

Root Cause:

Multi-partner VAST wrappers lacked duration constraints, causing player timeouts (>2500ms) and pod truncation when creative lengths exceeded available SCTE-35 commercial breaks.

Solution:

Deployed strict VAST response duration validation, configured fallbacks for wrapper timeout cascades, and implemented automated hourly pacing variance monitoring.

Result:

Eliminated end-of-month under-delivery escalations, stabilized pod fill rates across CTV inventory, and ensured 100% Delivery in Full (DIF) across North American campaigns.

My Role:

AdTech Solutions Engineer — incident triage, log trace analysis, SSAI partner coordination, and pacing SOP implementation.

Architecture Flow: Live HLS Stream → SCTE-35 Cue → SSAI Router → VAST Pod Request (tmax 1500ms) → Duration Guard → #EXT-X-DISCONTINUITY → Player Render
Production-Inspired Case Study Tier-1 High-Scale Mobile FinTech App & Marketplace (300M+ Requests/Day)

High-Scale Programmatic Header Bidding & Dynamic Floor Optimization

Problem:

Severe auction latency timeouts during high-traffic promotional events, resulting in a 24% drop in bid density and lost programmatic yield.

Investigation:

Captured in-app client-side network traces and Prebid Server (PBS) auction logs. Measured bidder response distributions against auction timeout (tmax).

Root Cause:

Client-side bidder timeouts were set too aggressively (150ms) for high-latency mobile networks, while bid granularity was configured in broad $0.50 steps, leaving high bids unmonetized in GAM price priority tiers.

Solution:

Migrated heavy client-side bidder calls to Prebid Server (PBS), optimized client timeout thresholds to a dynamic 300ms window, and implemented fine-grained $0.05 price buckets in GAM 360 dynamic allocation.

Result:

Reduced client-side auction timeouts by 40%, restored multi-bidder competition density, and increased overall programmatic yield without impacting app rendering speed.

My Role:

Solutions Engineer / Technical Specialist — Prebid architecture audit, GAM priority tier alignment, and yield optimization.

Architecture Flow: App Event → Prebid Server (PBS) → Multi-SSP Auction (tmax 300ms) → Top Bid to GAM 360 → Dynamic Allocation ($0.05 Buckets) → Winning Creative
Technical Simulation & Root-Cause Playbook Multi-Tier Video Exchange, Primary Ad Server & Third-Party Measurement Vendor

Multi-Partner Impression Discrepancy & VAST Wrapper Resolution

Problem:

Persistent 18% reporting discrepancy between publisher ad server impression counts and advertiser third-party measurement billing numbers.

Investigation:

Executed end-to-end HAR network trace captures across multiple browsers and mobile environments. Tracked HTTP status codes and CORS response headers for all creative assets and tracking pixels.

Root Cause:

A 4-level deep VAST wrapper chain introduced a redirect to an uncompressed tracker missing Access-Control-Allow-Origin: * headers, causing modern browsers to drop the impression beacon while the video ad played.

Solution:

Enforced a maximum 2-wrapper depth policy, configured automated CORS header validation in the ad tag ingestion pipeline, and aligned pixel firing triggers from VAST <Impression> to player start event.

Result:

Reduced tracking discrepancy from 18% down to an industry-standard 2.1%, restoring billing parity and preventing partner credit reconciliations.

My Role:

Technical Lead — HAR packet inspection, IAB VAST specification enforcement, and partner remediation SOP.

Architecture Flow: Video Player → VAST Ad Request → Wrapper 1 → Wrapper 2 → InLine XML → CORS Check (* allowed) → Impression Beacon (204 No Content) → Reconciliation Engine
SOLUTIONS ENGINEERING THINKING

How I Think

A disciplined 8-step framework for diagnosing and resolving complex AdTech failures across ad servers, programmatic exchanges, and streaming clients.

Step 01

Reproduce

Recreate the reported anomaly in a controlled sandbox using identical targeting parameters, device headers, and protocol inputs.

Step 02

Isolate

Narrow down the fault domain: client-side video player, SSP auction timeout, ad server priority tier, or DSP bid response.

Step 03

Inspect

Extract and inspect raw network packets, OpenRTB JSON AST, VAST XML trees, CORS response headers, and tracking beacon firing logs.

Step 04

Hypothesis

Formulate a testable engineering hypothesis based on IAB specifications, network latency constraints, or floor price dynamics.

Step 05

Validate

Verify the hypothesis with synthetic test requests, payload parameter overrides, or staged mock endpoints before touching production.

Step 06

Fix

Deploy targeted remediation: correct schema violations, adjust auction timeout thresholds (tmax), realign GAM priority tiers, or configure CORS.

Step 07

Monitor

Track real-time delivery telemetry, error rate metrics (e.g. VAST 303/405), and billing parity logs to confirm sustained recovery.

Step 08

Document RCA

Author a structured Root Cause Analysis (RCA) covering incident timeline, root cause, immediate remediation, and partner prevention SOP.

✓ Standard SOP
TECHNICAL PROFICIENCIES

Technology Stack

Core technologies, protocols, and data tooling used in production solutions engineering and technical operations.

AdTech

Ad server orchestration, real-time bidding protocols, and exchange wrappers.

CTV / Video

Ad pod architecture, SSAI manifest manipulation, and streaming cue fidelity.

Data

Analytical query engineering, automated log processing, and reporting pipelines.

Measurement

Mobile Measurement Partners (MMPs), attribution parity, and tracking beacons.

APIs

Integration endpoints, payload formatting, event dispatch, and webhook callbacks.

ENGINEERING BUILDS

Projects

High-signal technical tools, diagnostic utilities, and data engines built to solve real-world AdTech operations and integration challenges.

Ad Campaign Analyst (MCP & Python Analytics Engine)

Python MCP Server SQLite / Pandas Campaign Analytics JSON-RPC
Problem:

AdOps and Solutions Engineers spend hours manually calculating eCPMs, pacing variances, and anomalous under-delivery spikes across fragmented campaign CSV reports.

What was built:

Model Context Protocol (MCP) server & automated analytical suite that ingests multi-platform campaign logs, calculates pacing anomalies, and surfaces underperforming placements via structured tool calls.

Technical Architecture: Client Prompt → MCP Protocol JSON-RPC → SQLite / Pandas Engine → Pacing & Anomaly Evaluator → Structured Diagnostic Output

OpenRTB 2.6 AST Parser & Validator Engine

OpenRTB 2.6 JavaScript AST JSON Schema TCF v2.2 EIDs / UID2
Problem:

Misconfigured bid requests (missing poddur, negative floors, unencoded consent strings) cause silent bid drops and auction rejections.

What was built:

In-browser JSON AST analyzer validating real-time bid requests and responses against 20+ IAB schema constraints, CTV podding specifications, and user consent parameters with instant Jira/Slack export.

Technical Architecture: Raw Payload → RFC 8259 Parser → AST Visitor → Category Evaluators (Inventory, User, Regs, Schain, tmax) → Readiness Scoreboard → Jira Export

GAM 360 Dynamic Allocation & Waterfall Simulator

Google Ad Manager Dynamic Allocation Price Priority UPR Floors Prebid.js
Problem:

Line item priority contention (P4 vs P8 vs P12) and floor price interactions often lead to unexpected delivery drops for high-value campaigns.

What was built:

Interactive simulation engine modeling line item priority hierarchies against external Prebid.js header bidding bids and Unified Pricing Rules (UPR) with step-by-step auction logs.

Technical Architecture: Ad Request Event → Priority Tier Evaluation (P4 → P8 → P12) → Floor Comparison (UPR) → Header Bidding Bid Injection → Winner Resolution

OpenAPI 3.0 Interactive Testbench & Latency Telemetry

OpenAPI 3.0 REST APIs cURL Generator Latency Telemetry Token Auth
Problem:

Integrating new demand and supply partners requires manual endpoint testing, query parameter validation, and latency benchmarking.

What was built:

Live OpenAPI 3.0 developer testbench with interactive endpoints, query parameter controls, instant cURL snippet generator, and response latency gauges for AdTech integrations.

Technical Architecture: OpenAPI Spec JSON → Dynamic Form Generator → Request Dispatcher → Microsecond Performance Profiler → Response Preview

AdTech SQL Discrepancy & Reconciliation Engine

SQL (PostgreSQL) CTEs & Window Functions Billing Reconciliation Pacing Audits
Problem:

Publisher vs advertiser impression reporting regularly diverges by 10–20%, requiring complex multi-table SQL queries to isolate the root cause.

What was built:

Advanced SQL analytical workbench implementing Common Table Expressions (CTEs), window functions, and multi-partner billing reconciliation to isolate pacing variances and impression discrepancies.

Technical Architecture: Publisher Log Table → SSP Billable Table → Full Outer Join on Date/Placement → Variance Calculation → Threshold Anomaly Flagging

Python Telemetry & Log Parser Automation

Python 3 Log Parsing Pandas Error Cascades Automated Alerts
Problem:

Video ad delivery failures in CTV environments generate millions of unindexed log lines that cannot be inspected manually.

What was built:

Production-grade Python script library for parsing massive ad server logs, detecting VAST 405 codec error spikes, and automating partner discrepancy alerts.

Technical Architecture: Raw Ad Server Log Stream → Regex Tokenizer → Error Classifier → Time-Window Aggregator → Incident Alert & HAR Exporter
SYSTEMATIC MASTERY

Learn → Practice → Prove

The core product methodology: master the protocol concept, practice inside an interactive technical workbench, and prove competence through real-world triage scenarios.

OpenRTB & Programmatic Auctions

01. LEARN

Auction Architecture & Specs

Deep breakdown of OpenRTB 2.5/2.6 JSON object models, impression arrays, podding rules, and floor price dynamics.

Read OpenRTB Guide →
02. PRACTICE

Interactive AST Validator

Paste raw JSON bid requests to detect missing poddur fields, invalid ext.eids, and unencoded consent strings in real time.

Open RTB Validator →
03. PROVE

Diagnose Low Bid Response Rate

Analyze why DSPs drop bid responses during high-volume CTV auction bursts with aggressive tmax thresholds.

Solve Triage Scenario →

Google Ad Manager & Waterfall Decisioning

01. LEARN

Line Item Priority Hierarchy

How GAM 360 evaluates Sponsorship (P4), Standard (P8), and Price Priority (P12) against Prebid.js and UPR floors.

Read GAM Architecture →
02. PRACTICE

Dynamic Allocation Simulator

Simulate line item competition, adjust header bidding CPM inputs, and watch step-by-step waterfall decisions unfold.

Run Waterfall Lab →
03. PROVE

Resolve Delivery Conflicts

Debug why a high-CPM line item is not delivering despite matching targeting, due to guaranteed pacing reservations.

Solve GAM Scenario →

Connected TV (CTV) & Video Protocols

01. LEARN

VAST 4.2 & SSAI Specifications

Master InLine vs Wrapper XML trees, quartile tracking lifecycles, and SCTE-35 cue markers for server-side stitching.

Read VAST 4.2 Guide →
02. PRACTICE

SSAI Manifest Manipulation Lab

Inspect HLS .m3u8 discontinuity tags, simulate creative transcoding, and verify client vs server beacon firing parity.

Launch SSAI Lab →
03. PROVE

Triage CTV Pod Truncation

Investigate a live CTV ad pod truncation incident caused by multi-wrapper timeout cascades during live sports broadcasts.

Inspect CTV RCA →

Data Analytics & Discrepancy Reconciliation

01. LEARN

SQL for AdTech & eCPM Formulas

Learn essential AdTech metrics (Fill Rate, eCPM, VTR) and how ad servers calculate delivery pacing and win rates.

Read SQL Guide →
02. PRACTICE

SQL Query & CTE Workbench

Execute practical SQL queries using Common Table Expressions and window functions to detect impression discrepancy spikes.

Open SQL Lab →
03. PROVE

18% Partner Discrepancy RCA

Conduct deep HAR network trace analysis to isolate CORS header drops and resolve multi-partner billing disputes.

Review Billing RCA →

Sequential Learning Pathway

AdTech Engineering Curriculum: Step by Step

Follow this 8-step sequential curriculum designed to guide you from foundational terminology to production-grade Solution Engineering. Click any topic or subtopic to explore.

Step 01 Foundations

100+ core industry terms (DSP, SSP, DMP, eCPM, schain, SPO, UID2) with plain-English definitions and architecture context.

Step 02 Protocols

Annotated OpenRTB 2.6 JSON bid request/response payloads, impression objects, floor pricing, and first-price clearing logic.

Step 03 Ad Serving

Line item priority hierarchy (1–16), price priority competition, key-value targeting rules, and delivery pacing diagnostics.

Step 04 Header Bidding

Client-side wrapper vs Prebid Server architectures, price granularity tiers, and passing hb_pb targeting into GAM.

Step 05 Video Protocols

InLine vs Wrapper XML structures, tracking event lifecycles (quartiles), and IAB error code troubleshooting (100–901).

Step 06 Connected TV

Server-Side Ad Insertion, HLS manifest manipulation (#EXT-X-DATERANGE), SCTE-35 cue markers, and ad pod management.

Step 07 Compliance

GDPR consent strings (TCF v2.2), CCPA/CPRA US Privacy flags, COPPA child-directed rules, and Consent Mode v2 operational impacts.

Step 08 Evaluation

Validate your mastery with 20 real-time questions across programmatic, video, and ad serving architecture with instant feedback.

FOR RECRUITERS & HIRING MANAGERS

Looking for an AdTech Solutions Engineer, Technical Account Manager, AdOps or Programmatic specialist?

Here is the 30-second summary: 10+ years of technical AdTech execution across programmatic auctions, CTV/SSAI video workflows, ad serving decisioning, and data integrations. Specialized in OpenRTB 2.6, GAM 360, VAST 4.2, REST APIs, Python, and SQL — building toward high-impact Solutions Engineering and Technical Account Management roles.

10+ Years Programmatic CTV AdOps APIs Troubleshooting Data
GET IN TOUCH

Let's Talk AdTech

Looking to discuss Solutions Engineering opportunities, evaluate technical architecture, or debug a tricky programmatic integration? Reach out directly.

Santosh Mahanty

AdTech Solutions Engineer

Always open to discussing AdTech system integrations, CTV/SSAI streaming workflows, header bidding yield optimization, and Solutions Engineering / Technical Account Management roles.

Bangalore, India • Open to Remote / Relocation

Direct Inquiry

Have a technical question or an open opportunity? Send a message directly via email or LinkedIn.

AdTech Toolkit

Enter any two values
to calculate the third

More tools coming soon