In mid-May I opened the AdMob monthly report and wondered: if I sent the same CSV to both Gemini 3 Pro and Gemini 3 Flash at once, would the two summaries leave me torn over which to trust? Running apps solo, I had been noticing that the time I spend just staring at monthly revenue reports kept quietly growing.
These are my implementation notes from ten mornings of sending the same AdMob report to Pro and Flash in parallel, measuring cost, latency, and summary quality. The short version: rather than pick one, I landed on a workflow where each model plays a different role in the same day.
Why I Wanted to Run Them Side by Side
The trigger was a month of using Pro's summary on its own. The conclusions were plausible, but I had no way of checking whether a given interpretation was actually sound. Reading the gap between two models' answers, I suspected, would make biases and omissions easier to spot than trusting either model alone — so I decided to run them together.
The practical motivation was more concrete:
- The monthly AdMob CSV is split into three sheets — eCPM by country, RPM by ad unit, and fill rate — and I always end up staring at it for fifteen minutes or more
- Pro alone gives plausible conclusions but it is hard to feel the accuracy difference on months with small movements
- Flash alone is fast and cheap, but occasionally summarises numerical interpretation a bit loosely
- Putting them side by side might help me decide where to act next month, faster
More data points can easily slow a decision down rather than sharpen it, so I deliberately constrained the experiment: two models in parallel, the human still synthesises.
Parallel Setup
The setup is small: Python's asyncio sending the same prompt to Pro and Flash, then laying the two summaries side by side.
import asyncio
from google import genai
from google.genai import types
client = genai.Client(api_key="YOUR_GEMINI_API_KEY")
PROMPT = """
For the attached AdMob monthly report (CSV text), write the following
three points as a bullet list in English:
- Countries where eCPM moved by 5% or more vs last month, with a hypothesis
- Ad units where fill rate is dropping and probable causes
- Adjustments to test next month (floor price, mediation order, new formats)
Prefix any speculative reasoning with "Speculation:".
""".strip()
async def call(model: str, csv_text: str) -> dict:
resp = await client.aio.models.generate_content(
model=model,
contents=[csv_text, PROMPT],
config=types.GenerateContentConfig(
temperature=0.3,
max_output_tokens=1200,
),
)
usage = resp.usage_metadata
return {
"model": model,
"text": resp.text,
"input_tokens": usage.prompt_token_count,
"output_tokens": usage.candidates_token_count,
}
async def run(csv_text: str):
return await asyncio.gather(
call("gemini-3-pro-latest", csv_text),
call("gemini-3-flash-latest", csv_text),
)By default asyncio.gather fails as a whole when either task raises, which means one bad model call costs you the summary that succeeded. In production I wrap the try/except inside each call and keep the half that worked:
async def call_safe(model: str, csv_text: str) -> dict:
try:
return await call(model, csv_text)
except Exception as e:
return {"model": model, "text": None, "error": str(e)}
async def run(csv_text: str):
results = await asyncio.gather(
call_safe("gemini-3-pro-latest", csv_text),
call_safe("gemini-3-flash-latest", csv_text),
)
return [r for r in results if r.get("text")]During the ten days of measurement there was exactly one morning when only the Flash call returned a 503. The routine survived on Pro's summary alone that day, and I was glad these few lines of insurance were in from the start.
Ten Days of Measurements — Cost and Latency
From May 15 to May 24 I sent the same CSV (running month-to-date through the previous day) every morning. Averages over ten runs:
- Input tokens: around 9,500 (CSV fed in as raw text)
- Pro latency: 11.4 seconds average, output 540 tokens
- Flash latency: 3.2 seconds average, output 480 tokens
- Cost feeling: Flash came in at roughly one-seventh of Pro's cost based on the published pricing table
Over the ten days, total API cost was about 80 yen for Pro and 12 yen for Flash. At that price, running it daily comfortably pays for itself against the fifteen minutes of spreadsheet-staring it replaces.
The latency gap was more felt than I expected, and a natural rhythm emerged: read Flash's reply first, then decide whether to wait for Pro. The first three lines of Flash usually tell me whether Pro is worth waiting for.
One caveat about reproducibility that I only appreciated later: the code above uses the -latest aliases, and what an alias points to changes without notice. In July 2026, gemini-flash-latest switched to resolving to Gemini 3.5 Flash. For a measurement that compares cost and latency, a silent model swap mid-run makes the averages meaningless. Pin an explicit versioned model ID for anything you intend to measure, and reserve the aliases for day-to-day usage where you actively want to track the newest release — a distinction I should have settled before day one.
Where the Summaries Differed — Depth of Numerical Reading
Reading the ten days side by side, the difference between Pro and Flash was less about what they picked up and more about how deeply they read the numbers.
For example, one day India's eCPM was up 18 percent month-on-month.
- Flash's summary: "India eCPM up 18%. Probably seasonal demand."
- Pro's summary: "India eCPM up 18%. Same month's fill rate dropped 3 points, so this may not be a demand surge — fill is tightening and only the higher-CPM inventory is passing through. Recommend raising the floor price by 0.05 to see how fill responds."
Flash was not wrong, but Pro reached into the relationship with fill rate. That kind of multi-indicator reading is where the difference showed up most.
Conversely, Flash was better at "short, listed, scannable" outputs. For a Slack-ready summary or a quick weekly note, Flash sometimes read more naturally to me.
Where I Settled — Split Roles
After the ten days, I settled on this split:
- Daily check: Flash only. The three-second reply tells me whether it is a Pro day
- Weekly deep read: Pro only. Multi-indicator interpretation and concrete next-week tests
- End-of-month summary: Both in parallel — Flash's list combined with Pro's interpretation, then I write the final note myself
Official docs frame Pro as the reasoning model and Flash as the speed-and-cost model. After using both daily in a real project, I find a two-tier flow — "Flash to scan the whole picture, Pro to read deeply" — fits indie operations better than picking just one.
What I Want to Try Next
The next experiment is a two-stage pipeline: let Pro write the long interpretation, then have Flash compress it into three lines for Slack. I am also testing the Gemini Batch API for processing the previous month in bulk overnight.
The more rows a report grows, the easier it is for time to evaporate into just looking at numbers. Letting the model handle the first reading, and reserving my own attention for deciding what to change — that division feels like the realistic one for a solo operation.
If you also run AdMob on your own, I hope these notes help.