Don't Stop at Shipping StoreKit 2 — Growing Subscription Revenue with Server Notifications, Recovery Offers, and Price Experiments

// SubscriptionAnalyticsManager.swift
import FirebaseAnalytics
import StoreKit
 
class SubscriptionAnalyticsManager {
    static let shared = SubscriptionAnalyticsManager()
 
    func logSubscriptionStarted(product: Product, isFreeTrial: Bool) {
        Analytics.logEvent("subscription_started", parameters: [
            "product_id": product.id,
            "is_free_trial": isFreeTrial,
            "price_locale": product.priceLocale.identifier,
            "price": product.price as NSDecimalNumber,
        ])
    }
 
    // Track when users navigate toward the cancellation flow
    func logSubscriptionCancelIntent(source: String) {
        Analytics.logEvent("subscription_cancel_intent", parameters: [
            "source": source,  // "settings" | "paywall" | "offboarding_flow"
            "days_since_start": daysSinceSubscriptionStart(),
        ])
    }
 
    func logSubscriptionCancelled(originalTransactionId: String, daysActive: Int) {
        Analytics.logEvent("subscription_cancelled", parameters: [
            "days_active": daysActive,
            // Categorize churn for funnel analysis
            "cancel_reason_category": inferCancelCategory(daysActive: daysActive),
        ])
    }
 
    private func inferCancelCategory(daysActive: Int) -> String {
        switch daysActive {
        case 0...3: return "immediate_churn"    // Never found value
        case 4...14: return "early_churn"       // Onboarding failure
        case 15...60: return "mid_term_churn"   // Usage dropped off
        default: return "long_term_churn"        // Likely switching to competitor
        }
    }
}

-- Ask Antigravity: "Write a BigQuery query to calculate 30-day cohort churn rate by month"
 
WITH cohorts AS (
  SELECT
    FORMAT_DATE('%Y-%m', DATE(TIMESTAMP_MICROS(event_timestamp))) AS cohort_month,
    user_pseudo_id,
    MIN(event_timestamp) AS first_subscribe_ts
  FROM `your_project.analytics_XXXXXXXX.events_*`
  WHERE event_name = 'subscription_started'
  GROUP BY 1, 2
),
cancellations AS (
  SELECT
    user_pseudo_id,
    event_timestamp AS cancel_ts
  FROM `your_project.analytics_XXXXXXXX.events_*`
  WHERE event_name = 'subscription_cancelled'
)
SELECT
  c.cohort_month,
  COUNT(DISTINCT c.user_pseudo_id) AS total_subscribers,
  COUNT(DISTINCT CASE
    WHEN TIMESTAMP_DIFF(
      TIMESTAMP_MICROS(can.cancel_ts),
      TIMESTAMP_MICROS(c.first_subscribe_ts), DAY) <= 30
    THEN c.user_pseudo_id
  END) AS churned_within_30d,
  ROUND(100.0 *
    COUNT(DISTINCT CASE
      WHEN TIMESTAMP_DIFF(
        TIMESTAMP_MICROS(can.cancel_ts),
        TIMESTAMP_MICROS(c.first_subscribe_ts), DAY) <= 30
      THEN c.user_pseudo_id END) / COUNT(DISTINCT c.user_pseudo_id), 1
  ) AS churn_rate_30d_pct
FROM cohorts c
LEFT JOIN cancellations can USING (user_pseudo_id)
GROUP BY 1
ORDER BY 1 DESC
LIMIT 24

// OffboardingFlowManager.swift
import StoreKit
 
class OffboardingFlowManager: ObservableObject {
    @Published var promoOfferState: PromoOfferState = .checking
 
    enum PromoOfferState {
        case checking
        case available(Product.SubscriptionOffer)
        case notAvailable
        case redeemed
    }
 
    func loadPromoOffer(for product: Product) async {
        guard let subscription = product.subscription else { return }
 
        // Check server-side eligibility (based on subscription history)
        let eligibility = await checkOfferEligibility(for: product)
        guard eligibility.isEligible else {
            await MainActor.run { promoOfferState = .notAvailable }
            return
        }
 
        // Match the eligible offer ID to the available promotional offers
        // Offer IDs are configured in App Store Connect (e.g., "winback_3months_50pct")
        if let offer = subscription.promotionalOffers.first(where: {
            $0.id == eligibility.offerId
        }) {
            await MainActor.run { promoOfferState = .available(offer) }
        }
    }
 
