After WWDC26, Reselecting What an Indie Should Build Right Now

Which brake did the free tier actually release?

Question 1 can be answered with arithmetic rather than instinct. I ran the numbers on what those external API charges were really blocking.

// ai-cost-model.mjs — what metered API pricing was actually blocking
const PRICE_IN = 0.15 / 1e6;   // USD per input token (small-model assumption)
const PRICE_OUT = 0.60 / 1e6;  // USD per output token
const PRICE = 3.50;            // monthly subscription, USD
const STORE_FEE = 0.30;
 
const profiles = [
  { name: "Light (one summary a day)",     calls: 2,  tin: 400,  tout: 150 },
  { name: "Daily (one insight each morning)", calls: 10, tin: 800,  tout: 300 },
  { name: "Constant (interpret every input)", calls: 40, tin: 1500, tout: 500 },
];
 
// monthly AI cost per DAU, in USD
const costPerDau = (p) =>
  p.calls * 30 * (p.tin * PRICE_IN + p.tout * PRICE_OUT);
 
for (const p of profiles) {
  const c = costPerDau(p);
  const breakevenCvr = c / (PRICE * (1 - STORE_FEE));
  console.log(
    `${p.name} : $${c.toFixed(3)}/DAU/mo / $${(c * 5000).toFixed(0)} at 5,000 DAU ` +
    `/ break-even paid conversion ${(breakevenCvr * 100).toFixed(2)}%`
  );
}

Here is the output from Node v22.22.3. Token pricing moves around by model, so read these as orders of magnitude rather than quotes.

The shape of this surprised me. A once-a-day summary costs under a cent per user per month even on metered pricing. It breaks even at a 0.37% paid conversion rate, which means it was always affordable — free tier or not. That was never where the brake was.

What was blocked started at "daily." Returning one small insight every morning pushes break-even conversion to 3.67%, and indie apps realistically convert somewhere between 2% and 4%. That lands right on the line. Interpreting every input as it arrives needs 25.71%, which is simply not a number anyone hits.

So the free tier did not release the brake on whether you can add AI. It released the brake on whether you can run AI every single day. Questions 1 and 2 turn out to be the same question asked from two sides. If you want to keep the inference on the device entirely, I covered that path in Adding Offline Edge AI to Rork Apps.

Question 2: Is the reason to keep opening it inside the feature?

The most overlooked thing at the concept stage is the reason to return. Even with a smart feature, an experience that satisfies after one use will not grow retention. In the apps I have run, the ones that lasted generated a little meaning each day.

On-device AI shines here. An experience that interprets the user's data on the spot and returns a small insight for today is a cost you might hesitate over with an external API, but can run daily on the free tier. At the concept stage, put into words whether this feature becomes a reason to open the app every day. If it does not, it is a one-off convenience, not a business core.

Question 3: Is the billing path in the concept from the start?

If you chase revenue as an indie, billing is part of the concept, not an afterthought. At the concept-doc stage I draw a clear line between the value given for free and the value people pay for.

Three lines I write into the concept doc from the start (my template)
- Free value: the core of an experience worth opening daily (retention fuel)
- Paid value: an extension that deepens the free experience (ad removal / lifted limits / advanced AI)
- Billing placement: the natural moment right after the user feels the value

In the on-device AI context, "light AI features free, heavy or high-frequency AI features paid" draws a natural line. Because even a free tier has practical usage realities, a design where heavy users sustain you through a paid plan holds up without strain. If you combine AdMob ads with RevenueCat subscriptions, decide that split at the concept stage too.

Question 4: How many days to validate a minimal form with Rork?

Even a sound concept loses momentum if validation drags. This is where Rork (Expo) speed pays off. I take a new concept, build a minimal form in Rork first, hand out a share link, and confirm within a few days whether the reason to return is real.

In minimal validation, watch "did they open it again tomorrow," not "the numbers"
1. Generate just the one core screen in Rork, distribute via share link
2. Have 5-10 people use it for a week
3. Look only at whether they opened it the next day / stayed after a week
4. If they did not stay, drop the concept. If they did, move to the next question

You do not need to pay $200/month for Rork Max at this stage. I broke down what the plan tiers actually buy you in Rork Pricing Compared: Free vs Pro vs Max. Validate the core on Expo-based Rork, and only after you are convinced the reason to return is real, decide whether native depth is required. Not prepaying a heavy investment on concept validation is the realistic rhythm of indie development.

What five testers can and cannot tell you

In Question 4 I said to hand the build to 5-10 people and watch whether they open it again tomorrow. I had never actually checked how much that sample size can support. Binomial confidence intervals settle it.

// retention-signal.mjs — what a tiny "did they come back" sample supports
const Z = 1.96;
 
function wilson(k, n) {
  const p = k / n, d = 1 + Z * Z / n;
  const c = p + Z * Z / (2 * n);
  const s = Z * Math.sqrt((p * (1 - p) + Z * Z / (4 * n)) / n);
  return [(c - s) / d, (c + s) / d];
}
 
for (const n of [5, 8, 10, 20, 30, 100]) {
  const [lo, hi] = wilson(Math.round(n * 0.5), n);  // half came back
  const [lo2] = wilson(n, n);                       // everyone came back
  console.log(
    `n=${n} : half -> D1 ${(lo * 100).toFixed(1)}-${(hi * 100).toFixed(1)}%` +
    ` (width ${((hi - lo) * 100).toFixed(1)}pt) / all -> floor ${(lo2 * 100).toFixed(1)}%`
  );
}
 
for (const p of [0.3, 0.4, 0.5]) {
  console.log(
    `True D1 of ${(p * 100).toFixed(0)}% still produces 3/3 ${(p ** 3 * 100).toFixed(1)}% ` +
    `of the time, 5/5 ${(p ** 5 * 100).toFixed(1)}% of the time`
  );
}

A split result carries almost no information. Four out of eight tells you only that true D1 sits somewhere between 21.5% and 78.5%. Killing or funding a concept on a 57-point interval is barely different from flipping a coin.

A unanimous result is a different animal. If all five open it the next day, the floor on D1 rises to 56.6%. An app whose true D1 is 30% produces five straight returns 0.2% of the time; even at 40% it happens only 1.0% of the time. Small samples are strong precisely when the answer is unanimous, and worthless when it is mixed.

So I rewrote my own rule for Question 4: discard split results as noise, and advance only the concepts where everyone came back. Reading four-out-of-six as "not bad" and pressing on is the expensive mistake, because it spends weeks on a signal that was never there. What to do with a concept that does survive is a separate craft, which I worked through in Designing a Rork App That Doesn't Get Deleted.

Question 5: When it grows, how much room is there to go deeper?

The final question is the ceiling. For a concept that survived validation, roughly estimate at the concept stage how deep it can later go. If the core you shipped with Rork (Expo) will eventually need native depth like widgets, Live Activities, or on-device Core ML, then a staged move to Rork Max enters the options at that point. Where generation stops reaching and hand-written native work begins is mapped out in Where Rork Max Still Falls Short.

I call this "staged planning." Rather than aiming at the finished form from the start: ship fast with Rork, confirm the reason to return, and deepen with native features as it grows. Balancing investment against conviction at each stage is what wears me down the least while continuing indie development on limited time.

Conclusion: when the premise shifts, re-rank the concepts

On-device AI going free for indie developers is not a story about one new feature. It is a story about the premise of "what should be built" moving. A concept you gave up on, blaming AI cost, might pencil out now.

As a next step, write down three app ideas you have been nursing, and run each through today's five questions. The one with the most Yeses is the concept you should validate first with Rork. I am still in the middle of learning myself, but I would be glad to think it through together.