Building Monetized Apps with Rork AI — to Ads, IAP & Subscriptions

Implementing Ads with Rork AI

Basic AdMob Setup

Rork AI can generate ad integration code as part of your initial app creation. The key is specifying your ad strategy clearly in your prompt.

Example Rork AI prompt:
"Create a recipe management app with the following ad setup:
- Banner ad fixed at the bottom of the screen
- Interstitial ad shown every 5th navigation from list to detail view
- Use AdMob test IDs for development
- Include a remote config flag to adjust ad frequency server-side"

Rork AI will generate a React Native app with the appropriate AdMob library integration, ad placement logic, and frequency controls.

Ad Placement Best Practices

Where you put ads matters enormously for both revenue and user retention. Follow these principles to find the right balance.

Banner ads should sit at the bottom of the screen in a fixed position, never overlapping content the user is trying to interact with. Interstitial ads should appear at natural transition points — between levels in a game, after saving a document, or when navigating between major sections. Never interrupt a user mid-action.

Rewarded ads are the highest-performing format for user satisfaction. Let users choose to watch an ad in exchange for a benefit — extra lives, premium content previews, or temporary feature unlocks. This opt-in model consistently receives positive user feedback.

Frequency Tuning

Ad frequency is a balancing act between revenue and churn. As general guidelines, interstitial ads should appear no more frequently than once every three to five user actions. Rewarded ads should be capped at two to three per session. Banner ads can be persistent but should never obstruct interactive elements.

Build remote configuration into your app from day one so you can adjust these frequencies without pushing an app update.

Example Rork AI prompt:
"Add Firebase Remote Config support for ad frequency settings.
Default values: interstitial every 5 actions,
rewarded ads max 3 per session.
Include a kill switch to disable all ads remotely."

Implementing In-App Purchases

Designing Your Purchase Items

The success of IAP hinges on what you put behind the paywall. The golden rule: the free version should be genuinely useful on its own. Users need to experience enough value to understand what they'd gain from paying more.

Common IAP patterns include feature unlocks (export functionality, advanced search, unlimited storage), content packs (premium themes, filters, templates, sticker sets), capacity expansions (more saved items, larger cloud storage), and ad removal (a one-time purchase that removes all advertising).

Implementation with Rork AI

Example Rork AI prompt:
"Add the following in-app purchases to the photo editing app:
1. Premium Filter Pack ($3.99 one-time)
2. Ad Removal ($6.99 one-time)
3. HD Export ($2.49 one-time)
Store purchase status in AsyncStorage with receipt validation.
Include a 'Restore Purchases' button in the settings screen.
Support both App Store and Google Play billing."

Rork AI will generate the billing integration, purchase state management, and UI components for the purchase flow, including proper error handling for failed transactions and network issues.

Pricing Strategy

Pricing varies significantly by market and category. Here are typical ranges for reference: small feature unlocks at $0.99 to $2.99, content packs at $1.99 to $6.99, ad removal at $2.99 to $9.99, and full pro upgrades at $9.99 to $24.99.

When uncertain, start lower. It's easier to raise prices after establishing a conversion baseline than to lower them after setting expectations high. Use A/B testing to find the price point that maximizes total revenue — not just conversion rate, but conversion rate multiplied by price.

Implementing Subscriptions

Designing Your Subscription Tiers

The standard approach is offering two tiers: monthly and annual. The annual plan should include a discount equivalent to roughly two months free, which both incentivizes longer commitments and reduces churn.

Example tier structure:
- Free: Core features, 5 AI analyses per month, ads shown
- Pro Monthly: $4.99/month — unlimited AI, no ads, cloud sync
- Pro Annual: $39.99/year (equivalent to $3.33/month, saving $20)

Building with Rork AI

Example Rork AI prompt:
"Add subscription functionality to the health tracking app:
- Free tier: basic logging, 5 AI health insights per month
- Pro Monthly: $4.99/month, unlimited AI analysis, detailed reports, no ads
- Pro Annual: $39.99/year
Include a 7-day free trial with a push notification reminder 3 days
before trial ends. Use RevenueCat for subscription management.
Add a subscription status indicator in the app header."

RevenueCat is the recommended library for subscription management — it handles receipt validation, cross-platform subscription status, and provides analytics out of the box.

Reducing Churn

Churn rate is the single most important metric for subscription businesses. Every percentage point of monthly churn compounds dramatically over a year. Here are proven strategies to keep subscribers engaged.