    func redeemOffer(product: Product, offer: Product.SubscriptionOffer) async throws {
        // Fetch server-generated signature (NEVER generate this client-side)
        let signature = try await fetchOfferSignature(
            productId: product.id,
            offerId: offer.id
        )
 
        let purchaseOptions: Set<Product.PurchaseOption> = [
            .promotionalOffer(
                offerID: offer.id,
                keyID: signature.keyId,
                nonce: signature.nonce,
                signature: signature.signature,
                timestamp: signature.timestamp
            )
        ]
 
        let result = try await product.purchase(options: purchaseOptions)
        switch result {
        case .success:
            // Server Notification will also update state asynchronously
            await MainActor.run { promoOfferState = .redeemed }
        case .userCancelled:
            break  // User declined — proceed to normal cancellation
        default:
            break
        }
    }
}

// GracePeriodBannerView.swift
// Surface a non-intrusive reminder when the user's payment has failed
 
struct GracePeriodBannerView: View {
    let gracePeriodEndDate: Date
    @State private var isDismissed = false
 
    var daysRemaining: Int {
        Calendar.current.dateComponents([.day], from: Date(), to: gracePeriodEndDate).day ?? 0
    }
 
    var body: some View {
        if !isDismissed && daysRemaining >= 0 {
            HStack(spacing: 12) {
                Image(systemName: "creditcard.trianglebadge.exclamationmark")
                    .foregroundStyle(.orange)
                VStack(alignment: .leading, spacing: 2) {
                    Text("Payment update needed")
                        .font(.subheadline.weight(.semibold))
                    Text("Update your billing info to keep your subscription — \(daysRemaining) day\(daysRemaining == 1 ? "" : "s") remaining.")
                        .font(.caption)
                        .foregroundStyle(.secondary)
                }
                Spacer()
                Button("Update") {
                    // Deep-link to App Store subscription management
                    if let url = URL(string: "https://apps.apple.com/account/subscriptions") {
                        UIApplication.shared.open(url)
                    }
                }
                .buttonStyle(.borderedProminent)
                .controlSize(.small)
            }
            .padding()
            .background(.orange.opacity(0.1), in: RoundedRectangle(cornerRadius: 12))
            .padding(.horizontal)
        }
    }
}

// PricingExperimentManager.swift
import FirebaseRemoteConfig
 
class PricingExperimentManager: ObservableObject {
    private let remoteConfig = RemoteConfig.remoteConfig()
 
    func configure() {
        remoteConfig.setDefaults([
            "paywall_variant": "control" as NSObject,   // "control" | "annual_emphasis" | "trial_emphasis"
            "show_promo_badge": false as NSObject,
            "trial_duration_days": 7 as NSObject,
        ])
    }
 
    var paywallVariant: String {
        remoteConfig.configValue(forKey: "paywall_variant").stringValue ?? "control"
    }
 
    var trialDurationDays: Int {
        Int(remoteConfig.configValue(forKey: "trial_duration_days").numberValue)
    }
 
    func fetchAndActivate() async throws {
        try await remoteConfig.fetchAndActivate()
        Analytics.logEvent("experiment_assigned", parameters: [
            "paywall_variant": paywallVariant,
        ])
    }
}
 
// PaywallView.swift — render based on assigned variant
struct PaywallView: View {
    @StateObject private var pricing = PricingExperimentManager()
 
    var body: some View {
        Group {
            switch pricing.paywallVariant {
            case "annual_emphasis":
                AnnualEmphasisPaywallView()
            case "trial_emphasis":
                TrialEmphasisPaywallView()
            default:
                ControlPaywallView()
            }
        }
        .task { try? await pricing.fetchAndActivate() }
    }
}

// win-back-campaign.ts (Cloudflare Workers + Queues)
export async function triggerWinBackCampaign(
  originalTransactionId: string,
  userId: string,
  productId: string,
  env: Env
) {
  await env.WIN_BACK_QUEUE.send({
    userId,
    originalTransactionId,
    productId,
    expiredAt: new Date().toISOString(),
    sequence: 0,
  });
}
 
