Building a Fan Club App with Rork — Direct Revenue Without Platform Dependence

When your Instagram or Threads following grows, a quiet anxiety arrives with it: you're building your audience on someone else's land.

One algorithm update can cut your reach in half. An account restriction can silence you overnight. These aren't hypotheticals — they're things that happen to creators regularly.

I build iOS apps and make art, and what I keep coming back to is this: owning your platform changes everything. A fan club app is the most direct form of that ownership. With Rork, an individual creator can build one in a few days.

What Changes When You Have Your Own App

The most important difference between an SNS and your own app isn't the features — it's push notification access.

A post on Instagram reaches some fraction of your followers, depending on the algorithm that day. A push notification from your own app reaches every user who opted in. That's a fundamentally different relationship.

The second difference is revenue directness. Sponsorships and brand deals require intermediaries. Subscriptions in your own app go directly to you, minus Apple's cut (30% in year one, 15% from year two onward for subscriptions). At 100 subscribers at $4.99/month, that's roughly $4,200/year landing directly in your account.

Core Design: The Three-Tier Structure

The most important decision in a fan club app is the boundary between free and paid. After studying several creator apps, this three-tier structure works consistently:

Free tier: Post thumbnails and preview text visible to everyone. This is your shop window — it exists to convert visitors into subscribers.

Silver tier ($3.99/month): Full post access, exclusive behind-the-scenes content (sketches, process videos, drafts), push notifications for new posts.

Gold tier ($7.99/month): Everything in Silver plus: monthly live Q&A access, ability to DM the creator, name in app credits, exclusive merchandise discounts.

Tell Rork: "Build a fan club app with three subscription tiers. Use Supabase for content and user management, RevenueCat for subscriptions. Free users see post previews only. Paid users see full content based on their tier level."

Supabase Table Design

Here's the schema Rork generates:

-- Content posts
create table posts (
  id uuid primary key default gen_random_uuid(),
  title text not null,
  preview_text text,        -- Visible to all users
  full_content text,        -- Paid users only
  media_urls text[],        -- Image/video URL array
  required_tier int default 1,  -- 1=Free, 2=Silver, 3=Gold
  created_at timestamptz default now()
);
 
-- User subscription state (updated via RevenueCat webhook)
create table user_subscriptions (
  user_id uuid references auth.users primary key,
  tier int default 1,
  valid_until timestamptz,
  revenuecat_customer_id text
);

After generating this schema, ask Rork: "Add Row Level Security policies to the posts table. Free content should be accessible to everyone. Silver content (required_tier = 2) should only be accessible to users with tier >= 2 in user_subscriptions."

create policy "premium_content_access" on posts
  for select using (
    required_tier = 1
    or (
      required_tier >= 2
      and exists (
        select 1 from user_subscriptions
        where user_id = auth.uid()
        and tier >= posts.required_tier
        and valid_until > now()
      )
    )
  );

RevenueCat Webhook Integration

RevenueCat handles subscription state management beautifully. The critical piece is keeping your Supabase subscription data synchronized via webhooks.

Tell Rork: "Create a webhook endpoint that receives RevenueCat events. Handle INITIAL_PURCHASE, RENEWAL, and CANCELLATION events by updating the user_subscriptions table accordingly."

// app/api/revenuecat-webhook/route.ts
export async function POST(request: Request) {
  const payload = await request.json();
  const { event } = payload;
 
  const userId = event.app_user_id;
  const productId = event.product_id;
  const tier = productId.includes('gold') ? 3 : 2;
  const validUntil = new Date(event.expiration_at_ms);
 
  if (event.type === 'INITIAL_PURCHASE' || event.type === 'RENEWAL') {
    await supabase
      .from('user_subscriptions')
      .upsert({ user_id: userId, tier, valid_until: validUntil });
  }
 
  if (event.type === 'CANCELLATION') {
    // Keep access until period end
    await supabase
      .from('user_subscriptions')
      .update({ tier: 1, valid_until: validUntil })
      .eq('user_id', userId);
  }
 
  return Response.json({ ok: true });
}

One thing worth noting: cancellations should maintain access until the subscription expires, not immediately. This is both expected user behavior and App Store requirement.

The Content Posting Interface

You need a way to create posts from your app. Tell Rork: "Build a creator admin panel with the ability to write posts, upload multiple images to Supabase Storage, select the required tier, and write a preview text excerpt."

My recommendation: implement the creator admin interface as a web app, not inside the iOS app. Two reasons:

First, App Store guidelines prefer that creator/publisher management tools live on the web. Administrative features for managing paid content can complicate your review if they're in the app itself.

Second, writing long posts and managing files is simply more comfortable on a desktop browser than on a phone.

App Store Review Considerations

Fan club apps have specific review friction points you should anticipate.

Content rating accuracy: Set your age rating correctly upfront. If your content includes mature themes, set 17+ in App Store Connect. Content that includes nudity is restricted or unavailable in certain regions — know your audience and plan accordingly.

Subscription content guidelines: Apple's Guideline 3.1.3 requires that subscription content be "continuously updated." In your review notes, describe your posting cadence and the type of content subscribers receive. Reviewers need to understand they're paying for an ongoing content relationship, not a static feature set.

No external payment links: You cannot link to Patreon, your website payment page, or any external purchase flow from within the app. All transactions must go through Apple's in-app purchase system. Mentioning external payment options, even in text, can lead to rejection.

Revenue Reality

At 100 subscribers at $4.99/month with Apple's 15% fee (year two onward), you keep about $5,090/year. At 500 subscribers, that becomes $25,450/year.

The critical milestone is your first 30 subscribers. Announce to your existing social following, offer a one-month free trial, and let them experience the app before committing. RevenueCat's introductory offer feature handles this elegantly — tell Rork: "Add a free trial introductory offer to the paywall screen, highlighted prominently with the trial end date."

The path from zero to first subscriber is the hardest part. After that, every new subscriber builds on real social proof from the people who are already in.

Building art and building apps alongside each other — there's a version of that life where they reinforce each other rather than compete. A fan club app is one of the most concrete ways to make that happen.