5Gauge

Turn your App Store and Google Play apps reviews into AI-powered product intelligence: detect emerging issues, analyze trends, and send GitHub issues to your team. Manage your reviews with AI.

Comment

Inspiration

I am a solo entrepreneur managing several mobile applications. App Store and Google Play reviews are one of the clearest sources of product feedback, but they are fragmented across applications, stores, countries, languages, versions, and devices.

The same underlying defect can appear in many forms:

  • “The app closes when I return to it.”
  • “It crashes after being restored from the background.”
  • “After switching back from another app, it no longer works.”

Reading those reviews individually makes it difficult to see that they describe one growing problem. Most review-management products focus on ratings and reply generation. I wanted to build something different: a workspace that turns reviews into evidence-backed product decisions.

I registered for Build Week on July 16 at 22:49 local time in Poland, only a few days before the deadline. I first discussed the product direction in ChatGPT, then wrote an authoritative product brief and used Codex with GPT-5.6 to turn it into a working system.

What it does

5Gauge is a review-intelligence workspace for mobile product teams.

Its central workflow is:

Reviews → recurring issue → evidence and priority → supervised task, report, or reply

5Gauge provides:

  • A unified App Store and Google Play review inbox across multiple applications
  • Search across original and translated review text
  • Filters for application, store, rating, language, version, date, reply state, and detected issue
  • Issue Radar for recurring bugs, complaints, support problems, and feature requests
  • Evidence-backed issue details with affected versions, devices, operating systems, countries, and representative reviews
  • Transparent severity based on seven separately stored components
  • Issue lifecycle management with history, recurrence, regression reopening, and manual corrections
  • Supervised review-reply drafting
  • Grounded task and evidence-report generation
  • Markdown and PDF export
  • Human-reviewed GitHub issue drafts and production GitHub App publication controls
  • Official App Store Connect and Google Play adapters
  • Durable synchronization, analysis, retry, and publication jobs

The public demo requires no external credentials. Every sign-in creates a private 24-hour PostgreSQL-backed sandbox containing 8 applications, 118 multilingual synthetic reviews, and 15 recurring issues.

What makes it different

5Gauge is not primarily a reply generator. Its purpose is to reveal product problems that are difficult to see when reviews are handled individually.

AI is deliberately constrained. It can interpret language, identify product signals, compare candidate themes, and draft grounded explanations. Deterministic application code remains responsible for scope, trend, severity, recurrence, and ranking.

Every model-derived result retains provenance and is visibly distinguished from original, translated, deterministic, or simulated content. Users can correct issue assignments, mark reviews as non-issues, create manual issues, and keep those decisions authoritative until automatic analysis is explicitly restored.

External effects are also supervised. Replies and GitHub issues require human review and exact-body approval. Demo actions are visibly simulated, while production actions use immutable approval snapshots, audit records, retries, and duplicate reconciliation.

How I built it

The application uses Next.js, React, TypeScript, PostgreSQL, Drizzle ORM, Better Auth, Zod, and the OpenAI Responses API. Local zero-configuration development uses file-backed PGlite, while production uses standard PostgreSQL.

The production system includes:

  • Workspace-scoped authorization and database constraints
  • Google and GitHub social identity
  • Versioned AES-256-GCM encryption for write-only integration credentials
  • Official Apple and Google review-provider adapters
  • Strict structured OpenAI output with validation and one bounded repair attempt
  • Durable PostgreSQL jobs with leases, retries, and recovery
  • A deployment-owned GitHub App with verified installations and immutable publication snapshots
  • More than 300 automated tests covering domain logic, UI behavior, migrations, tenant isolation, credentials, providers, and job recovery

I collaborated with Codex running GPT-5.6 throughout implementation. I made the product and risk decisions; Codex translated them into vertical slices, implemented them across the stack, ran tests and production builds, inspected the application in the browser, diagnosed failures, and added regression coverage.

Codex was particularly valuable when a problem crossed several layers. Examples included notification state reverting after navigation, development pages rendering without hydration over a LAN URL, PGlite entering the production server bundle, false issue groups caused by insufficient context, stale approvals, and ambiguous external-write retries.

Challenges

Separating similar language from the same underlying problem

Shared keywords are not enough. Two reviews can mention “crash” while describing unrelated failures. 5Gauge combines atomic signal extraction, application-specific semantic shortlisting, strict candidate comparison, corroboration requirements, and manual correction controls.

Keeping AI useful without making it authoritative

The model is good at interpreting language but should not silently determine business priority. I separated semantic judgment from deterministic severity and lifecycle rules, validated every structured output, retained provenance, and exposed uncertainty.

Supporting a zero-credential demo and credible production architecture

Judges need immediate access, but a real product must protect customer evidence and provider credentials. Demo and production therefore share the same PostgreSQL-backed repository and product workflow, while demo external effects are safely simulated.

Building safely under a compressed deadline

As a solo entrepreneur, I could define the customer problem and make the product decisions, but implementing and testing the complete system across authentication, databases, provider APIs, AI, jobs, security, and responsive design would not have been possible in the available time without Codex.

What I learned

I learned that AI-assisted development works best when the human supplies clear product principles and non-negotiable boundaries.

The most effective pattern was:

  1. Define one coherent vertical slice.
  2. Let Codex implement and verify it.
  3. Exercise the real behavior.
  4. Feed failures and product observations back into the next iteration.
  5. Add regression coverage before expanding scope.

I also learned that trustworthy AI products need visible provenance, deterministic authority for measurable facts, human correction, and honest simulation boundaries—not simply more model calls.

What's next

The complete review-to-action MVP is implemented and operator-tested. Remaining work is primarily release operations: final provider smoke tests, worker monitoring, backup and restore rehearsal, and optional external-write failure drills.

Post-MVP product work includes team invitations and roles, outbound notifications, billing, account export and deletion, 2FA management, and two-way GitHub synchronization.

Built With

Share this project:

Updates