Build an episode-funnel and paywall dashboard for your microdrama app

A vertical microdrama app lives or dies on three numbers: how many viewers the cold open holds past the first few seconds, how far they binge, and how many pay to unlock when the free episodes run out. Apps like ReelShort and DramaBox are built entirely around that funnel. This article turns your view data into the dashboard that tracks it: the episode funnel, the paywall unlock rate, the ep-1 hook rate, and a series leaderboard that shows which title needs which fix.

The whole thing runs on one export: where the binge stops, who crosses the paywall, and which series lost people before they ever got there.

How the data flows

FastPix Player SDK ──▶ FastPix Video Data ──▶ CSV export ──▶ chdb ──▶ episode funnel + paywall dashboard
(vertical mobile,       (completion, watch time,              (this article)   (funnel, hook rate,
 viewer + series +       playback events per view)                             unlock rate, leaderboard)
 episode + paywall
 in custom dimensions)

microdrama-sample-synthetic: https://drive.google.com/file/d/1qDISHq0DCkcpsZN_T-S8cxrRaFBAzmyc/view?usp=sharing

Illustrative synthetic data (not real viewers): ~460 viewers across 5 series of 15 episodes each, episodes 1–5 free and 6+ pay-to-unlock, with the full playback event stream on every view. Columns mirror a real FastPix Video Data export. Every snippet runs against it. No FastPix account yet? Start free with $25 credit (no credit card) and build this on your own app.

Part 1: Get view data flowing from your player

Playback happens in your player. FastPix Video Data captures every interaction from inside it: it dedupes the beacons, stitches events into sessions, adds geo and device data, and computes quality scores, across millions of concurrent views when you need it. What you export is one clean row per view, with a viewer ID and the full playback event stream on every row.

Already collecting views with FastPix? Skip to Part 2. New here? Setup is about ten minutes.

Step 1: Add the player (or add monitoring to the one you have)

<script src="https://unpkg.com/@fastpix/[email protected]/dist/player.js"></script>

<fastpix-player playback-id="YOUR_PLAYBACK_ID" stream-type="on-demand"></fastpix-player>

Microdrama is a vertical, mobile-first feed, so the monitoring SDK captures the same data from your in-app player, hls.js, or a native mobile player:

import fastpixMetrix from "@fastpix/data-core";

fastpixMetrix.tracker(videoElement, {
  hlsjs: hls,
  Hls: Hls,          // both are required
  data: { workspace_id: "YOUR_WORKSPACE_KEY" },
});

Step 2: Tag each view with viewer, series, episode, and paywall state

The funnel questions all need these. Pass them in custom dimensions so every view can be grouped by who watched, which series and episode it was, and whether that episode was behind the paywall:

fastpixMetrix.tracker(videoElement, {
  hlsjs: hls,
  Hls: Hls,
  data: {
    workspace_id: "YOUR_WORKSPACE_KEY",
    custom_2: viewer.id,                 // who is watching
    custom_3: series.title,              // which drama
    custom_4: episode.number,            // episode 1, 2, 3, ...
    custom_5: episode.locked ? "locked" : "free",   // paywall state
  },
});

That last dimension is what makes the paywall measurable. When a viewer plays a locked episode, they unlocked it, and the view data records the moment they paid without you touching the payment system.

Step 3: Export the views

Export from the Video Data dashboard (Views → Export CSV) or the export API, which is what a nightly job pulls. The columns this article uses: viewer_id, series_title, custom_episode, custom_paywall, video_duration, view_start, view_max_playhead_position (how far they got), view_total_content_playback_time (watch time), device_type, and events (the playback stream, used for the hook rate).

Part 2: Build the dashboard

The stack is chdb (embedded ClickHouse, pip install chdb). Same SQL later runs on a real ClickHouse.

Step 4: The episode funnel

Load the views and count how many distinct viewers reached each episode number. That staircase is the funnel, and the step where it falls off a cliff is the paywall.

import chdb, pandas as pd

v = chdb.query("""
    SELECT viewer_id AS viewer, series_title AS series,
           CAST(custom_episode AS Int64) AS ep, custom_paywall AS wall,
           CAST(video_duration AS Int64) AS dur,
           CAST(view_max_playhead_position AS Int64) AS reach_ms, events
    FROM file('microdrama-sample-synthetic.csv', CSVWithNames)
""", "DataFrame")

funnel = v.groupby("ep")["viewer"].nunique()
depth  = v.groupby("viewer")["ep"].max()          # binge depth per viewer

