When Free Rork Users Become Paying Subscribers — Pricing and Paywall Lessons From an Indie Developer

Pricing Psychology and the Science of Subscription Pricing

The Three-Tier Anchoring Strategy

How you present pricing dramatically affects which plan users choose. The first price a customer sees becomes their mental anchor — everything else is evaluated relative to it.

The most effective structure is the three-tier approach:

• Lite: $2.99/month (basic features)
• Standard: $7.99/month (recommended — this is your target) ← highlight this
• Pro: $19.99/month (full feature set)

By framing Standard as the middle option between a clearly limited Lite and an obviously expensive Pro, you make it feel like the sensible, reasonable choice. This is the decoy effect in action.

Here's how to implement this in Rork:

// Plan card component with visual emphasis on recommended plan
const PlanCard = ({ plan, isRecommended }) => {
  return (
    <View style={[
      styles.card,
      isRecommended && styles.recommendedCard
    ]}>
      {isRecommended && (
        <View style={styles.popularBadge}>
          <Text style={styles.badgeText}>Most Popular</Text>
        </View>
      )}
      <Text style={styles.planName}>{plan.name}</Text>
      <Text style={styles.price}>
        ${plan.price}
        <Text style={styles.period}>/month</Text>
      </Text>
      {plan.features.map((feature, index) => (
        <View key={index} style={styles.featureRow}>
          <Text style={styles.checkmark}>✓</Text>
          <Text style={styles.featureText}>{feature}</Text>
        </View>
      ))}
      <TouchableOpacity
        style={[styles.button, isRecommended && styles.primaryButton]}
        onPress={() => handleSubscribe(plan.id)}
      >
        <Text style={styles.buttonText}>
          {isRecommended ? 'Get Started' : 'Choose Plan'}
        </Text>
      </TouchableOpacity>
    </View>
  );
};

Annual Plans: Your Most Powerful LTV Lever

Annual subscriptions typically reduce churn by 4–5x compared to monthly plans. A user who has paid for a year has committed psychologically and financially in a way a monthly subscriber has not.

The pricing sweet spot for annual discounts is approximately two months free (around 16–17% off):

Monthly: $7.99/month × 12 = $95.88/year
Annual: $79.99/year (save $15.89 — roughly 2 months free)

Frame the annual plan in terms of what the user saves, not the percentage discount. "Save $15 — get 2 months free" consistently outperforms "16% off."

Paywall Design: Four Models and When to Use Each

Feature Gates

The user attempts to access a specific feature and encounters a prompt to upgrade. This is the highest-converting paywall type because it catches users at their exact moment of wanting something.

// Feature gate implementation
const FeatureGate = ({ featureName, requiredPlan, children }) => {
  const { userPlan, showUpgradeModal } = useSubscription();
  const hasAccess = checkPlanAccess(userPlan, requiredPlan);
 
  if (hasAccess) return children;
 
  return (
    <TouchableOpacity
      style={styles.lockedFeature}
      onPress={() => showUpgradeModal({
        feature: featureName,
        requiredPlan,
        source: `feature_gate_${featureName}`
      })}
    >
      <View style={styles.lockOverlay}>
        <Text style={styles.lockIcon}>🔒</Text>
        <Text style={styles.lockText}>{featureName}</Text>
        <Text style={styles.upgradeHint}>Unlock with Premium</Text>
      </View>
    </TouchableOpacity>
  );
};

Usage Caps

Users can use a feature up to a limit (e.g., 10 items per month) before being prompted to upgrade. This model works well when the value is habitual — users are already dependent on the feature before the cap kicks in.

Time-Limited Trials

Give full access for 7–14 days, then require a subscription. Trials with upfront credit card capture convert significantly better than those without — users who have entered payment details are far more likely to become paying customers than those who haven't.

Content Gates

Premium content, lessons, or resources require a subscription to access. This works particularly well for learning, media, and content-curation apps.

Best combination for most Rork apps: Feature gates as the primary paywall, supplemented by usage caps for core features that should have limited free access.

Paywall Modal Design Principles

When a user hits your paywall, they are at peak motivation. Don't waste the moment:

