Rork Maxで個人開発アプリ月収100万円を達成する：収益設計・実装・データ分析の設計書

// src/lib/revenuecat.ts
import Purchases, { LOG_LEVEL } from 'react-native-purchases';
import { Platform } from 'react-native';
 
const REVENUECAT_API_KEY = {
  ios: process.env.EXPO_PUBLIC_REVENUECAT_IOS_KEY ?? '',
  android: process.env.EXPO_PUBLIC_REVENUECAT_ANDROID_KEY ?? '',
};
 
export async function initializePurchases(userId?: string): Promise<void> {
  try {
    // 開発環境ではデバッグログを有効化して挙動を確認しやすくする
    if (__DEV__) {
      Purchases.setLogLevel(LOG_LEVEL.DEBUG);
    }
 
    const apiKey = Platform.select(REVENUECAT_API_KEY);
    if (!apiKey) {
      throw new Error('RevenueCat API key is not configured for this platform');
    }
 
    await Purchases.configure({
      apiKey,
      // ログイン済みユーザーにはIDを渡してデバイス間の購入履歴を同期する
      appUserID: userId,
    });
 
    console.log('[RevenueCat] Initialized successfully');
  } catch (error) {
    // 初期化失敗はクラッシュではなくログに記録し、アプリの起動を妨げない
    console.error('[RevenueCat] Initialization failed:', error);
    // SentryなどのCrashlytics連携ツールに送信する場合はここに追加
  }
}

// src/hooks/usePaywall.ts
import { useState, useCallback } from 'react';
import Purchases, {
  type PurchasesOffering,
  type CustomerInfo,
  type PurchasesError,
} from 'react-native-purchases';
 
interface UsePaywallResult {
  offering: PurchasesOffering | null;
  customerInfo: CustomerInfo | null;
  isLoading: boolean;
  error: string | null;
  fetchOffering: () => Promise<void>;
  purchasePackage: (packageIdentifier: string) => Promise<boolean>;
  restorePurchases: () => Promise<boolean>;
}
 