Deliver new value regularly. Whether it's new features, fresh content, or improved AI models, subscribers need to feel that their ongoing payment is justified by ongoing improvement. The first week after subscription is critical — invest in an onboarding flow that ensures new subscribers discover and use the premium features they're paying for.

When users attempt to cancel, present a retention offer. A 50% discount for one month costs you less than losing the subscriber entirely. Collect cancellation reasons through a brief survey and use that data to prioritize product improvements.

Give "we don't know yet" its own type

The bug I hit most often wasn't pricing or placement. It was the first few hundred milliseconds after launch.

Whether you use RevenueCat or talk to StoreKit directly, entitlement lookup is asynchronous. Between app launch and the purchase info coming back, the state isn't "paid" or "free" — it's "not known yet." Most implementations store it in a single boolean anyway.

// The common version. isPro starts out false.
const [isPro, setIsPro] = useState(false);
useEffect(() => { Purchases.getCustomerInfo().then(i => setIsPro(!!i.entitlements.active.pro)); }, []);
 
return isPro ? <PremiumScreen /> : <><BannerAd /><FreeScreen /></>;

This code flashes an ad at every paying customer on every cold start. It's the usual cause behind "I paid and I still see ads" in store reviews — and because it's intermittent from the user's side, you generally can't reproduce it when the report arrives.

The fix is to make the state ternary.

// entitlement.ts
export type Entitlement = 'unknown' | 'entitled' | 'notEntitled';
 
export function useEntitlement(): Entitlement {
  const [state, setState] = useState<Entitlement>('unknown');
 
  useEffect(() => {
    let alive = true;
    Purchases.getCustomerInfo()
      .then(info => {
        if (!alive) return;
        setState(info.entitlements.active['pro'] ? 'entitled' : 'notEntitled');
      })
      .catch(() => {
        // Don't collapse failures into notEntitled — that shows ads to
        // paying users whenever the app launches offline.
        if (alive) setState('unknown');
      });
    return () => { alive = false; };
  }, []);
 
  return state;
}

The part that matters is choosing a different default per surface when the state is unknown. Any attempt to pick one default for everything breaks one side or the other.

// Each surface decides what "unknown" means for itself
export const shouldShowAds     = (s: Entitlement) => s === 'notEntitled'; // withhold when unsure
export const shouldShowPaywall = (s: Entitlement) => s === 'notEntitled'; // withhold when unsure
export const canUnlockPremium  = (s: Entitlement) => s === 'entitled';    // deny when unsure
export const shouldShowLoader  = (s: Entitlement) => s === 'unknown';

Ads and paywalls withhold when unsure; premium unlocking denies when unsure. They point in opposite directions, and both follow from the same question: who pays for the mistake? Failing to show one ad costs a fraction of a cent. Showing an ad to someone who already paid costs their trust. Unlocking a paid feature for someone who hasn't paid leaks revenue directly.

Running those four predicates across the realistic launch scenarios makes the gap visible:

The two bold cells are where a single boolean serves ads to a paying customer. The offline case is the worse of the two — it persists until the restore call times out, which is a lot longer than a few hundred milliseconds.

When asking Rork AI to build this, specifying the type up front gets you the right shape:

Prompt for Rork AI:
"Model entitlement state as a three-value type: 'unknown' | 'entitled' | 'notEntitled'.
Show ads and the paywall only when the state is notEntitled.
Unlock premium features only when the state is entitled.
Render a skeleton while the state is unknown.
If getCustomerInfo() rejects, do not fall back to notEntitled."

Ask for "an isPro flag" and you'll get a boolean. Describing how the thing should fail, not just how it should work, is the part that makes generated implementations survive contact with real users.

Hybrid Monetization Strategies

Most successful apps combine multiple revenue models. Here are three proven patterns.

Pattern 1: Ads + Ad Removal IAP

The simplest hybrid. Free users see ads; users who find ads disruptive pay a one-time fee to remove them. You earn from both segments — advertising revenue from the majority and IAP revenue from engaged users willing to pay for a cleaner experience.

This pattern works particularly well for utility apps and casual games where the core experience doesn't naturally lend itself to premium features.

Pattern 2: Freemium + Subscription

Offer core functionality for free and gate advanced features behind a subscription. This is the dominant model for productivity, fitness, and content apps. The key challenge is calibrating the free tier — too restrictive and users leave before discovering value; too generous and there's no reason to upgrade.

A good heuristic: the free tier should let users accomplish their primary goal, while the paid tier should make them significantly more effective or efficient at it.

Pattern 3: Full Stack (Ads + Subscription + IAP)

