Indie Growth Agent

Turn App Store, GA4, and AdMob data into grounded, prioritized actions for indie developers.

Comment

Inspiration

I am an indie developer who publishes and maintains multiple apps on the App Store.

To improve my apps, I regularly check App Store Connect to understand whether people are discovering them, Google Analytics 4 to understand how they are being used, and Google AdMob to understand how they are monetizing.

Looking at each source individually is not the difficult part.

The difficult part is combining those signals and deciding what I should do next.

Is the biggest problem discoverability in the App Store? Is something changing in how people use the app? Should I focus on monetization instead? With limited development time, deciding where to start means moving between multiple dashboards, comparing different metrics, and interpreting them together.

I wanted an agent that could do that work with me: read the data across App Store Connect, GA4, and AdMob, then turn it into a short, prioritized list of what to investigate or improve next.

That became Indie Growth Agent.

3 data sources → 1 priority list.

What it does

Indie Growth Agent connects to three real data sources:

  • App Store Connect Analytics
  • Google Analytics 4
  • Google AdMob

It compares the latest reporting period with the previous period, identifies meaningful changes, and uses an AI agent to recommend the Top 3 next actions in priority order.

But the goal is not simply to summarize dashboards.

Before generating recommendations, the system applies grounding rules designed to prevent misleading conclusions:

  • Missing data is not treated as zero
  • Facts are separated from speculation
  • Populations from different data sources are not treated as one funnel
  • Recommendations must be grounded in observed data
  • Causality is not claimed when the data only shows correlation

The result is designed to answer one practical question:

“What should I do next?”

How we built it

The AI agent is built with the Strands Agents SDK and uses a foundation model through Amazon Bedrock.

The production flow is:

  1. A static Next.js web interface is hosted with AWS Amplify Hosting.
  2. The browser calls a FastAPI backend running on Amazon ECS Express Mode / AWS Fargate.
  3. The backend retrieves real data from App Store Connect, Google Analytics 4, and Google AdMob.
  4. The data is normalized into an analysis context that preserves reporting periods, population scope, missing-data handling, and event definitions.
  5. The Strands agent receives this grounded context and invokes the model through Amazon Bedrock.
  6. The agent returns confirmed facts, clearly labeled speculation, and three prioritized next actions.
  7. The results are displayed in either Japanese or English.

The backend container image is stored in Amazon ECR, and external API credentials are managed with AWS Secrets Manager.

AWS IAM roles allow the running ECS task to access AWS services such as Amazon Bedrock without embedding long-lived AWS access keys in the application.

Challenges we ran into

The hardest part was not calling an LLM.

It was preventing the agent from confidently inventing relationships that the underlying analytics data could not actually prove.

App Store Connect, GA4, and AdMob measure different populations. A GA4 event count cannot simply be divided by an App Store metric to create a funnel. Missing data also cannot safely be interpreted as zero.

We therefore built explicit grounding rules around the agent and kept Facts and Speculation separate in both the analysis and the UI.

We also encountered a real data freshness issue during development. A limit in our App Store Connect retrieval logic caused older records to be included while newer processed records were excluded. Once we corrected the retrieval logic, the observed trends changed significantly.

That was an important lesson: before grounding an AI model, the data being used to ground it must itself be correct and current.

Deployment introduced another challenge. Fetching multiple external data sources and running the agent analysis can take around two to three minutes, so the production infrastructure had to support longer-running analysis requests.

Accomplishments that we're proud of

The MVP works end-to-end using real production data from one of my published apps — not mock analytics data.

A developer can open the deployed web app, click Analyze latest data, and receive recommendations generated from current App Store Connect, GA4, and AdMob data.

We are especially proud that the interface does not present every AI-generated statement as a fact.

Alongside the prioritized actions, it explicitly shows:

  • Facts — what the connected data confirms
  • Speculation — possible interpretations that the data does not prove
  • Data Scope — what population each source represents
  • Analysis Rules — the grounding constraints used by the agent

The goal is not to make the AI sound certain.

The goal is to make its recommendations useful without hiding uncertainty.

What we learned

One of the biggest lessons was that giving an LLM more data is not the same as giving it better context.

Reporting periods, population scope, event definitions, missing values, and the distinction between correlation and causation all matter.

Without those constraints, an AI-generated recommendation can sound convincing while being based on an invalid comparison.

We also learned that an agent becomes more useful when it is designed around a decision, rather than around producing more analysis.

Indie developers already have dashboards.

What we often need is help deciding where to spend our limited time next.

That is why Indie Growth Agent is designed to produce a short priority list rather than another large analytics report.

What's next for Indie Growth Agent

Next, we want to expand the same grounded analysis approach to:

  • Google Play / Android
  • Multiple app selection
  • App Store reviews
  • In-app purchases and subscriptions
  • RevenueCat

A longer-term goal is portfolio-level analysis across multiple apps.

Instead of only asking:

“What should I improve in this app?”

the agent could eventually help an indie developer answer:

“Which of my apps deserves my limited development time next?”

The broader vision is to connect:

Acquisition → Usage → Feedback → Revenue → Prioritized Action

and turn fragmented app data into practical decisions for indie developers.

Built With

Share this project:

Updates

Submission history