On the sample, the free episodes drop gently (460 → 264 → 227 → 195 → 186 across episodes 1 to 5), then the paywall at episode 6 takes it from 186 to 54. Average binge depth is 3.6 episodes. The free slope is a content question; the paywall step is a monetization one.

Step 5: Ep-1 hook rate

Vertical drama is a swipe-away feed. The first few seconds of episode 1 decide everything downstream, so measure the share of episode-1 viewers who got past them.

HOOK_MS = 5000   # held past the first 5 seconds = not a swipe-away
ep1 = v[v.ep == 1]
hook_rate = (ep1.reach_ms >= HOOK_MS).mean()      # 70% on the sample

70% of viewers hold past the cold open on the sample, which means three in ten swipe away before the story starts. That number is per-series in the leaderboard, and it caps everything: a viewer who never gets past the first seconds never reaches the paywall.

Step 6: The paywall unlock rate

This is the revenue gate. Of the viewers who reached the last free episode, how many went on to play a locked one.

PAYWALL_EP = 6
reached_wall = set(v[v.ep == PAYWALL_EP - 1].viewer)     # reached the last free episode
unlocked     = set(v[v.ep >= PAYWALL_EP].viewer)         # played a locked episode = paid to unlock
unlock_rate  = len(unlocked & reached_wall) / len(reached_wall)   # 29% on the sample

29% of the viewers who reached the wall paid to unlock. Across all viewers the payer share is 12%, which sits above the 2–5% that gets cited for Western short-drama apps because everyone in this sample actually started watching. Report your own number; the point is that this one gate, not the free episodes, is where the revenue is decided.

Start using FastPix for free - $25 credit, no credit card required. Build this on your own app this week. Create your workspace →

Step 7: The series leaderboard

Put hook rate, binge depth, and unlock rate side by side per series and you can see which title needs which fix.

def stats(s):
    sv = v[v.series == s]
    wall = set(sv[sv.ep == PAYWALL_EP - 1].viewer)
    unl  = set(sv[sv.ep >= PAYWALL_EP].viewer)
    return dict(series=s,
        hook=(sv[sv.ep == 1].reach_ms >= HOOK_MS).mean(),
        depth=sv.groupby("viewer")["ep"].max().mean(),
        unlock=len(unl & wall) / max(len(wall), 1))

The leaderboard is where the diagnosis lives. In the sample, one series holds 79% past the cold open, binges to nearly 5 episodes, and unlocks at 33%. Another holds only 45%, binges to 2.2, and unlocks at 8%. That second series does not have a paywall problem; it has a hook problem, and no amount of coin tuning fixes a cold open that loses half its viewers in the first seconds.

Part 3: What the dashboard shows

The paywall is the cliff, not the content. The free episodes lose viewers gradually; the drop at the unlock episode is a different kind of event. It is the one place where the question stops being "is this good enough to keep watching" and becomes "is this good enough to pay for." Watching that step, per series, tells you where to place the paywall and how hard the cliffhanger before it needs to land.

A weak hook caps everything downstream. Hook rate and unlock rate are the two real levers, and they fail independently. A series can convert well among the few who reach the wall yet still earn little because its cold open loses most viewers before episode 2. The leaderboard separates the two so you fix the right one.

Binge depth is the number to move. Every extra episode a viewer reaches before the paywall raises the odds they unlock, because they are more invested when the wall arrives. Depth is not a vanity metric here; it is the run-up to the revenue gate, which is why the cliffhangers on episodes 4 and 5 matter as much as the paywall price.

Part 4: Nudges that act on the dashboard

The dashboard is more useful when it drives your messaging. FastPix supplies the signals; your push, email, or in-app engine sends the message.

for viewer in reached_wall - unlocked:
    offer_coins(viewer, "Unlock the next episode - 50% off")   # the paywall-save, the biggest lever
for viewer in ep1[ep1.reach_ms < HOOK_MS].viewer:
    # swiped away on episode 1: a series-level hook problem, not a per-viewer one
    flag_weak_hook(series_of(viewer))

On the sample this produces 132 paywall-save offers for viewers who reached the wall and did not unlock, and flags 138 episode-1 swipe-aways into the series-level hook report. The same signals drive the workflows a microdrama app needs:

How different teams use this

Running this on your own data

Point Step 4 at your own export and set two things for your app: the paywall episode (set PAYWALL_EP to your lock point, or read it from custom_paywall directly) and the hook window (5 seconds fits vertical drama; a longer-form app might use 30). Everything else, the funnel and hook rate and leaderboard, runs unchanged.