What changed
FACT (source: Android Developers blog, June 2026): Starting in Android 17, the system enforces per-app memory limits scaled to device RAM and kills violating apps with no stack trace. FACT (source: Android Developers blog, May 2026): Google AI Studio now generates installable native Android apps from a prompt with zero tooling, and the first-party Android CLI hit stable 1.0, letting coding agents drive builds, profilers, and Compose previews programmatically.
Why now
FACT: Enforcement is live now (June 2026) at the same moment Google's own tools mass-produce app authors who have never opened a profiler. FACT: The stable CLI (1.0) makes profiler runs scriptable by an agent, so the audit itself can be automated by a solo builder. HYPOTHESIS: A meaningful population of these prompt-built apps will exceed the limits and get silently killed, producing confused owners searching for help — this is inferred from the causal chain, not yet observed in complaint data.
Converging signals
(1) Android 17 per-app memory limits with silent kills [Prioritizing Memory Efficiency post]; (2) prompt-to-native-app generation in AI Studio [Build native Android apps post]; (3) Android CLI 1.0 stable enabling agent-driven builds/analysis [CLI 1.0 post]; (4) agents can drive Android Studio profilers via CLI [productivity updates post]. Signals 1 creates the pain, 2 creates the unskilled victim pool, 3-4 make the fix automatable at low cost.
Customer pain
FACT (source): apps exceeding limits are killed with no stack trace — the one failure mode that gives a novice literally nothing to Google. HYPOTHESIS: prompt-app creators experience this as 'my app randomly closes on my customer's phone,' can't reproduce it, and AI chat assistants can't fix what needs runtime profiling. Pain intensity is plausible but there is zero cited complaint evidence (no Reddit/StackOverflow/Play-review signals in the input) — this is the single biggest unvalidated assumption.
Who pays
HYPOTHESIS: (a) prompt-app creators with a live app being killed (one-off scan, $29-99); (b) micro-studios/agencies shipping many client apps (pre-release check subscription, $49-199/mo); (c) AI-agent dev shops wanting a CI gate. Segment (a) is large but hobbyist-heavy with low willingness to pay; (b) is the credible revenue core but smaller.
Solved today
FACT-adjacent (well-known tooling, not from provided sources — treat as background): Android Studio Memory Profiler and LeakCanary are free and standard; Embrace/Instabug/Sentry offer paid production monitoring. HYPOTHESIS: none of these are usable by a non-developer — they assume you can read a heap dump, and none frame output as 'Android 17 compliance pass/fail + patch.'
Why current solutions are bad
Free tools require exactly the skill the target customer lacks (profiler literacy, heap-dump reading). Production monitors require SDK integration before the crash and still hand back diagnostics, not fixes. Nothing takes 'here is my APK/project' and returns 'you will be killed on 2GB devices; here is the patch.' HYPOTHESIS: the packaging/automation gap, not the diagnostic capability, is the product.
Proposed product
A web service + CLI: upload a Compose project (or APK + repo link). Pipeline: agent-driven Android CLI spins emulators at several RAM tiers, exercises the app (Compose preview traversal + monkey-style navigation), captures heap/RSS against Android 17 limits, runs leak detection, then a Claude-driven pass maps findings to source and emits concrete patches (bitmap handling, listener leaks, ViewModel scope, oversized Compose state). Output: pass/fail compliance report + patch set the customer's own AI agent can apply. Per-scan pricing; subscription CI gate for repeat shippers.
MVP version
2-3 weeks: scriptable pipeline = Android CLI + emulator matrix (2/4/8GB profiles) + automated UI walk + memory sampling vs. Android 17 thresholds + LeakCanary-style heap analysis, wrapped in a report generator; Claude Code produces the patch suggestions. Manual-in-the-loop at first (founder sanity-checks each report) — sold as a productized service before it's a SaaS. Landing page: 'Your app is being killed by Android 17. Find out why in 1 hour.'
30-day build
Week 1: demand validation BEFORE building — mine r/androiddev, StackOverflow, Google Play developer forums, and AI Studio community spaces for 'app killed / closes randomly / Android 17' complaints; post a diagnostic offer. Weeks 2-3: build the emulator+CLI scan pipeline on 2-3 real prompt-generated apps (generate them himself in AI Studio to create test corpus). Week 4: 10 free scans for complainants in exchange for testimonials and pricing interviews.
60-day build
Convert free scans to paid ($49/scan launch price). Publish 2-3 teardown posts ('We scanned 25 AI-Studio-generated apps; 60% violate Android 17 limits' — content that markets itself). Add self-serve upload + Stripe. Approach 5-10 small agencies/AI-app studios with a pre-release compliance-check retainer.
90-day revenue plan
HYPOTHESIS target: 30-60 paid scans/mo ($1.5-3k) + 3-5 studio subscriptions at $99-199/mo ($0.5-1k) = $2-4k MRR. Honest floor: $0 if complaint mining in week 1 finds no organic pain — in which case kill it cheaply, having spent <2 weeks.
Distribution path
Complaint-mining and direct reply (his proven motion): answer 'my app keeps closing' threads with a free diagnostic. SEO on the exact novel query ('app killed Android 17 no crash log') where competition is currently zero. Teardown content. Listing in agent-tool directories so coding agents themselves can invoke the scan as a tool (CLI makes this natural). No enterprise sales anywhere in the loop.
Pricing hypothesis
$49-99 per scan (report + patches); $99-199/mo studio plan (unlimited pre-release scans, CI hook); later an API per-call price for agent platforms. Anchor against the cost of one lost customer or a failed client delivery, not against free profilers.
Technical difficulty
Moderate. The profiling primitives are all first-party and free (FACT: CLI 1.0 drives profilers/previews). Hard parts: reliably exercising an arbitrary app's UI to trigger its real memory profile (coverage problem), and mapping runtime findings to correct source patches for APK-only customers without source. Mitigation: require project source (Compose/AI Studio export) for the patch tier; APK-only gets diagnosis tier. Solo-feasible with AI assistance; realistic MVP is weeks, not days.
Legal / regulatory risk
Low. Analyzing a customer's own app at their request; no scraping, no PII, no regulated domain. Standard ToS disclaiming guarantee of Play acceptance.
Platform dependency
HIGH — the main structural risk. The pain exists at Google's pleasure: Google could soften Android 17 enforcement, or (more likely) bake memory-compliance checks into AI Studio generation and Android Studio itself, since they built both the trap and the tooling. Reasonable window: 6-18 months of arbitrage, not a decade. Price and effort should assume harvest-fast.
Founder fit
Strong on mechanism, weaker on domain. Matches his pattern: a mandate (platform, not federal) forces a party into a compliance obligation they can't self-serve; he builds the automated check/submission layer and charges per transaction — structurally the ELDT play with Google as the regulator. Fits stated preferences: micro-SaaS, API, agent tooling, compliance monitor, complaint-mining, demonstrated-value sales. Gap: he has no visible Android-ecosystem presence and this isn't a government portal, so the VERY-HIGH gov-filing multiplier does not fully apply; also unlike ELDT, nobody is legally compelled to buy — apps can just stay broken.
Breakout potential
Moderate. Natural expansion: full 'Android 17 readiness' audit line (background limits, battery, permissions), a CI compliance gate for agent-built apps generally, and becoming the standard 'verify' tool coding agents call after generating Android code — that last one is the real prize if agent platforms adopt it.
Final recommendation
CONDITIONAL GO — cheap validation first, build second. This is a genuine convergence with a real silent-failure pain mechanism and an unusually good fit to his compliance-automation playbook, but demand is 100% inferred. Spend ≤1 week mining complaints and offering free diagnostics; build the pipeline only if ≥5-10 real sufferers surface. Treat as a 6-18 month cash harvest (platform will eventually absorb it), not a long-term company.
Next action
Today: search r/androiddev, StackOverflow, and Google Play developer community for Android 17 kill complaints ('app closes randomly', 'killed no crash log', 'excessive memory'), and generate 3 test apps in AI Studio to profile against Android 17 limits — validating both the demand and the technical pipeline in parallel within 48 hours.