The companion article Mobile App Monetization Foundations With Rork covered the big-picture decision framework. This piece picks up from there — what you actually implement and operate to break the ¥100k/month wall.
I've been doing solo mobile development since 2014, peaking at over ¥1.5M/month from AdMob alone, and I currently hold steady around ¥500k/month across multiple apps. This article distills the things I've found to actually work — and the things I've found to definitely not work — into a form you can apply on Rork.
What the ¥100k/Month Wall Really Is
The ¥100k/month number isn't arbitrary. It's the line where solo development becomes "viable as a side income," and most indie developers stop right at it. The reason is simple: getting from ¥10k to ¥100k requires more than scaling up what got you to ¥10k.
Reaching ¥10k is partly luck. My first hit got there without much effort. But the 10x jump from ¥10k to ¥100k almost never happens without strategic tuning.
The state I call "the ¥100k wall" looks like this: you can ship apps, they're in the stores, you're getting some downloads, but revenue plateaus between ¥3,000 and ¥10,000/month. Breaking through requires shifting from "implementation mode" to "operations mode."
The Strategy Map — Four Levers
Four primary levers are available for crossing ¥100k/month. We'll go through each.
Maximize ad eCPM. Doubling eCPM (revenue per 1,000 impressions) doubles revenue at the same impression count.
Optimize IAP price and pitch. Tuning your product lineup, prices, and purchase flow can double your conversion and ARPU.
Improve subscription retention. Cutting monthly churn from 10% to 5% doubles LTV.
Grow ASO organic downloads. Store optimization can lift downloads 3–5x for the same app.
In my experience, focusing on one lever at a time — based on your app's current state — is far more effective than improving all four in parallel.
Maximizing Ad eCPM
For ad-based apps, eCPM improvement is the most direct path to ¥100k/month. Three strategies I've validated:
Mediation. Combining AdMob with Meta Audience Network, Unity Ads, and AppLovin via Mediation lets the highest bid win for each impression. Typical lift: 30–80% on eCPM.
// AdMob Mediation baseline setup
import mobileAds, {
AdsConsent,
AdsConsentStatus,
MaxAdContentRating,
} from "react-native-google-mobile-ads";
// Run once at startup
mobileAds()
.setRequestConfiguration({
maxAdContentRating: MaxAdContentRating.PG,
tagForChildDirectedTreatment: false,
tagForUnderAgeOfConsent: false,
})
.then(async () => {
// GDPR consent (mandatory for EU users)
const consentInfo = await AdsConsent.requestInfoUpdate();
if (consentInfo.status === AdsConsentStatus.REQUIRED) {
await AdsConsent.showForm();
}
await mobileAds().initialize();
});
// Mediation configuration is done in the AdMob dashboard
// Local code remains the standard AdMob implementationReal-time bidding. Switching from waterfall to bidding adds another 15–25% on top of mediation gains. Toggle "Bidding" in the AdMob dashboard.
Format mix. My optimal mix on the wallpaper apps (such as Beautiful Wallpapers) was banner (always-on at the bottom of home), interstitial (every 5th detail-image view), rewarded (optional at wallpaper-set time). Rewarded eCPM often runs 10–30x banner; tying it to a "voluntary user action" captured the high yield without hurting UX.
Optimizing IAP Price and Pitch
For IAP-based apps to cross ¥100k/month, both conversion rate and ARPU must improve.
Three price tiers. With one product, users decide "buy or not." With three, they decide "which one." The decoy effect makes the middle tier most popular, raising average order value.
const TIER_PRODUCTS = [
{ sku: "starter", price: "¥240", features: ["Remove ads"] },
{ sku: "standard", price: "¥480", features: ["Remove ads", "Pro features", "50 templates"], recommended: true },
{ sku: "deluxe", price: "¥980", features: ["Remove ads", "Pro features", "200 templates", "Cloud backup"] },
];
function PricingScreen() {
return (
<View>
{TIER_PRODUCTS.map((tier) => (
<View key={tier.sku} style={tier.recommended ? styles.recommended : styles.normal}>
{tier.recommended && <Badge text="Recommended" />}
<Text style={styles.price}>{tier.price}</Text>
{tier.features.map((f) => <Text key={f}>✓ {f}</Text>)}
<Button title="Buy" onPress={() => handlePurchase(tier.sku)} />
</View>
))}
</View>
);
}Time-limited offers. A "50% off within 24 hours of first launch" offer typically converts 5–10% of non-paying users. Caveat: only use real time limits — fake countdowns are dark patterns and erode trust.
function useFirstLaunchTimer() {
const [secondsLeft, setSecondsLeft] = useState<number>(0);
useEffect(() => {
const init = async () => {
const firstLaunch = await AsyncStorage.getItem("first_launch_at");
const firstLaunchAt = firstLaunch ? parseInt(firstLaunch) : Date.now();
if (!firstLaunch) {
await AsyncStorage.setItem("first_launch_at", String(Date.now()));
}
const offerEndsAt = firstLaunchAt + 24 * 60 * 60 * 1000;
const interval = setInterval(() => {
const remaining = Math.max(0, offerEndsAt - Date.now());
setSecondsLeft(Math.floor(remaining / 1000));
}, 1000);
return () => clearInterval(interval);
};
init();
}, []);
return secondsLeft;
}Pre-purchase trial. Adding a 5-minute "feel what ad-free is like" preview lifted my conversion by 1.8x. Reframe from "you can't use this without paying" to "try it, and pay if you like it."
Holding Subscription Retention at 95%
For subscription apps to cross ¥100k/month, you need monthly churn under 5%. The LTV at 5% churn is double the LTV at 10%.
Auto-recover failed payments. Card expirations and authorization failures account for 30%+ of all cancellations — these aren't user choice, they're administrative failures, and most are recoverable.
// Auto-recovery flow on payment failure (Stripe webhook)
async function handleInvoicePaymentFailed(invoice: Stripe.Invoice) {
const userId = invoice.metadata?.userId;
const subscription = await stripe.subscriptions.retrieve(invoice.subscription as string);
// 1. Notify the user immediately
await sendEmail(userId, {
template: "payment_failed_retry",
data: {
retryUrl: invoice.hosted_invoice_url,
nextAttemptAt: new Date(invoice.next_payment_attempt! * 1000),
},
});
// 2. Show an in-app banner
await db.user.update({
where: { id: userId },
data: {
paymentIssue: true,
paymentIssueResolveBy: new Date(invoice.next_payment_attempt! * 1000),
},
});
// 3. Stripe Smart Retries handles up to 3 retries
// If still failing, subscription.deleted will fire
}Make value visible monthly. Users decide "is this worth paying again?" right around billing time. A monthly summary email of "what you accomplished this month" cut my churn from 8% to 4%.
// Monthly summary on the 25th
async function sendMonthlySummary(userId: string) {
const monthStart = startOfMonth(new Date());
const monthEnd = endOfMonth(new Date());
const usageStats = await db.usageEvent.aggregate({
where: {
userId,
occurredAt: { gte: monthStart, lte: monthEnd },
},
_count: { _all: true },
_sum: { quantity: true },
});
await sendEmail(userId, {
template: "monthly_value_summary",
data: {
totalActions: usageStats._count._all,
timeSavedMinutes: estimateTimeSaved(usageStats),
topFeatures: await getTopFeatures(userId, monthStart, monthEnd),
},
});
}Cancellation save flow. When a user clicks cancel, offer "50% off this month" or "next month free." This recovers 15–25% of intended cancellations. Critical: keep the one-tap cancel path intact — never make it a dark pattern.
Tripling Organic Downloads With ASO
To break ¥100k/month sustainably, organic ASO traffic matters more than paid ads. Paid acquisition has poor ROI at indie scale and burns you out.
Aggressive subtitle and keyword optimization. App name + subtitle (30 chars) + keyword field (100 chars) totals 130 characters of pure SEO real estate. Use Sensor Tower or App Annie to find "high-volume, low-competition" keywords and pack them in.
A/B test screenshots. Both Apple and Google support screenshot A/B testing. A single pair change can double your store-page conversion. In my apps, "benefit text on screenshot" outperforms "feature screenshot" reliably.
Multilingual expansion. Going from JP+EN to 16 languages routinely doubles or quadruples downloads. Rork makes the translation workflow much easier than it used to be, lowering the bar significantly.
Common Pitfalls
Testing too many things at once. If you change five things and revenue moves, you don't know what worked. One change at a time, two-week measurement window — slow is fast here.
Over-optimizing for short-term revenue. Cramming in more ads or pushy paywalls can briefly lift revenue, but reviews tank, ranking drops, and total revenue eventually falls. I had to learn this three times before it stuck.
Skimping on analytics. Without granular event tracking via Firebase Analytics or Amplitude, you can't see where users drop off. Analytics setup is the highest-priority task on the path to ¥100k/month.
Over-dependence on one app. Hitting ¥100k/month on a single app makes it tempting to lean entirely on that app, but a store policy change, OS update incompatibility, or new competitor can erase the revenue overnight. Three or more revenue sources is the survival baseline for solo developers.
Pricing without rationale. "Other apps charge ¥480" isn't a reason. Price from "what value does the user perceive" backward. Before setting a new feature's price, I always interview five users first.
What "Apps That Cross ¥100k" Have in Common
Across 50+ shipped apps, the ones that stably earn ¥100k+/month share a few traits.
One clear value proposition. If you can describe the app's value in one sentence, it grows. "Does many useful things" downloads short-term but doesn't retain or monetize.
A retention hook. Reasons to open daily — notifications, fresh content, visible progress — built into the app from the start.
Ongoing dialogue with users. Reply to reviews, post on social, respond carefully to support requests. The unsexy work compounds.
Closing Thought
To cross ¥100k/month as a solo developer requires shifting from "build" to "operate." Reaching ¥10k can happen by accident; reaching ¥100k cannot.
If you do one thing today, calculate your current monthly revenue and ARPU per active user. The path to 3x that becomes visible — and which of the four levers (ad eCPM, IAP, subscription retention, ASO) to prioritize first becomes obvious.
The biggest lesson from 12 years of trying is this: once you cross the ¥100k wall, the path to ¥500k+ is comparatively smooth. The first wall is the hardest. With Rork in your hands as a powerful implementation tool, the conditions for crossing that wall have never been better.