The Analytics Gap in Playable Ads
Playable ads are a unique corner of mobile advertising. Unlike video ads or static banners, playables are interactive — users tap, swipe, drag, and make decisions. This interaction data is gold for optimizing creative performance, yet most ad platforms treat playables as black boxes: you get impression count, click count, and install count. Nothing in between.
That missing middle — what happens during the 3-15 seconds a user plays your ad — contains the signals that separate top-performing creatives from budget wasters.
PlayableAd Studio bridges this gap with an analytics pipeline built on Cloudflare Workers Analytics Engine and D1. Every interaction in a playable ad becomes a structured data point, enabling granular optimization that no ad network provides out of the box.
The Three-Layer Analytics Architecture
Layer 1: Edge Ingestion (Workers Analytics Engine)
Every playable ad served through PlayableAd Studio fires lightweight HTTP beacon requests to a Cloudflare Worker. These requests carry structured event data:
```json
{
"ad_id": "fruit-match-v2",
"session_id": "sess_7xkLm9qR",
"variant": "B",
"events": [
{"type": "impression", "ts": 0},
{"type": "tap", "ts": 1.2, "x": 240, "y": 315},
{"type": "match", "ts": 3.8},
{"type": "swipe", "ts": 5.1, "dx": 80, "dy": -40},
{"type": "level_complete", "ts": 8.4},
{"type": "cta_tap", "ts": 9.2},
{"type": "install", "ts": 14.7}
],
"device": "iPhone 14",
"country": "US",
"network": "Meta"
}
```
Workers Analytics Engine is the perfect fit here because it handles **high cardinality** (every session is unique) at **massive throughput** (thousands of writes per second) with **predictable costs** ($0.25 per million writes).
```javascript
// Worker: analytics ingestion endpoint
export default {
async fetch(request, env) {
const event = await request.json();
// Write to Analytics Engine
env.PLAYABLE_EVENTS.writeDataPoint({
blobs: [event.ad_id, event.variant, event.country, event.network],
doubles: [
event.events.length,
event.events.filter(e => e.type === 'tap').length,
event.events.filter(e => e.type === 'cta_tap').length,
event.events.some(e => e.type === 'install') ? 1 : 0
],
indexes: [event.ad_id]
});
// Cache summary in D1 for dashboard queries
await env.DB.prepare(
`INSERT OR REPLACE INTO ad_daily_stats
(ad_id, variant, date, impressions, installs, avg_taps, avg_session_duration)
VALUES (?, ?, date('now'), ?, ?, ?, ?)`
).bind(
event.ad_id, event.variant,
1, event.events.some(e => e.type === 'install') ? 1 : 0,
event.events.filter(e => e.type === 'tap').length,
event.events[event.events.length - 1]?.ts || 0
).run();
return new Response("ok", { status: 200 });
}
}
```
Layer 2: Aggregation (D1 + Cron)
Analytics Engine handles raw ingestion. For dashboard queries, D1 stores pre-aggregated hourly and daily summaries. A cron-triggered Worker runs every 30 minutes:
```sql
-- Hourly aggregation query
INSERT INTO ad_hourly_stats (ad_id, variant, hour, impressions, installs, cvr)
SELECT
ad_id,
variant,
DATE_TRUNC('hour', NOW()) as hour,
COUNT(*) as impressions,
SUM(install_flag) as installs,
ROUND(SUM(install_flag) * 100.0 / COUNT(*), 2) as cvr
FROM blobs
WHERE timestamp > DATE_TRUNC('hour', NOW() - INTERVAL '1 hour')
GROUP BY ad_id, variant;
```
Layer 3: Visualization (Dashboard)
The D1-powered dashboard from the previous post renders these metrics in real-time. Key dashboards include:
**Creative Performance Dashboard**
- Impressions, installs, CVR by variant
- 7-day trend lines
- Geographic breakdown (top 10 countries)
- Device breakdown (iOS vs Android, model distribution)
**Funnel Analysis**
- Impression → Tap → Level Start → Level Complete → CTA Tap → Install
- Drop-off rates at each stage
- Average time between stages
**Heatmap Overlay**
- Tap coordinates aggregated per creative variant
- Z-order: which UI elements users interact with most
- Dead zones: areas users ignore
Identifying Winning Creative Patterns
With structured event data, you can answer questions traditional ad platforms can't:
**Does game difficulty correlate with install rate?**
```sql
SELECT
variant,
AVG(level_completion_pct) as avg_completion,
AVG(install_rate) as avg_install_rate,
CORR(level_completion_pct, install_rate) as correlation
FROM ad_hourly_stats
WHERE ad_id = 'fruit-match-v2'
GROUP BY variant;
```
**At what second do users tap the CTA most often?**
Aggregating CTA tap timestamps reveals the optimal moment to present the install prompt.
**Which device types convert best?**
iPhone users might convert at 8%, while Android users convert at 4.5% for the same creative — suggesting different optimization strategies per platform.
Integration with Ad Networks
The analytics pipeline doesn't replace ad network reporting — it supplements it. PlayableAd Studio's MRAID container fires network-standard trackers (impression, click, install) alongside the custom analytics beacons:
```
┌─────────────────────────────────┐
│ MRAID Playable Ad Container │
├─────────────────────────────────┤
│ ┌───────────────────────────┐ │
│ │ Game Loop │ │
│ │ (Canvas/WebGL) │ │
│ └───────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────┐ │
│ │ Analytics Beacon │───────►│ Cloudflare Worker
│ │ (custom events) │ │ → Analytics Engine
│ └─────────────────────┘ │ → D1 Dashboard
│ │ │
│ ▼ │
│ ┌─────────────────────┐ │
│ │ Network Tracker │───────►│ Meta/Google/TikTok
│ │ (impression/click) │ │ (for campaign attribution)
│ └─────────────────────┘ │
└─────────────────────────────────┘
```
Cost Analysis
| Component | Volume (Monthly) | Cost |
|-----------|-----------------|------|
| Analytics Engine writes | 5M events | $1.25 |
| D1 reads (dashboard) | 100K queries | $0.03 |
| Worker invocations | 5M | $0.50 |
| D1 storage | ~500MB | ~$0.75 |
| **Total** | | **~$2.53/month** |
For less than $3/month, you get a full analytics pipeline that ad networks would charge thousands for or not provide at all.
Summary
The gap between "user tapped install" and understanding why is where most playable ad budgets get wasted. PlayableAd Studio's three-layer analytics architecture — Workers Analytics Engine for ingestion, D1 for aggregation, and edge-powered dashboards for visualization — fills that gap at near-zero marginal cost.
By treating every user interaction as a structured data point, you can optimize playable ad creatives with surgical precision instead of gut feelings. And because the whole pipeline runs on Cloudflare's global network, there's no latency penalty for collecting data at the edge while users play.