export function usePaywall(): UsePaywallResult {
  const [offering, setOffering] = useState<PurchasesOffering | null>(null);
  const [customerInfo, setCustomerInfo] = useState<CustomerInfo | null>(null);
  const [isLoading, setIsLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
 
  const fetchOffering = useCallback(async () => {
    setIsLoading(true);
    setError(null);
    try {
      const offerings = await Purchases.getOfferings();
      // "default"オファリングを優先し、なければ最初のオファリングを使用する
      const current = offerings.current ?? Object.values(offerings.all)[0];
      if (!current) {
        throw new Error('オファリングが設定されていません。RevenueCatダッシュボードを確認してください。');
      }
      setOffering(current);
 
      // 現在の購入ステータスをオファリングと同時に取得してUIの表示を確定する
      const info = await Purchases.getCustomerInfo();
      setCustomerInfo(info);
    } catch (err) {
      const message = err instanceof Error ? err.message : '予期しないエラーが発生しました';
      setError(message);
      console.error('[usePaywall] fetchOffering failed:', err);
    } finally {
      setIsLoading(false);
    }
  }, []);
 
  const purchasePackage = useCallback(async (packageIdentifier: string): Promise<boolean> => {
    if (!offering) return false;
 
    const targetPackage = offering.availablePackages.find(
      (p) => p.identifier === packageIdentifier
    );
    if (!targetPackage) {
      setError(`パッケージ "${packageIdentifier}" が見つかりません`);
      return false;
    }
 
    setIsLoading(true);
    try {
      const { customerInfo: updatedInfo } = await Purchases.purchasePackage(targetPackage);
      setCustomerInfo(updatedInfo);
 
      // 購入後は "premium" エンタイトルメントの有無でアクセス権を判定する
      const isPremium = updatedInfo.entitlements.active['premium'] !== undefined;
      return isPremium;
    } catch (err: unknown) {
      // ユーザーが自分でキャンセルした場合はエラーではなく正常系として扱う
      const purchaseError = err as PurchasesError;
      if (purchaseError.userCancelled) {
        return false;
      }
      const message = err instanceof Error ? err.message : '購入処理中にエラーが発生しました';
      setError(message);
      console.error('[usePaywall] purchasePackage failed:', err);
      return false;
    } finally {
      setIsLoading(false);
    }
  }, [offering]);
 
  const restorePurchases = useCallback(async (): Promise<boolean> => {
    setIsLoading(true);
    setError(null);
    try {
      const restoredInfo = await Purchases.restorePurchases();
      setCustomerInfo(restoredInfo);
      // アクティブなエンタイトルメントが1件以上あれば復元成功
      return Object.keys(restoredInfo.entitlements.active).length > 0;
    } catch (err) {
      setError('購入履歴の復元に失敗しました。しばらく経ってから再度お試しください。');
      console.error('[usePaywall] restorePurchases failed:', err);
      return false;
    } finally {
      setIsLoading(false);
    }
  }, []);
 
  return {
    offering,
    customerInfo,
    isLoading,
    error,
    fetchOffering,
    purchasePackage,
    restorePurchases,
  };
}

// src/lib/analytics.ts
import PostHog from 'posthog-react-native';
import type { CustomerInfo } from 'react-native-purchases';
 
// シングルトンパターンでインスタンスを管理し、重複初期化を防ぐ
let posthogClient: PostHog | null = null;
 
export function getAnalytics(): PostHog {
  if (!posthogClient) {
    posthogClient = new PostHog(
      process.env.EXPO_PUBLIC_POSTHOG_API_KEY ?? 'YOUR_POSTHOG_API_KEY',
      {
        host: 'https://app.posthog.com',
        // 開発中はイベントを送信しない設定
        disabled: __DEV__,
      }
    );
  }
  return posthogClient;
}
 
// 収益に直結するイベントのみをトラッキングする関数群
export const trackRevenue = {
  // ペイウォールが表示された（どの画面から開いたかを記録する）
  paywallViewed: (source: 'onboarding' | 'feature_gate' | 'settings' | 'upgrade_banner') => {
    getAnalytics().capture('paywall_viewed', {
      source,
      timestamp: new Date().toISOString(),
    });
  },
 
  // 購入が成功した（どのパッケージを選んだか・トライアル経由かを記録する）
  purchaseCompleted: (customerInfo: CustomerInfo, packageId: string) => {
    const premiumEntitlement = customerInfo.entitlements.active['premium'];
    getAnalytics().capture('purchase_completed', {
      package_id: packageId,
      is_trial: premiumEntitlement?.periodType === 'TRIAL',
      billing_period: premiumEntitlement?.productPlanIdentifier ?? 'unknown',
    });
 
    // ユーザープロパティを更新することでコホート分析が可能になる
    getAnalytics().identify(customerInfo.originalAppUserId, {
      is_premium: true,
      subscription_status: 'active',
      purchased_at: new Date().toISOString(),
    });
  },
 
  // ペイウォールでキャンセルされた（離脱ポイントの特定に使う）
  paywallDismissed: (source: string, timeSpentSeconds: number) => {
    getAnalytics().capture('paywall_dismissed', {
      source,
      time_spent_seconds: timeSpentSeconds,
    });
  },
};

# review_slots.py — 年3回の上限を踏まえてレビュー依頼の置き場所を選ぶ
import itertools
 
CAP = 3  # 365日あたりの表示上限（Apple 側の仕様）
 
# (瞬間, インストール基準の到達率, 依頼したとき星4以上が付く確率)
MOMENTS = [
    ("初回起動の翌日",       0.55, 0.04),
    ("オンボーディング完了", 0.42, 0.07),
    ("初めて成果が出た瞬間", 0.26, 0.22),
    ("7日連続の達成",        0.11, 0.38),
    ("課金から30日",         0.05, 0.45),
]
 
def simulate(selected, installs=1000):
    reach = [m[1] for m in MOMENTS] + [0.0]
    reviews = prompts = 0.0
    for k in range(len(MOMENTS)):                 # ちょうど k 段目まで到達した層
        layer = reach[k] - reach[k + 1]
        fired = [i for i in sorted(selected) if i <= k][:CAP]   # 上限で切られる
        prompts += layer * len(fired)
        reviews += layer * sum(MOMENTS[i][2] for i in fired)
    return reviews * installs, prompts * installs
 
ranked = []
for n in range(1, len(MOMENTS) + 1):
    for sel in itertools.combinations(range(len(MOMENTS)), n):
        reviews, prompts = simulate(sel)
        ranked.append((reviews, prompts, sel))
 
for reviews, prompts, sel in sorted(ranked, reverse=True)[:5]:
    print(f"星4以上 {reviews:6.1f} / 依頼 {prompts:7.1f} / "
          f"1依頼あたり {reviews / prompts:.3f}  "
          + "＋".join(MOMENTS[i][0] for i in sel))

// src/review/reviewSlots.ts — 依頼の打順を1か所に集約する
import * as StoreReview from 'expo-store-review';
 
type Moment = 'day2' | 'onboarded' | 'first_win' | 'streak7' | 'paid30';
 
// 上から順に撃つ。年3回の上限に当たる前に、価値の高い瞬間へ届かせる
const ORDER: Moment[] = ['onboarded', 'first_win', 'streak7'];
 
export type SlotResult =
  | 'requested'
  | 'skipped:not_in_order'
  | 'skipped:duplicate'
  | 'skipped:yearly_cap'
  | 'skipped:unavailable';
 
export async function requestReviewAt(
  moment: Moment,
  firedInLast365Days: Moment[],
): Promise<SlotResult> {
  if (!ORDER.includes(moment)) return 'skipped:not_in_order';
  if (firedInLast365Days.includes(moment)) return 'skipped:duplicate';
  if (firedInLast365Days.length >= 3) return 'skipped:yearly_cap'; // 手元でも数えておく
  if (!(await StoreReview.hasAction())) return 'skipped:unavailable';
 
  await StoreReview.requestReview();
  return 'requested'; // 実際に表示されたかどうかはOSしか知らない
}

# churn_to_downloads.py — 解約率から必要DL/日を逆算する
TARGET_MRR = 1_000_000      # 目標の月次経常収益（円）
INSTALL_TO_TRIAL = 0.12     # インストール → トライアル開始率
TRIAL_TO_PAID = 0.40        # トライアル → 有料転換率
 
def required_downloads_per_day(price: int, churn: float) -> float:
    paying_users = TARGET_MRR / price          # 必要な有料会員数
    monthly_refill = paying_users * churn      # 毎月の補充ノルマ
    return monthly_refill / (INSTALL_TO_TRIAL * TRIAL_TO_PAID) / 30
 
for price in (480, 980, 1980):
    for churn in (0.03, 0.05, 0.10, 0.15):
        ltv = price / churn
        print(f"{price}円 churn{churn:.0%}  LTV={ltv:,.0f}円  "
              f"必要DL/日={required_downloads_per_day(price, churn):,.0f}")