Combine all three models, targeting different user segments with different monetization approaches. Free users see ads. Casual users buy individual features or content through IAP. Power users subscribe for the complete experience.

This maximizes revenue per user across all segments but adds complexity. Start simple and layer in additional models as your user base grows and you have data to guide decisions.

Post-Launch Revenue Optimization

A/B Testing

Every monetization decision should be validated with data. Key elements to A/B test include ad placement and frequency, pricing for IAP items and subscriptions, paywall design and copy, free trial duration (3 days versus 7 versus 14), and subscription tier structures.

Example Rork AI prompt:
"Add Firebase A/B testing for the subscription paywall.
Test Pattern A (feature-list focused layout) against
Pattern B (social-proof focused layout with testimonials).
Split traffic 50/50 and track the 'subscription_started' event
as the conversion metric."

Key Metrics to Monitor

Track these metrics daily to understand your revenue health. ARPU (average revenue per user) combines all revenue streams divided by daily active users — this is your north star metric. Conversion rate needs its denominator stated explicitly: 2-5% is a reasonable target for cumulative paying users over cumulative installs, but the monthly rate against DAU is closer to 0.3-0.8% — confusing the two shifts your projection by 6x. LTV (lifetime value) estimates the total revenue a user generates over their entire relationship with your app. Monthly churn rate should stay below 5% for subscriptions. ROAS (return on ad spend) measures whether your user acquisition spending is profitable.

Seasonal Promotions

Plan promotional campaigns around natural buying moments — New Year's resolutions, back-to-school season, Black Friday, and major holidays. Offer time-limited discounts on annual subscriptions (20% off is a common sweet spot) or release exclusive content packs tied to seasonal themes.

Common Mistakes to Avoid

Crippling the Free Tier

In the rush to monetize, some developers strip the free version down to near-uselessness. Users churn before they ever understand what they'd be paying for. Remember: the free tier is your acquisition funnel. It needs to deliver genuine value that makes users want more.

Overwhelming Users with Ads

Aggressive ad frequency is the fastest path to one-star reviews. If "too many ads" appears in your store reviews more than occasionally, you've already lost users who didn't bother to leave feedback. Monitor this closely and err on the side of fewer ads.

Ignoring Price Sensitivity

The right price depends on your market, category, and competitive landscape. Don't guess — research competitor pricing, then validate with A/B tests. A $4.99 subscription might convert at 4% while a $2.99 subscription converts at 8%, making the lower price more profitable despite the lower unit revenue.

No Win-Back Strategy

When subscribers cancel, most developers simply let them go. But re-engaging a lapsed subscriber costs far less than acquiring a new user. Set up automated win-back campaigns — a special offer email 30 days after cancellation, a push notification when you ship a major new feature.

Notes from building this solo

Three things changed in how I approach this after wiring monetization into Rork-built apps.

The first is that choosing the revenue model belongs before implementation, not after. I used to work in the order of "ship with ads, consider a subscription once it grows." But a screen laid out around a banner has nowhere to put a paywall later. The strip reserved at the bottom for the ad and the whitespace needed to communicate value are competing for the same real estate. Counting first lets you avoid that collision instead of discovering it.

The second is that monetization code is where generated implementations are least trustworthy. Layout and API calls generally work as produced. Purchase handling spends a long time in the state of looking correct while being broken — the ternary-gate problem is exactly that shape, and it looks fine in the simulator and on device. After generating it, you have to go test the failure modes yourself.

The third is that I stopped taking eCPM figures from other people. The same "¥180 banner" moves by a factor of two depending on category and geographic mix. Build a plan on somebody else's numbers and you'll later find a gap you can't explain. The script above isn't meant to be used as-is; it's meant to be re-run with your own measured values pulled from the AdMob console. Swapping four constants makes it your app's model rather than mine.

Your monetization roadmap — count, then build

Once the three models sit on the same footing, the ordering at 1,000 DAU is fairly clear. Establish the ¥81,600 base with ads. Layer remove-ads IAP on top for a few thousand yen more. Plant subscriptions early, but expect them to pay off in year two rather than year one.

That conclusion rests entirely on the constants I plugged in, though. eCPM and churn both move by a factor of two with category and region.

So the next step I'd suggest, before writing any of the implementation above, is to open monetization-mix.mjs and replace four constants — eCpmBanner, eCpmInter, your monthly conversion rate, and your churn — with your own measured figures from the AdMob console and App Store Connect, then run it once. It takes five minutes. The number that falls out will tell you which model to implement first.

I did this in the opposite order and lost months to it. If this saves you that detour, it was worth writing. Thank you for reading.