AWS Builder Center
Weekend Showcase Challenge: Reality Check

Weekend Showcase Challenge: Reality Check

AI product audits for ideas, UI, SEO, and market.

DevRel 🥑 | AWS Student Builder Groups Leader | Open Source enthusiast |Ex- AWS SBCL |

The uncomfortable question behind RealityCheck

This summer I built and tested several ideas with AI, and I noticed a pattern: when builders ask whether an idea is good, the answer is usually encouraging. That encouragement feels productive, but it can also send us into another weekend of building features before we challenge the assumptions underneath them.
The expensive question is rarely “Can I build this?” Modern tools make building increasingly possible. The expensive question is: “What must be true for this product to work, and what evidence do I have?”
RealityCheck is my answer. It is an AI product reality-audit platform for founders, students, indie hackers, designers, developers, and small product teams. Its promise is simple: your product’s brutally useful second opinion.
A builder can submit:
  • A product idea
  • A public website
  • UI screenshots
  • Or all of that evidence together
RealityCheck evaluates the problem, audience, market assumptions, differentiation, user experience, conversion clarity, SEO basics, validation evidence, and launch readiness. It produces a concise report with a Reality Score, a verdict, the biggest risk, one immediate next action, severity-ranked findings, assumptions to test, small validation experiments, and a prioritized action plan.
The goal is not to replace the builder’s judgment. It is to make that judgment better before more time and money are committed.

From a fixed demo to a real evidence-based audit

One of the most important improvements during the showcase weekend came from finding an embarrassing flaw in my own product: every audit appeared to score 67 out of 100.
The cause was not Qwen. The application had a seeded HackMate demonstration report with a score of 67, and the live path silently reused that report whenever the AI provider was not configured. The UI looked complete, but the result was not genuinely auditing the submitted product.
I removed that fallback completely.
Today, the 67-point HackMate report exists only as an explicitly labeled synthetic demonstration. A real audit requires a configured Qwen provider. If the provider is missing, the interface explains the exact setup step instead of pretending that a demo score belongs to the user’s product.
I also stopped asking the model to invent the final score. Qwen now rates evidence-based dimensions and explains the rationale for each one. Server code calculates the final Reality Score as a weighted mean based on the selected audit type. For website audits, measurable page evidence is blended into SEO and launch-readiness dimensions. The report shows the formula, evidence-confidence level, and deterministic adjustments, making 67 a possible result—not a predetermined one.

Looking beyond the submitted product

A product cannot be audited in isolation. Its real competition includes direct products, adjacent tools, and the manual workflow people already use instead.
RealityCheck now performs live competitor discovery before asking Qwen for its judgment. It creates focused search queries from the product description, collects public candidate URLs, removes duplicate and obviously irrelevant sources, and inspects a limited number of public pages. Builders can also supply up to five known competitor URLs.
The collected web content is treated as untrusted evidence. Instructions found inside a competitor page are never followed. Qwen only receives the candidate name, source URL, search context, and deterministic page facts. It must omit irrelevant candidates and is explicitly forbidden from inventing market share, revenue, adoption, pricing, or unsupported features.
For every relevant competitor, the report presents:
  • What the competitor appears to do well
  • Where its current positioning leaves space
  • The confidence level of the comparison
  • The public evidence behind it
  • A specific “How you can win” recommendation
This changed RealityCheck from an isolated product critique into a more useful positioning tool. A builder can see not only what is weak, but what could be made meaningfully different.

How I built it

I used Next.js 15, React, TypeScript, Tailwind CSS, Zod, the OpenAI-compatible SDK, and AWS Amplify Gen 2 resources.
The central architectural decision was to separate measurement from interpretation.
Code measures objective website facts: HTTP status, page title, meta description, H1 count, canonical URL, viewport metadata, robots metadata, document language, and visible call-to-action text. Qwen interprets why those facts matter for the submitted audience and goal. The model is not asked to guess whether a title or metadata field exists.
The same boundary applies to competition. Code discovers and inspects public sources; Qwen compares the evidence and proposes positioning opportunities.
The audit output is structured JSON from end to end. Zod validates every dimension, finding, competitor, assumption, experiment, action, limitation, and confidence value before the report reaches the interface. If the provider returns malformed output, the application rejects it instead of rendering an unreliable partial report.
The Qwen integration presented another real production challenge. A large non-streaming audit request reached ModelScope successfully but remained silent while the model generated its full structured response. After several minutes, the upstream gateway returned HTTP 504. A tiny request completed in 2.6 seconds, proving that the key, endpoint, and model were valid.
The fix was to use streaming, which is also the pattern used by the original Qwen example. RealityCheck now receives content incrementally, assembles the final JSON on the server, and validates it only after the stream finishes. I also disabled unnecessary thinking for the structured audit request, reduced excessive output, added a 55-second timeout, and returned specific provider-timeout messages. A temporary provider failure can no longer leave the interface spinning for six minutes.