• Lead with value, not price: "Unlock unlimited projects, team collaboration, and AI suggestions" before mentioning the price
• Add social proof: star ratings, user count, or a short quote
• Eliminate perceived risk: "Cancel anytime. No questions asked."
• One CTA: multiple buttons create decision paralysis

LTV, CAC, and Churn: Building Your Metrics Foundation

Calculating Your Core Subscription Metrics

Before you can optimize, you need a baseline:

LTV (Lifetime Value)

LTV = Average Monthly Revenue Per User (ARPU) ÷ Monthly Churn Rate
Example: ARPU $7.99, Churn 5%/month → LTV = $159.80

CAC (Customer Acquisition Cost)

CAC = Total Marketing Spend ÷ New Paid Users Acquired
Example: $500 in ads → 20 new subscribers → CAC = $25

LTV/CAC Ratio

Healthy threshold: LTV ÷ CAC > 3
Example above: $159.80 ÷ $25 = 6.4 (healthy)

If your LTV/CAC ratio falls below 3, your business model needs intervention — either increasing LTV (better retention, higher pricing, upsells) or reducing CAC (better conversion, organic growth, referral programs).

Cohort Analysis to Identify Churn Patterns

Cohort analysis tracks retention across groups of users who started at the same time. It reveals your "danger zones" — the points in the subscription lifecycle where churn spikes.

Most apps see three predictable churn spikes: around day 7 (did not find value fast enough), day 30 (first renewal decision), and day 90 (evaluation after three months). Knowing yours lets you target interventions at exactly the right time.

// Tracking with PostHog for cohort analysis
import PostHog from 'posthog-react-native';
 
const trackSubscriptionStart = (plan, source) => {
  PostHog.capture('subscription_started', {
    plan_name: plan.name,
    plan_price: plan.price,
    billing_period: plan.period,       // 'monthly' or 'yearly'
    conversion_source: source,          // which paywall triggered conversion
    days_since_install: getDaysSinceInstall(),
    features_used_before_conversion: getTopFeaturesUsed(),
  });
};
 
const trackSubscriptionCancelled = (reason) => {
  PostHog.capture('subscription_cancelled', {
    reason: reason, // 'too_expensive', 'not_using', 'missing_feature', 'temporary'
    subscription_duration_days: getSubscriptionDurationDays(),
    last_active_feature: getLastUsedFeature(),
    was_on_annual_plan: isAnnualPlan(),
  });
};

Automated Retention Interventions at Churn Danger Zones

Armed with cohort data, build automated responses at each danger zone:

• Day 7: Check if onboarding is complete. Push notification surfacing the most commonly missed high-value feature.
• Day 30: Send a "your month in review" message — show the user what they've accomplished with the app. Make value tangible.
• Day 90: "3 months with us — thank you." Offer a limited-time upgrade to annual with a modest discount.
• Pre-cancellation: Surface the pause option before the cancel button finalizes anything.

A/B Testing Infrastructure for Subscription Optimization

What to Test (Ranked by Impact)

Not all A/B tests move the needle equally. Prioritize in roughly this order:

• Pricing: $4.99 vs $7.99 vs $9.99 — finding psychological price points is high-leverage
• Trial length: 3 days vs 7 days vs 14 days
• Paywall timing: Feature gate on first access vs third access vs after 5 uses
• CTA copy: "Start Free Trial" vs "Unlock Premium" vs "Get Started"
• Plan count: 2 plans vs 3 plans vs single subscription

Implementing A/B Tests in Rork

// A/B test hook using PostHog Feature Flags
import { useEffect, useState } from 'react';
import PostHog from 'posthog-react-native';
 
const useABTest = (testName, variants) => {
  const [variant, setVariant] = useState(null);
 
  useEffect(() => {
    const assignedVariant = PostHog.getFeatureFlag(testName);
 
    if (assignedVariant && variants[assignedVariant]) {
      setVariant(assignedVariant);
      PostHog.capture('ab_test_assigned', {
        test_name: testName,
        variant: assignedVariant,
      });
    } else {
      // Fall back to control variant
      setVariant('control');
    }
  }, [testName]);
 
  return {
    variant,
    config: variant ? variants[variant] : variants['control'],
  };
};
 
