Build a member-retention dashboard for your fitness platform

Members who build a workout habit in their first two weeks stick around; the rest quietly stop opening the app. If you run a streaming-fitness platform, your view data already knows which members are on each path, which instructors keep people coming back, and which classes get abandoned halfway. This article turns that data into a retention dashboard your team can act on every week.

The whole thing runs on one export: member health, an instructor scorecard, a program funnel, and the nudge list for members slipping away.

Here's the dashboard you'll build, from the sample below. Early-habit members retain far better, one instructor keeps members despite middling completion, and some class abandonment is a buffering problem, not a content one.

How the data flows

fitness-platform-sample-synthetic.csv: https://drive.google.com/file/d/1c5ymLjbjsQrEk5spqblbFHBVSqrUp4Ue/view?usp=sharing

Illustrative synthetic data (not real members): ~210 members, 6 instructors, 24 classes over an 8-week window, modeled on the documented early-habit retention mechanic. 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 members.

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 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>

Fitness runs on the living-room TV as much as the phone, so instrument every surface. The monitoring SDK captures the same data from hls.js, video.js, native mobile, and TV players:

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 member, instructor, and program

The retention questions all need these three. Pass them in custom dimensions so every view can be grouped by who watched, who taught, and which program it belongs to:

fastpixMetrix.tracker(videoElement, {
  hlsjs: hls,
  Hls: Hls,
  data: {
    workspace_id: "YOUR_WORKSPACE_KEY",
    custom_2: member.id,            // who is working out
    custom_7: klass.instructor,     // who teaches the class
    custom_9: klass.program,        // which program / challenge
  },
});

Step 3: Export the views

Export from the Video Data dashboard (Views → Export CSV) or the export API, which is what a weekly job pulls. The columns this article uses: viewer_id, member_since, video_title, custom_instructor, custom_program, video_duration, view_start, view_max_playhead_position (how far they got), view_total_content_playback_time (watch time), device_type, and buffer_count.

Part 2: Build the dashboard

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

Step 4: Member health from the first-14-days signal

Load views, compute completion per view, and flag whether each member built the early habit (3+ workouts in their first 14 days). Then classify members by how recently they last worked out.

import chdb

v = chdb.query("""
    SELECT viewer_id AS member, member_since AS enrolled, view_start AS watched_at,
           custom_instructor AS instructor, custom_program AS program,
           CAST(video_duration AS Int64) AS dur,
           CAST(view_max_playhead_position AS Int64) AS reach_ms,
           CAST(buffer_count AS Int64) AS buffers
    FROM file('fitness-platform-sample-synthetic.csv', CSVWithNames)
""", "DataFrame")
v["completion"]   = (v["reach_ms"] / v["dur"]).clip(upper=1.0)
v["days_since"]   = (v["watched_at"] - v["enrolled"]).dt.days

per_member = v.groupby("member").agg(
    classes=("instructor", "count"), last_watch=("watched_at", "max"),
    early=("days_since", lambda s: (s < 14).sum())).reset_index()
per_member["committed"] = per_member["early"] >= 3

A member is Active if they worked out in the last 10 days, At risk at 11–21 days idle, and Inactive beyond that. On the sample: 42% Active, 26% At risk, 32% Inactive.

Step 5: Prove the early-habit signal

Split members by whether they built the early habit, and compare how many are still active:

committed = per_member[per_member.committed]
other     = per_member[~per_member.committed]
lift = active_rate(committed) / active_rate(other)   # 59% vs 30% = 1.9x

Members who did 3+ workouts in their first 14 days are 1.9x more likely to still be active at week 8 (59% vs 30%). That single number is why the at-risk nudge in Part 4 fires on day 10, not day 30.

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

Step 6: Instructor scorecard

Group by instructor for completion and reach, then measure retention by home instructor: among members whose most-watched instructor is X, how many are still active.

scorecard = v.groupby("instructor").agg(
    completion=("completion", "mean"), members=("member", "nunique"))
# retention by home instructor: active-rate among members who mostly watch them

The scorecard earns its place by disagreeing with completion. In the sample, Robin Hale posts the highest completion (61%) but Cody Marsh retains slightly more of his members (50% vs 47%), and Sam Reyes has decent completion (55%) yet keeps only 15% of members active. High completion on a single class is not the same as keeping someone subscribed.

Step 7: Program funnel and class abandonment

Two more views your content team wants. The program funnel is a simple nested count (started → watched 3+ classes → watched 6+), so you can see where each program loses people. And when a class is abandoned before halfway, split the ones that had buffering from the ones that did not:

abandoned = v[v.completion < 0.5]
qoe_share = (abandoned.buffers > 0).mean()   # 9% were buffering, not content

Part 3: What the dashboard shows

Early habit is the retention lever. The 1.9x gap between early-habit members and everyone else is the signal to act on first. It tells you exactly where to spend: getting a new member to their third workout inside two weeks.

One instructor keeps members the class numbers would miss. Completion ranks instructors one way; retention ranks them another. An instructor whose members keep subscribing is worth more than one whose single classes complete slightly higher, and only the retention column surfaces that.

Nine percent of abandonment is a buffering problem, not a content one. Of the classes abandoned before halfway, 9% had buffering, mostly on the TV app. Those members did not dislike the workout; the stream failed them. That is a fix for engineering, not for the content team, and the split keeps you from blaming the wrong thing.

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 m in per_member.itertuples():
    if not m.committed and m.days_idle > 10:
        nudge(m.member, "Your next workout is waiting")       # win-back the slow starters
    elif m.health == "At risk":
        nudge(m.member, "Keep your streak going")             # re-engage before they lapse

On the sample this produces 55 at-risk nudges and 88 win-back nudges for members who never built the early habit. The same signals drive the workflows a fitness product 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 catalog: the early-habit window (3 workouts in 14 days fits most, but a daily-practice app might use 5 in 7) and the idle thresholds behind Active / At risk / Inactive. Everything else, the scorecard and funnel and nudges, runs unchanged.