What changed
FACT (source: Android Developers Blog, June 2026): starting in Android 17 the OS enforces per-app memory limits scaled to device RAM and kills violators with no stack trace. FACT (source: Android Developers Blog, May/June 2026): the Android CLI hit stable 1.0 and lets coding agents drive Android Studio–grade tooling — builds, profilers, Compose previews, device streaming — headlessly instead of via brittle custom scripts.
Why now
Enforcement and the automation lever landed in the same quarter: silent kills create a diagnosis problem that in-house teams can't see in their crash reporters (no stack trace), while the stable agent-facing CLI makes it cheap for one person to run Studio-grade memory profiling autonomously. HYPOTHESIS: urgency ramps with Android 17 device penetration, so the acute pain window is likely 3-12 months out, not today — early movers get positioning, not immediate inbound.
Converging signals
(1) Android 17 per-app memory limits with silent kills [FACT, blog 841]; (2) Android CLI stable 1.0 enabling agent-driven professional Android workflows [FACT, blog 835]; (3) Google itself promoting agent-driven profiler/preview automation as the productivity path [FACT, blog 843]. Note: all three signals are capability/announcement signals from Google — there is NO buyer-complaint signal in this input set. Demand is currently inferred, not observed.
Customer pain
HYPOTHESIS (mechanism is factual, prevalence unproven): memory-heavy apps — games, media apps, React Native/Flutter hybrids with native leaks — start dying in the field on Android 17 devices with no crash report, surfacing only as uninstalls, 1-star 'app keeps closing' reviews, and support tickets nobody can reproduce. Small studios lack a senior Android performance engineer who can run profiler/leak triage.
Who pays
Small/mid app studios and agencies (2-20 devs) with published memory-heavy apps; secondarily indie game devs and RN/Flutter shops whose teams have no native-profiling skillset. They already pay for Instabug/Embrace-class observability and for one-off perf consultants, so a $500-$2,500 fixed-price audit is inside existing spending behaviour. HYPOTHESIS: willingness to pay before their app is visibly dying is low; the buyer converts after the first mystery uninstall wave.
Solved today
Free tooling (LeakCanary, Android Studio Memory Profiler, StrictMode), Android vitals / Play Console signals, crash-reporting SaaS (Crashlytics, Sentry, Embrace, Instabug), or hiring an Android perf consultant at $150-250/hr. Google's own guidance blog tells devs to do this work themselves.
Why current solutions are bad
Crash reporters are blind to no-stack-trace kills by design (HYPOTHESIS: some may partially infer them via exit-info APIs — this is the single biggest technical unknown to verify first). Free profilers require a skilled human driving them for hours; small studios don't have that person. Consultants are slow to book and expensive. Nobody currently sells a push-button 'is my app going to get killed on Android 17, and where's the leak' answer.
Proposed product
Productized audit service, not a platform: customer grants repo access or uploads an APK; an agent pipeline (Claude Code + Android CLI 1.0) builds the app, runs scripted memory-profiler sessions and leak-detection passes across simulated RAM tiers, flags allocations that breach Android 17 limits, and emits a ranked remediation report — optionally a patch PR for the top leaks. Price per audit, with a per-app/month re-scan-on-release retainer as the recurring layer.
MVP version
Concierge-first: pick 5 popular memory-heavy open-source or public APKs, run the agent pipeline manually, and publish 2-3 teardown reports ('X exceeds Android 17's limit on 4GB devices — here's the leak') as proof-of-capability marketing. Tooling needed: one repeatable script chaining Android CLI build → profiler capture → heap analysis → report template. No web app, no dashboard, no signup flow. 2-3 weeks of build.
30-day build
Week 1: verify the two make-or-break unknowns — (a) can existing crash/exit-info tooling already diagnose these kills (if yes, the wedge shrinks to remediation, not detection), (b) can the CLI-driven profiler pipeline actually run unattended end-to-end on a real hybrid app. Weeks 2-3: build the pipeline, produce 3 public teardown reports. Week 4: direct outreach to 30 studios whose apps the reports implicate or resemble ('your app class is in the kill zone — $750 audit, report in 72 hours'). Mine r/androiddev, Google Issue Tracker, and Play reviews for 'app closes without crash on Android 17' complaints to build a warm target list.
60-day build
Convert 3-5 paid audits; use each engagement to harden the pipeline (RN, Flutter, Unity variants). Add the patch-PR upsell (+$500-1,000). Publish every anonymized finding as content — the teardowns ARE the distribution. Start a simple waitlist/retainer offer: automatic re-scan on every release, $99-299/app/month.
90-day revenue plan
Target: $3-8k cumulative — 6-10 audits at $500-1,500 plus 3-5 retainer apps. HYPOTHESIS: this assumes Android 17 rollout has reached enough devices that studios feel the kills; if adoption lags, revenue slips a quarter and the play becomes pre-emptive 'compliance check before you're hit', which converts worse.
Distribution path
Demonstrated value, no enterprise sales: public APK teardowns as content, posted to r/androiddev, Hacker News, Android dev newsletters/Discords; direct outreach to studios named or implicated by the scans; SEO on 'Android 17 app killed no crash report'. This matches the founder's proven sell-by-showing motion. Weakness: dev-tool audiences are skeptical of paid audits when LeakCanary is free — the reports must show findings free tools miss.
Pricing hypothesis
$500-1,500 per audit (scope by app size), $500-1,000 patch-PR add-on, $99-299/app/month continuous re-scan retainer. Anchor against the alternative: 10-20 hours of a $200/hr perf consultant.
Technical difficulty
Moderate. The CLI is first-party and stable, but chaining build → profiler → heap diff → actionable leak attribution across arbitrary third-party codebases (especially RN/Flutter/Unity) is genuinely hard to make reliable; expect per-customer babysitting for months. FACT: the CLI supports agent-driven profiling [blog 835/843]; HYPOTHESIS: that it works unattended on messy real-world repos.
Legal / regulatory risk
Low. Analyzing a customer's own app under contract is clean. Publishing teardowns of third-party APKs needs care (analyze public behaviour, avoid decompiled-source publication, honor ToS). Repo access requires an NDA template and basic security hygiene — a trust hurdle for cold buyers, mitigated by the APK-only entry tier.
Platform dependency
High and double-ended: Google controls both the enforcement (could soften limits, add stack traces, or surface kills in Android vitals — any of which shrinks the pain) and the tooling (CLI pricing/terms). Google shipping a first-party 'memory compliance check' in Play Console is the realistic 12-month kill shot. This is a fast-cash window play, not a durable moat.
Founder fit
Good but not his best pattern. Fits: AI-agent automation, low-budget productized service, sell-by-demonstration, complaint-mining distribution, no enterprise sales. Does NOT fit the proven ELDT edge — no regulation compels anyone to file anything with a government system here; Google enforcement creates pain but no mandated filing to intermediate, so there is no per-transaction compliance chokepoint to own. Also assumes he can debug Android/native memory issues when the agent stalls — HYPOTHESIS, not demonstrated. Score high-moderate, not VERY HIGH.
Breakout potential
Moderate: could grow into a CI-integrated 'Android release health' micro-SaaS (scan every release, block regressions) and expand to other OS-enforcement events. But the category leaders (Emerge Tools, Embrace) are funded and adjacent; durable version of this becomes a features race he shouldn't fight. Best case is a $5-20k/mo productized service or an acquihire-by-customer of the tooling.
Final recommendation
CONDITIONAL GO — validate before building. Spend week 1 exclusively on the two kill-shot questions: (1) do existing exit-info APIs/crash vendors already expose Android 17 memory kills, and (2) is there any observable complaint volume yet (r/androiddev, Google Issue Tracker, Play reviews). If detection is genuinely blind and complaints are appearing, build the concierge pipeline and sell audits immediately — the agent-run cost structure makes even 5 customers profitable. If either check fails, park this and revisit when Android 17 hits meaningful device share. Do not build a platform or dashboard under any circumstances in the first 90 days.
Next action
Today: (a) test whether ApplicationExitInfo/Crashlytics/Sentry capture an Android 17 memory kill on an emulator image, and (b) run three searches (r/androiddev, Google Issue Tracker, Play reviews) for 'Android 17 app killed/closes no crash' to count real complaints. Both are free and take one day; they decide the whole bet.