// Usage in paywall screen
const PaywallScreen = () => {
  const { config } = useABTest('paywall_price_test', {
    control: {
      price: 7.99,
      trialDays: 7,
      cta: 'Start Free Trial',
    },
    variant_a: {
      price: 5.99,
      trialDays: 7,
      cta: 'Start Free Trial',
    },
    variant_b: {
      price: 7.99,
      trialDays: 14,
      cta: 'Try Free for 2 Weeks',
    },
  });
 
  if (!config) return <LoadingSpinner />;
 
  return (
    <View style={styles.container}>
      <Text style={styles.price}>${config.price}/month</Text>
      {config.trialDays > 0 && (
        <Text style={styles.trial}>{config.trialDays}-day free trial</Text>
      )}
      <Button title={config.cta} onPress={() => handleSubscribe(config)} />
    </View>
  );
};

Evaluating Test Results the Right Way

Two critical mistakes to avoid:

Stopping too early: You need 500–1,000 users per variant reaching the paywall before drawing conclusions. Declaring a winner at 50 users per variant leads to false confidence.

Optimizing for conversion rate alone: A variant that converts at 8% but churns 30% within a month is worse than one that converts at 5% with 10% monthly churn.

Effective conversion rate = Raw conversion rate × (1 − 30-day churn rate)
Variant A: 8% × (1 − 0.30) = 5.6%
Variant B: 5% × (1 − 0.10) = 4.5%
→ Variant A wins despite higher churn, but only by 1.1 points
→ Factor in LTV to determine true winner

Churn Prevention and Retention Playbook

Segmenting Users by Engagement Score

Treat high, medium, and low engagement users differently:

// Engagement scoring system
const calculateEngagementScore = (userEvents) => {
  const now = new Date();
  const last30Days = userEvents.filter(
    e => (now - new Date(e.timestamp)) / (1000 * 60 * 60 * 24) <= 30
  );
 
  const weights = {
    'app_open': 1,
    'feature_used': 3,
    'content_created': 5,
    'share_action': 4,
    'settings_updated': 2,
  };
 
  const score = last30Days.reduce((total, event) => {
    return total + (weights[event.type] || 1);
  }, 0);
 
  if (score >= 50) return 'high';      // Upsell to annual plan
  if (score >= 20) return 'medium';    // Feature discovery push notifications
  return 'low';                         // Re-engagement campaign
};

Cancellation Flow: Convert the Cancellation Into an Opportunity

// Cancellation flow with retention offers
const CancellationFlow = () => {
  const [step, setStep] = useState('reason');
  const [reason, setReason] = useState(null);
 
  const reasons = [
    { id: 'too_expensive', label: 'Too expensive', offer: 'downgrade' },
    { id: 'not_using', label: "Not using it enough", offer: 'pause' },
    { id: 'missing_feature', label: 'Missing a feature I need', offer: 'feedback' },
    { id: 'temporary', label: 'Only needed it temporarily', offer: 'discount' },
  ];
 
  const handleReasonSelected = (selectedReason) => {
    setReason(selectedReason);
    setStep(selectedReason.offer === 'pause' ? 'pause_offer' :
            selectedReason.offer === 'discount' ? 'discount_offer' :
            selectedReason.offer === 'downgrade' ? 'downgrade_offer' :
            'feedback_offer');
 
    PostHog.capture('cancellation_reason_selected', {
      reason: selectedReason.id,
    });
  };
 
  const PauseOffer = () => (
    <View>
      <Text style={styles.title}>Pause instead of canceling?</Text>
      <Text>Keep your data safe for 1–3 months, no charge.</Text>
      <Text>Resume anytime and pick up right where you left off.</Text>
      <Button title="Pause for 1 month" onPress={() => handlePause(1)} />
      <Button title="Pause for 3 months" onPress={() => handlePause(3)} />
      <TextButton title="Cancel anyway" onPress={() => setStep('final_confirm')} />
    </View>
  );
 
  // Render current step...
  const renderStep = () => {
    switch(step) {
      case 'reason': return <ReasonSelection reasons={reasons} onSelect={handleReasonSelected} />;
      case 'pause_offer': return <PauseOffer />;
      case 'discount_offer': return <DiscountOffer />;
      case 'downgrade_offer': return <DowngradeOffer />;
      default: return <FinalConfirmation />;
    }
  };
 
  return <View style={styles.container}>{renderStep()}</View>;
};

