Google Product 360

Collects all product related data from Google API's and combine information presenting Product 360, final intention is to connect it to central warehouse and marketplaces and become ecommerce tool.

Comment

Inspiration

Google Product 360 - product information is distributed across several APIs and Google interfaces. For a small ecommerce business, diagnosing one failing product often means moving between feeds, product status, account issues, and related reports. My wife runs a small ecommerce business, so I wanted to build a practical tool that brings this information together. Google Product 360 is designed to make every product failure understandable, actionable, and auditable.

What it does

Google Product 360 is a self-hosted workspace for managing Merchant Center products. It provides:

  • Google OAuth sign-in and a guided setup wizard.
  • Merchant Center product and issue synchronization.
  • A product grid with status, feed, price, availability, and issue summaries.
  • Clear separation between predictable issues and complex issues.
  • Explainable Quick Fix actions for safe, supported corrections.
  • Detailed product views showing evidence, consequences, and available actions.
  • Background operations that continue after the browser is closed.
  • Read-only activity and audit traces for every operation.
  • A clearly labelled synthetic demo mode for safe evaluation.

The public demo is available at:

https://gmc.connect-the-dots.biz/

How I built it

The application is written in TypeScript end-to-end.

  • Node.js 22 and Fastify power the server.
  • React and Vite power the client.
  • SQLite uses Node’s built-in node:sqlite support.
  • Google OAuth is used for operator authentication.
  • Service-account credentials are protected server-side for background API work.
  • Merchant API and Search Console integrations are isolated behind adapter interfaces.
  • Demo mode uses synthetic data through the same product and operation flows as live mode.
  • Durable operations and append-only event traces allow the UI to recover the current state after a restart or closed browser.
  • AI was used as a development partner for specification, implementation, design review, testing, and refinement.

Challenges I ran into

The main challenge was understanding the boundaries between Google’s different APIs and interfaces. Not every issue shown by Merchant Center can be resolved programmatically, so the application must clearly distinguish between supported actions and issues that require external intervention. Another challenge was asynchronous processing. A correction submitted to Google may not be reflected immediately. Product 360 therefore treats operations as durable background jobs, monitors them for an initial response window, and keeps them visible as pending when Google is still processing. Security was also important. The application must not expose service-account credentials or OAuth tokens to the browser, and the setup flow must stop before synchronization if required checks fail. Finally, I needed a reliable demo that does not require reviewers to connect a real Merchant Center account. Demo mode follows the same user journey while clearly identifying all data as synthetic.

Accomplishments that I'm proud of

  • Built a working product-focused Merchant Center experience instead of another generic dashboard.
  • Created a setup wizard with blocking validation and no partial synchronization.
  • Implemented product-level and account-level issue handling.
  • Added explainable remediation with durable operation state.
  • Added a read-only audit trail that records the full action path.
  • Built a demo mode that is safe, repeatable, and publicly accessible.
  • Kept the architecture ready for live Google API integrations and future AI assistance.
  • Completed automated validation with 113 passing tests and production builds.

What I learned

I learned that successful API integration requires understanding not only the endpoints, but also the operational boundaries, permissions, processing delays, and failure modes around them. I also learned that background operations should be modelled as durable server-side state rather than as temporary browser activity. Specification-driven development helped me make the core journey smaller and safer. Instead of attempting to replace Merchant Center, I focused on one valuable loop: find a product problem, explain it, suggest an action, apply it safely, and preserve the complete history.

What's next for Google Product 360

The next steps are:

  • Marktplace and warehouse integration for offers management and automation.
  • Ecommerce integration for information completness.
  • Complete broader live Merchant API synchronization.
  • Add Google push notification reconciliation.
  • Expand supported remediation actions.
  • Add more persistent remediation patterns and batch workflows.
  • Add Market Insights, performance reports, price benchmarks, competitor visibility, and Search Console analytics.
  • Introduce a guarded AI advisor for pattern discovery and explanation.
  • Expand the visual workflow builder with scheduled and event-driven automation.
  • Support multiple Merchant Center accounts and more generic ecommerce integrations.
  • Explore a hosted or multi-tenant version for other merchants and agencies.

Built With

Share this project:

Updates

Submission history