export default {
  async queue(batch: MessageBatch<WinBackMessage>, env: Env) {
    for (const message of batch.messages) {
      const { userId, sequence, expiredAt } = message.body;
      const daysSinceExpiry = Math.floor(
        (Date.now() - new Date(expiredAt).getTime()) / (1000 * 60 * 60 * 24)
      );
 
      if (sequence === 0 && daysSinceExpiry >= 3) {
        // Day 3: "Welcome back" offer — 1 month free
        await sendPushNotification(userId, {
          title: "We'd love to have you back",
          body: "Come back and get your first month free",
          data: { type: "win_back", offerId: "winback_1month_free" },
        }, env);
        await scheduleNextSequence(message.body, 1, 14, env);
 
      } else if (sequence === 1 && daysSinceExpiry >= 14) {
        // Day 14: Final offer — 3 months at 40% off
        await sendPushNotification(userId, {
          title: "A special offer, just for you",
          body: "Get 3 months at 40% off — this week only",
          data: { type: "win_back", offerId: "winback_3months_40pct" },
        }, env);
        // End sequence; hand off to email channel if available
      }
 
      message.ack();
    }
  }
};

// TrialConversionTracker.swift
import FirebaseAnalytics
 
struct TrialConversionTracker {
    // Track each meaningful interaction during the trial
    static func logTrialMilestone(_ milestone: TrialMilestone) {
        Analytics.logEvent("trial_milestone", parameters: [
            "milestone": milestone.rawValue,
            "trial_day": daysSinceTrialStart(),
        ])
    }
 
    // When the paywall is shown, record the context
    static func logPaywallImpression(trigger: String, trialDaysRemaining: Int) {
        Analytics.logEvent("paywall_impression", parameters: [
            "trigger": trigger,            // "trial_expiry" | "feature_gate" | "manual"
            "trial_days_remaining": trialDaysRemaining,
        ])
    }
 
    // When a user converts, capture the full journey
    static func logTrialConversion(product: Product, daysSinceStart: Int) {
        Analytics.logEvent("trial_converted", parameters: [
            "product_id": product.id,
            "days_to_convert": daysSinceStart,
            "converted_during_trial": daysSinceStart <= 7,
        ])
    }
 
    enum TrialMilestone: String {
        case firstSession = "first_session"
        case coreFeatureUsed = "core_feature_used"
        case savedOrExported = "saved_or_exported"  // "save" action = high intent
        case returnedNextDay = "returned_next_day"
        case invitedOther = "invited_other"          // Very high conversion signal
    }
}

// appstore-connect-auth.ts
import jwt from '@tsndr/cloudflare-worker-jwt';
 
async function generateAppStoreToken(
  keyId: string,
  issuerId: string,
  privateKey: string
): Promise<string> {
  const now = Math.floor(Date.now() / 1000);
  const payload = {
    iss: issuerId,
    iat: now,
    exp: now + 20 * 60,  // 20 minute expiry (Apple max)
    aud: 'appstoreconnect-v1',
  };
 
  return jwt.sign(payload, privateKey, {
    algorithm: 'ES256',
    header: { kid: keyId, typ: 'JWT' },
  });
}
 
// Fetch subscription summary from the Reporting API
async function fetchSubscriptionSummary(token: string, vendorNumber: string) {
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);
  const dateStr = yesterday.toISOString().split('T')[0];
 
  const response = await fetch(
    `https://api.appstoreconnect.apple.com/v1/salesReports?` +
    `filter[frequency]=DAILY&filter[reportDate]=${dateStr}` +
    `&filter[reportType]=SUBSCRIPTION_EVENT&filter[vendorNumber]=${vendorNumber}`,
    {
      headers: {
        Authorization: `Bearer ${token}`,
        Accept: 'application/a-gzip',
      },
    }
  );
 
  if (!response.ok) throw new Error(`API error: ${response.status}`);
  // Response is gzip-compressed TSV; decompress and parse
  return parseSubscriptionReport(await response.arrayBuffer());
}

# Runs Monday 07:00 via cron
antigravity run \
  --agent subscription-report \
  --prompt "Aggregate last week's MRR, trial-to-paid rate, and 30-day churn, with week-over-week deltas, as Markdown. If any threshold is breached (churn above 5%), prepend a warning." \
  --output reports/weekly-$(date +%Y-%m-%d).md