Rork + Stripe: Production-Ready Subscription Implementation

Checkout Flow with Full Tracking

// Full subscription checkout with A/B test tracking
const useSubscriptionFlow = () => {
  const [isLoading, setIsLoading] = useState(false);
 
  const startSubscription = async ({ planId, trialDays, source }) => {
    setIsLoading(true);
 
    try {
      const response = await fetch('/api/checkout', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          priceId: planId,
          trialDays: trialDays,
          metadata: {
            plan_type: 'subscription',
            source: source,
            ab_variant: getCurrentABVariant(),
            days_since_install: getDaysSinceInstall(),
          },
        }),
      });
 
      const { url } = await response.json();
      await Linking.openURL(url);
 
      PostHog.capture('checkout_initiated', {
        plan_id: planId,
        trial_days: trialDays,
        source: source,
      });
 
    } catch (error) {
      PostHog.capture('checkout_error', { error: error.message });
    } finally {
      setIsLoading(false);
    }
  };
 
  const changePlan = async ({ currentPlanId, newPlanId }) => {
    const isUpgrade = getPlanTier(newPlanId) > getPlanTier(currentPlanId);
 
    const response = await fetch('/api/subscription/change', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        newPriceId: newPlanId,
        // Upgrades are immediate; downgrades take effect at renewal
        prorationBehavior: isUpgrade ? 'always_invoice' : 'none',
      }),
    });
 
    return response.json();
  };
 
  return { startSubscription, changePlan, isLoading };
};

What Mattered More Than Price: Lessons From Indie Practice

We have covered pricing structures and funnels, but the single change that moved my own numbers the most was not the price — it was the moment the paywall appeared.

During one wellness app's run, I showed the plan cards right at launch. It felt efficient, but it quietly raised my uninstall rate. Showing a price to someone who has not yet felt the app's value does not persuade them; it just leaves a cold "I was being sold to" aftertaste.

So I pushed the paywall back to the first moment of genuine delight — right after a user saved a favorite, or reached for the same feature a second time. I also rewrote the copy from "Subscribe now" to something that read as a continuation of the experience: "Keep going, just a little further." I did not change the price by a single yen, and conversions still climbed visibly.

That experience taught me to treat conversion as timing design, not persuasion. The moment you lose respect for the fact that someone chose to spend their time in your app, no amount of clever pricing will save you. Dark patterns can manufacture a short-term lift, but they always return as cancellations and one-star reviews. Honest experience design is what actually sustains long-term LTV.

Give away the core value generously in the free tier, and let the paid tier promise "deeper, more your own." Draw that line from the flow of the user's emotion, not the convenience of your feature list. When I build with Rork, I sketch this one decision on paper before I write a single line of code.

Wrapping up

Maximizing freemium-to-subscription conversion requires more than adding a paywall. It demands a systematic approach: deliberate freemium design that delivers the aha moment reliably, pricing structures that use psychology to guide users toward your target plan, paywalls timed precisely to moments of peak user motivation, cohort-based analysis to catch churn before it happens, and A/B testing infrastructure that makes continuous improvement part of your operational rhythm.

The Rork + Stripe + PostHog stack gives you all the building blocks. The differentiator is treating conversion optimization as an ongoing system rather than a one-time implementation.

Start by establishing your baseline metrics — conversion rate, 30-day churn, and LTV/CAC ratio. Build the tracking infrastructure first, and the optimization opportunities will become apparent quickly.

The numbers will not move in a day — it took me close to six months to get conversion into double digits. But durable revenue only comes from that patient loop of measuring and improving. I hope your app builds a lasting relationship with the people it first meets for free. Thank you for reading.