A Daily Slack Digest of Six Apps' Store Reviews, Built with Gemini Flash

The structured-output prompt I'm using

The Gemini side is small enough to paste in full.

import google.generativeai as genai
 
genai.configure(api_key=os.environ["GEMINI_API_KEY"])
 
PROMPT_TEMPLATE = """\
You are a mobile app support engineer. Read the single app review below
and return one structured JSON object.
 
App: {app_name}
Store: {store}
Rating: {rating}
Language: {language}
Body: {body}
 
Fields:
- ja_translation: Japanese translation (or original if already Japanese)
- sentiment: positive | neutral | negative
- category: bug | feature_request | praise | question | spam
- urgency: low | medium | high
- bug_summary: one-sentence symptom (only if category == bug)
- feature_request_summary: one-sentence ask (only if category == feature_request)
 
Urgency rubric:
- high: crash, app unusable, billing error, data loss
- medium: feature broken, recurring inconvenience
- low: general dissatisfaction, requests, praise
 
Return only the JSON object. No explanation text.
"""
 
def classify(review: dict) -> dict:
    prompt = PROMPT_TEMPLATE.format(**review)
    model = genai.GenerativeModel(
        "gemini-3-2-flash",
        generation_config={
            "response_mime_type": "application/json",
            "temperature": 0.1,
        },
    )
    res = model.generate_content(prompt)
    return json.loads(res.text)

response_mime_type = "application/json" is the line that keeps Gemini from emitting anything other than JSON. In practice it matters a lot — without it, ~5% of responses include leading commentary.

I run temperature at 0.1 rather than 0.0. Pure determinism is appealing but I saw occasional missing-field bugs at 0.0; nudging it slightly above produces stable JSON schemas with effectively the same categorization.

Crashlytics matching — "is this review about that crash?"

A review saying "won't start" might be about the current release or about a device-specific issue from a year ago. I give Gemini a second pass with the recent 48-hour Crashlytics top issues as context.

def match_crashlytics_issue(review_text: str, recent_issues: list[dict]) -> str | None:
    context = "\n".join(
        f"- {i['issue_id']}: {i['title']} ({i['affected_users']} users)"
        for i in recent_issues
    )
    prompt = f"""\
Compare the review below against the recent Crashlytics issue list, and
return the single most likely matching issue ID. Return "none" if no
issue plausibly matches.
 
Review: {review_text}
 
Recent Crashlytics issues:
{context}
"""
    model = genai.GenerativeModel("gemini-3-2-flash")
    res = model.generate_content(prompt)
    issue_id = res.text.strip()
    return issue_id if issue_id != "none" else None

The match is not 100% accurate, but it replaces the most painful manual step — sitting with a spreadsheet of recent crashes and a feed of recent reviews, trying to correlate them by eye. On Beautiful HD Wallpapers v2.0.0, this Crashlytics matcher correctly linked four user reviews to the RecyclerView crash issue I wrote about elsewhere.

The Slack message shape — threads enforce reading order

I post a single parent message with a one-line summary, and put the per-review detail in the thread.

:large_yellow_circle: 6 apps daily review digest — 2026-05-27
Total: 53 (positive 31, neutral 12, negative 10)
:red_circle: high: 2 / :large_orange_circle: medium: 6 / :large_green_circle: low: 45

[1] Beautiful HD Wallpapers, Google Play, ★1, ja
   high / bug / Crashes 3 seconds after launch on Android 6.0.1
   Crashlytics: maybe → ABC-1234
   ↪ thread for original text + reply draft

On days when no review is high or medium urgency, the parent line tells me that in one glance and I close Slack without expanding the thread. Days with more than ten negatives, I open the thread and work top-down by urgency.

I don't post reply drafts automatically. Replies are written by hand. With a 50M-download user base, the words that land in those review responses matter too much to delegate to a model. The ETL's job is exactly the triage step, not the writing step.

Monthly cost — Gemini Flash $4, Cloud Run effectively $0

The actual bill, copied from my invoice:

Reviews per month:  ~2,000 (six apps total)
Gemini API:         ~350 input tokens / 220 output tokens per review
                    gemini-3-2-flash pricing → about $3.80/month
Cloud Run:          ~30 minutes/month, within free tier → $0
Cloud Scheduler:    30 jobs/month, free tier → $0
Total:              ~$3.80/month

I've considered upgrading to Gemini Pro a few times, but for a six-app indie portfolio Flash is the right tool. Upgrade when you need >95% accuracy on sentiment, or when you need multi-step reasoning over a single review (summarize → extract feature request → compare to competitor parity). I don't need either of those, so I stay on Flash.

Twelve years of indie work and where I draw the line

My grandfathers were both shrine carpenters in Japan, and what I absorbed from them is that the parts no one sees decide whether the structure holds. In app review work, the part no one sees is the triage step — picking which reviews get answered today. The part users see is the reply itself. Splitting these in two and automating only the first half is what makes the second half sustainable.

I started teaching myself code in 1997, at sixteen. The thing technology does best is reclaim time we spend on the wrong work. Gemini Flash giving me back 48 minutes a day, for about four dollars a month, is exactly that shape of recovery.

Where to start if you want to try this

Building the full thing from day one is overkill. Start with one app, one store (App Store Connect's review API is friendlier), and send Gemini Flash's structured output to a Slack webhook from a cron job on your own machine. Cloud Run isn't needed until you're past three apps. Five reviews a day is enough volume to settle the JSON schema and Slack message shape.

I hope this is useful for anyone else running a small portfolio of apps on their own. Thanks for reading.