Monetizing SwiftUI Native Apps Built with Rork Max — From App Store Approval to Subscription Revenue

Adding subscriptions with StoreKit 2

This part fixes the "gone after restart" problem. StoreKit 2 asks you to decide paid state from the current entitlements, not from the moment of purchase.

In App Store Connect, create monthly and yearly products in one subscription group. Configure a free trial as an introductory offer on each product, not as a separate product.

import StoreKit
 
@MainActor
final class StoreManager: ObservableObject {
    @Published private(set) var products: [Product] = []
    @Published private(set) var isSubscribed = false
    @Published var errorMessage: String?
 
    private let productIDs = ["com.example.app.monthly", "com.example.app.yearly"]
    private var updatesTask: Task<Void, Never>?
 
    init() {
        updatesTask = Task { [weak self] in
            for await result in Transaction.updates {
                if case .verified(let transaction) = result {
                    await transaction.finish()
                }
                await self?.refreshEntitlements()
            }
        }
        Task { await refreshEntitlements() }
    }
 
    deinit { updatesTask?.cancel() }
 
    func loadProducts() async {
        do {
            products = try await Product.products(for: productIDs)
                .sorted { $0.price < $1.price }
        } catch {
            errorMessage = "Could not load product information."
        }
    }
 
    func purchase(_ product: Product) async {
        do {
            switch try await product.purchase() {
            case .success(let verification):
                guard case .verified(let transaction) = verification else {
                    errorMessage = "Purchase verification failed."
                    return
                }
                await transaction.finish()
                await refreshEntitlements()
            case .userCancelled, .pending:
                break
            @unknown default:
                break
            }
        } catch {
            errorMessage = "Could not complete the purchase."
        }
    }
 
    func refreshEntitlements() async {
        var active = false
        for await result in Transaction.currentEntitlements {
            if case .verified(let transaction) = result,
               productIDs.contains(transaction.productID),
               transaction.revocationDate == nil {
                active = true
            }
        }
        isSubscribed = active
    }
 
    func restore() async {
        try? await AppStore.sync()
        await refreshEntitlements()
    }
}

As you can see, the only door to paid state is refreshEntitlements(). Right after a purchase, at launch, and on Transaction.updates, all three go through it, so the paid state no longer disappears on restart.

Always include a "Restore purchases" button. Review looks for it, and it helps people who change devices.

Reflect the free trial in the UI

Whether a trial exists can be read from the product's introductory offer. Showing the period and the post-trial price together is safer for review and clearer for users.

func trialText(for product: Product) -> String? {
    guard let offer = product.subscription?.introductoryOffer,
          offer.paymentMode == .freeTrial else { return nil }
    let value = offer.period.value
    let span: String
    switch offer.period.unit {
    case .day: span = "\(value)-day"
    case .week: span = "\(value)-week"
    case .month: span = "\(value)-month"
    default: span = "\(value)-year"
    }
    return "\(span) free trial, then \(product.displayPrice)"
}

Check eligibility with product.subscription?.isEligibleForIntroOffer, and do not show "free" to users who no longer qualify.

The paywall

struct PaywallView: View {
    @StateObject private var store = StoreManager()
    @Environment(\.dismiss) private var dismiss
 
    var body: some View {
        NavigationStack {
            List(store.products) { product in
                VStack(alignment: .leading, spacing: 4) {
                    Text(product.displayName).font(.headline)
                    if let trial = trialText(for: product) {
                        Text(trial).font(.subheadline)
                    } else {
                        Text(product.displayPrice).font(.subheadline)
                    }
                    Button("Subscribe") {
                        Task { await store.purchase(product) }
                    }
                }
                .padding(.vertical, 4)
            }
            .navigationTitle("Premium")
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("Close") { dismiss() }
                }
                ToolbarItem(placement: .bottomBar) {
                    Button("Restore purchases") { Task { await store.restore() } }
                }
            }
            .task { await store.loadProducts() }
            .onChange(of: store.isSubscribed) { _, subscribed in
                if subscribed { dismiss() }
            }
        }
    }
}

The two-parameter onChange requires iOS 17. If you support earlier versions, switch to the single-parameter form.

Deciding on price

I find prices hold up better when derived from your own numbers than borrowed from someone else's.

App Store Connect expands a base price to every storefront automatically, and you can override any of them. There is no country price to memorize. What to check is this:

• Does the gap between monthly and yearly give people a reason to choose yearly?
• Is the post-trial price the first thing visible on the paywall?
• Do the amounts look natural in your main markets?

There is no fixed right discount for yearly. Compare it against monthly × 12 and adjust over a few months of measurement, so that a shift to yearly does not erode monthly revenue.

Flow: show the value first

Generated onboarding tends to stop at feature introductions. A paywall lands better right after the user has felt value once.

This is the order I use.

1. State what the app solves in one line on the first screen.
2. Let the user get one result inside the free scope.
3. Show the entrance to paid features right after that result.
4. Leave a place they can return to at any time, even after closing.

Never put the paywall first, and always provide a close button. A structure that does not look pushy is also safer in review.

How to think about ASO

Check keyword volumes against your own App Store Connect analytics or an ASO tool. Numbers printed in articles shift with time and region.

Three implementation points are worth holding on to.

• The keyword field is limited to 100 characters, so leave out words already in the title and subtitle.
• Use the first screenshot to state the result users get, in words.
• Write the opening of the description assuming it gets cut off in search results.

Design that supports retention

The first step to fewer cancellations is knowing why people leave. Look at renewal rate and cancellation timing in App Store Connect analytics.

If you use notifications, ask permission first and send only when there is genuinely something new. A local notification looks like this.

import UserNotifications
 
func scheduleReminder(afterDays days: Int, title: String, body: String) async {
    let center = UNUserNotificationCenter.current()
    guard (try? await center.requestAuthorization(options: [.alert, .sound])) == true else { return }
 
    let content = UNMutableNotificationContent()
    content.title = title
    content.body = body
 
    let trigger = UNTimeIntervalNotificationTrigger(
        timeInterval: TimeInterval(days * 24 * 60 * 60), repeats: false)
    try? await center.add(UNNotificationRequest(
        identifier: "retention-\(days)d", content: content, trigger: trigger))
}

For offering a discount to people who cancelled, StoreKit's win-back offers are available. Supported OS versions and setup conditions change, so confirm them in Apple's StoreKit documentation before implementing.

Estimate revenue from your own numbers

A goal such as "500 subscribers at a given price" is easy to grasp, but plugging in someone else's conversion rate will miss. I suggest filling in this table with your app's measured values.

New paying members each month come roughly from downloads × start rate × conversion, and retention wears that down. Take one or two months of real data after launch and find the lowest value. Improvements usually pay off most where the number is weakest.

Reaching your first 10

My impression is that first subscribers come more often from people who can see your face than from ads.

• Share honestly in a community you already use why you built it and what you struggled with.
• Ask the people who tried it for their reactions directly, and fold them into the paywall wording.
• Write down improvements after release in a few lines, and tell people at every update.

Promotion and sharing read differently. "Here is where I got stuck and how I fixed it" puts you in the reader's seat more than "please buy" does.

Where to start

As your next step, run "buy, kill the app, relaunch" once on a real device. If the paid state survives, the foundation of your billing is in place.

From there, check the review items one by one and fill the numbers with your own measurements. It is plain work, but this accumulation is what turns generated code into a product.