Core gaming KPIs
User engagement metrics
- Daily active users (DAU): Count of unique players who engage with the game in a 24-hour period. DAU trends provide immediate insight into game health, with sustained declines indicating urgent issues requiring intervention.
def calculate_dau(events_df, target_date):
"""Calculate DAU for a specific date"""
daily_events = events_df[events_df['timestamp'].dt.date == target_date]
return daily_events['user_id'].nunique()
DAU trends offer instant insights into game performance, with persistent declines signaling serious problems requiring immediate action. Breaking down DAU by acquisition channel, device type, or geographic region reveals valuable information about audience demographics and helps identify targeted marketing opportunities.
- Monthly active users (MAU): Total unique players who accessed the game within the past month. MAU growth indicates expanding audience reach, while the DAU/MAU ratio reveals player engagement frequency.
def calculate_mau(events_df, end_date):
"""Calculate MAU for a 30-day period ending on specified date"""
start_date = end_date - pd.Timedelta(days=30)
monthly_events = events_df[(events_df['timestamp'].dt.date >= start_date) &
(events_df['timestamp'].dt.date <= end_date)]
return monthly_events['user_id'].nunique()
When used alongside DAU, the DAU/MAU ratio (often called "stickiness") indicates how frequently an average user returns:
def calculate_stickiness(dau, mau):
"""Calculate DAU/MAU ratio (stickiness)"""
return dau / mau if mau > 0 else 0
# Example: A stickiness of 0.2 means users engage approximately 6 days per month
Session metrics
Behavioral indicators tracking how players interact with the game. Session length measures time spent per play session, while session frequency shows how often players return. The correlation between these metrics reveals engagement patterns among different player segments.
Tracking sessions over time allows to detect changes in user engagement patterns. For example, decreasing session length might indicate content fatigue, while increasing session frequency could signal successful re-engagement campaigns.
The trend graph shows session length (orange) increasing over time from approximately 6-7 minutes in April 2024 to 10-12 minutes in April 2025, with a major spike to 22 minutes in December. Session frequency (pink) has remained relatively stable between 2-3 sessions throughout the year.
Monetization metrics
- Conversion rate: Percentage of players who make purchases, indicating monetization effectiveness. Platform-specific conversion rates highlight which environments generate better paying user conversion, informing platform prioritization decisions.
def calculate_conversion_rate(paying_users_count, total_users_count):
"""Calculate the conversion rate as a percentage"""
return (paying_users_count / total_users_count * 100) if total_users_count > 0 else 0
# Example: Platform-specific conversion rates
def calculate_platform_conversion(df):
"""Calculate conversion rates segmented by platform"""
result = {}
for platform in df['platform'].unique():
platform_data = df[df['platform'] == platform]
paying = platform_data[platform_data['paying_user'] == True]['user_id'].nunique()
total = platform_data['user_id'].nunique()
result[platform] = calculate_conversion_rate(paying, total)
return result
The industry average for mobile game conversion rates typically ranges from 2-5%, with variation by genre and monetization model.
- ARPPU & ARPDAU: ARPPU and ARPDAU are financial metrics that measure how effectively a game generates revenue from different user segments. ARPPU (Average Revenue Per Paying User) reveals how much money paying customers typically spend, while ARPDAU (Average Revenue Per Daily Active User) shows the average revenue generated by the entire player base.
def calculate_arppu(total_revenue, paying_users_count):
"""Calculate Average Revenue Per Paying User"""
return total_revenue / paying_users_count if paying_users_count > 0 else 0
def calculate_arpdau(total_revenue, dau):
"""Calculate Average Revenue Per Daily Active User"""
return total_revenue / dau if dau > 0 else 0
The ratio between ARPPU and ARPDAU provides insight into your monetization concentration:
def monetization_concentration(arppu, arpdau):
"""Calculate ratio between ARPPU and ARPDAU"""
return arppu / arpdau if arpdau > 0 else 0
# Example: A ratio of 50 means paying users spend 50x more than the average user
VIP revenue share: Percentage of total revenue generated by top-spending players. This metric reveals revenue concentration risk, with healthier games showing broader monetization distribution rather than dependency on a small group.
VIP revenue share fluctuates between 70-87% throughout the year, with the highest peaks in early 2024. The overall trend shows slight decline, suggesting growing monetization among non-VIP players, which indicates healthier revenue distribution.
A healthy game typically maintains VIP revenue share below 80%, with lower percentages indicating broader monetization success.
Player retention metrics: : Measurements of player return rates after specific time periods (D1=1 day, D7=7 days, D30=30 days). Strong retention curves indicate compelling gameplay and effective re-engagement mechanisms, with platform-specific retention highlighting technical or UX issues.
def calculate_retention(df, cohort_date, retention_day):
"""
Calculate retention rate for a specific day
Parameters:
- df: DataFrame with user_id and date columns
- cohort_date: The date of the original cohort
- retention_day: The day to check retention for (e.g., 1, 7, 30)
Returns:
- Retention rate as a percentage
"""
# Identify users in the original cohort
cohort_users = df[df['date'] == cohort_date]['user_id'].unique()
if len(cohort_users) == 0:
return 0
# Calculate target date for retention checking
target_date = cohort_date + pd.Timedelta(days=retention_day)
# Count users who returned on the target date
returning_users = df[(df['date'] == target_date) &
(df['user_id'].isin(cohort_users))]['user_id'].nunique()
# Calculate retention rate
retention_rate = returning_users / len(cohort_users)
return retention_rate * 100# Convert to percentage
Building a comprehensive retention curve allows user to identify critical drop-off points in a player lifecycle:
def generate_retention_curve(df, cohort_date, days=30):
"""Generate complete retention curve for a cohort"""
retention_curve = {}
for day in range(1, days + 1):
retention_curve[day] = calculate_retention(df, cohort_date, day)
return retention_curve
Regional analysis and churn: Churn rate is a critical metric that measures the percentage of players who stop engaging with a game over a specific period. Understanding churn patterns helps studios identify at-risk segments and implement targeted retention strategies.
The formula for calculating churn rate is:
Churn rate = (Number of churned users / Initial number of users) × 100
Regional churn analysis reveals how player attrition varies by geographic location, uncovering cultural, economic, and competitive factors affecting retention. As shown in the app, North America demonstrates the lowest churn rate at 2.4%, while Latin America experiences significantly higher churn at 3.6%, with Asia Pacific showing moderate levels at 3.0%.
Reactivation rate metrics: Reactivation rate measures the percentage of previously inactive players who return to the game, providing insights into the effectiveness of win-back campaigns and content updates.
The app shows reactivation rates ranging from 1.5-1.9% across regions, with Middle East and Asia Pacific leading at 1.9%. The upward trends in early 2025 indicate successful win-back strategies or compelling new content releases.
Ad monetization analytics: Ad monetization metrics track revenue and performance of in-game advertising, a crucial revenue stream particularly for free-to-play titles.
- eCPM analysis (effective cost per mille) measures the ad revenue generated per 1,000 impressions. The app shows eCPM growth from $3.5 to $5.5+ over a year, with a peak of $6.5 in January 2025, indicating improved ad implementation and optimization.
def calculate_ecpm(ad_revenue, impressions): """ Calculate eCPM (effective Cost Per Mille) Parameters: - ad_revenue: Total ad revenue in the period - impressions: Total ad impressions in the period Returns: - eCPM value """ if impressions == 0: return 0 # Formula: (Total Ad Revenue / Total Impressions) × 1000 ecpm = (ad_revenue / impressions) * 1000 return ecpmTracking eCPM trends helps identify high-performing ad formats, optimal placement strategies, and seasonal variations. The correlation between ad revenue spikes and eCPM increases (as seen in January 2025) suggests that both ad volume and quality improved simultaneously.