AWS services and architecture

RealityCheck is deployed as a Next.js server-rendered application on AWS Amplify Hosting. Amplify provides the public deployment, continuous delivery from GitHub, CDN distribution, and managed compute for the Next.js API routes.
The deployed request flow is:
  1. The browser sends the confirmed product brief and optional evidence to a Next.js API route running through Amplify Hosting compute.
  1. Server code inspects the submitted public website and performs focused competitor discovery.
  1. The server sends the compact evidence package to Qwen through ModelScope’s OpenAI-compatible API.
  1. Qwen streams back structured product reasoning and competitor comparisons.
  1. Zod validates the response.
  1. Server code calculates the final weighted score and verdict label.
  1. The browser receives and renders the evidence-backed report.

The repository also contains an Amplify Gen 2 backend schema for Amazon Cognito authentication, AWS AppSync, Amazon DynamoDB, and Amazon S3-backed screenshot metadata and evidence storage. Those resources use owner-scoped authorization. For the current public showcase, the intentionally accessible demo session stores completed reports in the user’s browser, while the schema documents the production persistence boundary rather than pretending that it is already connected.
The AI-provider layer is swappable. ModelScope provides the Qwen integration used for this showcase, while an Amazon Bedrock adapter is included for the next production step. Bedrock plus an Amplify SSR Compute IAM role will remove the need for a long-lived third-party API token and make the AI execution path fully AWS-native.

Product and interface decisions

I wanted the experience to feel skeptical without feeling hostile. The visual system uses calm off-white surfaces, charcoal typography, restrained amber for uncertainty, red-orange for risk, and green only for actions or evidence that genuinely earned it.
The audit is split into four steps:
  1. Choose Idea, Website, UI, or Everything.
  1. Explain the product, audience, stage, and goal.
  1. Add a URL, screenshots, uncertainty, and known competitors.
  1. Confirm RealityCheck’s understanding before running the model.
The final confirmation matters because it prevents an expensive audit based on a misunderstood product. It also shows the live Qwen connection state. Local development instructions refer to  .env.local ; the deployed interface gives Amplify-specific instructions and lets the builder recheck the connection without losing entered details.
The report is designed around decisions rather than decoration. It leads with the biggest risk and the next action. Dimension bars include rationales. Findings separate evidence from interpretation. The competition section links to sources. Every experiment has a hypothesis, method, effort estimate, and measurable success signal.

What I learned across the summer

My biggest lesson is that an AI feature becomes more trustworthy when its boundaries are explicit. Qwen is valuable for reasoning, prioritization, comparison, and explaining why evidence matters. Deterministic code is better for checking page facts, enforcing schemas, calculating reproducible scores, applying timeouts, and refusing unsupported claims.
I also learned that “production-ready AI” is mostly the engineering around the model call. Provider configuration, secret handling, streaming, timeout behavior, URL safety, prompt-injection boundaries, file limits, schema validation, responsive layouts, empty states, and honest error messages determine whether the feature feels real.
Finally, I learned to build around the user’s next decision. A score alone is decorative. A long critique is easy to postpone. A clearly stated risk connected to a small validation experiment can change what someone builds on Monday morning.
That is the outcome I want from RealityCheck: not less ambition, but fewer avoidable assumptions.

Try it

Before I add another feature, RealityCheck will ask the same question it asks its users: what evidence says that is the right thing to build next?
Tag a Builder Who Inspired You (For me it's not only 1 builder but many builders who inspires me)
A big shoutout to  Pawan Joshi ,  Rehan Poonia ,  Monish Reddy  (our youngest AWS Community Builder :) ),  Ritik dhanotiya ,  Manav Pandey ,  Tejasvi Shekhat ,  Achyut Hadwani ,  Karan Vaghela ,  Nisarg Chauhan ,  Tirth Patel  , Manvendra ,  Yash Sathe ,  Harshil Maniyar ,  Jorge  ...and lots of many other people. I met them thanks to AWS Community and I'm always going to be grateful to meet them who keeps inspiring me and keep pushing me even when sometimes things feel too much.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article