Main/home dashboard introducing Startup Sandbox.
Founder — Post a Test (chat). Guided flow helps a founder turn what they’re building into a structured test.
Completed/review test brief showing target testers, tasks, reward, deadline, etc.
Founder matched-testers page showing ranked testers / recommended experts.

Inspiration

Early-stage founders need feedback before they invest months building their product. But finding testers isn't always the hardest part. Finding the right testers is.

We spoke with founders and builders who described looking for users through conferences, meetups, personal networks, targeted communities, and in-person events. Some were looking for very specific audiences or subject-matter expertise. That reinforced the problem we wanted to explore:

How can we help founders reach relevant early users faster and turn their feedback into something actionable?

That became Startup Sandbox, our answer to the Houston Hackathon's Startup Sandbox challenge.

Our goal is simple:

Stop guessing. Start validating, with the right people.

What it does

Startup Sandbox is a Houston-focused platform that connects early-stage founders with relevant local people who can test their products.

Founders create a test by chatting with an AI assistant or filling out a form: they describe their product, the audience they need, and the real tasks testers should complete. Tests can be funded with a cash pool, swag, or points, so under-resourced founders can still post tests for free.

Testers create profiles based on their interests, experiences, location, devices, and other relevant attributes. Startup Sandbox uses that structured information to generate an explainable match between a test and a potential tester.

For example, a tester who writes "I'm a night-shift nurse, new dad, and I run the Buffalo Bayou trail on weekends" is turned into tags like new parent, night shifts, nursing, and trail running. Those place them in the Parents, Healthcare workers, and Fitness enthusiasts categories and immediately match them to live tests.

Instead of treating the match score as a prediction, we use it as a transparent way to answer:

"How closely does this tester fit what this founder is looking for?"

Every match shows its reasoning: which of the founder's criteria the tester meets, how many points each is worth, and how that adds up to the match percentage and tier (from "Crazy Match" to "Poor Match").

Highly relevant testers (60% or higher) can join directly, while lower matches can still apply with a short note and let the founder make the final decision.

Once enrolled, testers complete the founder's tasks and submit structured feedback about their experience, usefulness, willingness to pay, likelihood to recommend, and anything confusing or missing. Founders rate each response, and higher-rated feedback earns a larger share of the reward pool.

We also introduced organizations and local communities into the model. Organizations can bring their members into Startup Sandbox, host events, and help founders reach more specialized groups. Organizations work as a community fundraising model: when members complete paid tests, most of the cash reward goes to their group's cause, while testers who join on their own keep 100%. Our categories include Houston's multilingual and diaspora communities, so founders building for those audiences can reach them directly, and those communities can benefit from the products being built for them.

How we built it

We built Startup Sandbox as a full-stack application with a shared React frontend and two backends.

The frontend is built with React, while the deployed application uses Ruby on Rails and PostgreSQL on Render. We also maintain an in-page backend used by the Claude Artifact version of the project so we can rapidly prototype and test the same product flows. A parity test runs the same scenario against both backends and requires identical results.

Our matching system is intentionally rule-based and explainable rather than a black-box machine learning model.

Founder requirements and tester profiles are converted into structured attributes drawn from a taxonomy of 60 audience categories. Matching considers signals such as audience categories, interests, location, age, device requirements, expertise, and tester level. Each signal carries a weight, and together they produce a match score and match tier, while the interface shows users why a match occurred.

We use AI (Gemini on the deployed Rails app, Claude in the artifact version) to turn natural-language onboarding conversations into structured information the application can use. Every AI answer is filtered against our taxonomy, so the AI can't invent categories or tags. AI assists with understanding and organizing user input; the actual matching logic remains deterministic and inspectable. If AI is unavailable, the app falls back to guided questions and keyword matching.

The core workflow we built is:

Founder creates a test → relevant testers are matched → tester participates → tester completes tasks → structured feedback returns to the founder.

We expanded that workflow with organization onboarding and verification, rewards, events, RSVP management, and event attendee check-in.

Challenges we ran into

One of our biggest challenges was scope.

A two-sided marketplace quickly becomes much larger than "match founders with testers." We had to think about onboarding, trust, incentives, organizations, matching quality, applications, rewards, events, and what happens after someone actually agrees to test a product.

We repeatedly had to ask ourselves:

What is necessary to prove the core loop, and what can wait?

Matching presented another challenge. A percentage can easily look like a probability or an AI-generated confidence score, even when it isn't. We wanted our matches to remain understandable, so we focused on structured criteria, weighted rules, match tiers, and visible reasons behind the score.

We also encountered the normal challenges of building quickly as a team: keeping multiple implementations aligned, coordinating changes across teammates through pull requests, testing edge cases, tracing behavior across the frontend and backend, and making sure the UI accurately represented the underlying business rules.

Customer discovery

The hackathon also changed how we thought about the problem.

Our initial hypothesis was that founders struggle to find testers. Conversations with founders gave us a more specific question to investigate: how difficult is it to find the right testers?

We heard examples of founders using conferences, meetups, community outreach, personal networks, and targeted in-person events to reach potential users. Some needed access to particular communities or subject-matter experts rather than a generic pool of people.

Those conversations provided early qualitative support for the problem, but they also exposed the other half of the marketplace: why will testers participate and keep coming back?

Potential users expressed interest in trying the platform, and incentives such as cash, points, community participation, and other rewards are part of what we're exploring. But questions such as long-term tester retention, sustainable incentives, and whether community partnerships can become a repeatable acquisition channel still need real-world validation.

Accomplishments that we're proud of

We are proud of building and testing the core loop end-to-end:

Founder creates a test → relevant testers are matched → tester joins → completes real tasks → submits structured feedback → founder receives the results.

Some of the accomplishments we're especially proud of include:

Building an explainable matching system instead of treating matching as a black-box AI prediction.
Showing users exactly why they matched, criterion by criterion.
Creating multi-role accounts that support founders, testers, and organizations.
Turning natural-language onboarding into structured data that can be used by the application.
Supporting match tiers and different flows for stronger and weaker matches while keeping the founder involved in the final decision.
Building structured product-testing tasks and feedback instead of collecting only generic comments.
Adding organizations as a way to explore community-based tester acquisition.
Building organization verification, invitations, events, RSVPs, capacity handling, and attendee check-in.
Implementing rewards including points, swag, and pooled cash incentives.
Maintaining the shared product experience across our React frontend, in-page prototype backend, and deployed Rails/PostgreSQL application.
Testing the product as actual users rather than only testing individual screens.

We're also proud that we got out of the code and talked to founders. Those conversations challenged some of our assumptions and gave us concrete questions to validate after the hackathon.

For a project built under hackathon time constraints, getting the entire founder-to-feedback loop working while continuing to test and revise the product was a major accomplishment for our team.

What we learned

The biggest lesson was that building the technology is only part of building the product.

We learned to distinguish between an assumption, an early customer signal, and something we've actually validated.

We also learned that matching shouldn't remove human judgment. The system can surface relevant people and explain why they match, but founders still need control over who participates.

Technically, we learned how to combine conversational AI with structured application logic, maintain matching behavior across different backends, test complete user journeys, and build a multi-role product under a tight deadline.

Most importantly, talking with actual founders changed the questions we were asking.

Instead of only asking:

"Can we build a platform that matches founders and testers?"

we're now asking:

"Can we measurably reduce the time and effort it takes founders to find relevant early users, while creating enough value for testers and communities to keep participating?"

What's next for Startup Sandbox

AI-guided tester onboarding: testers describe their life and frustrations in their own words, and the AI builds their profile, the same way founders and organizations already onboard.
Readiness signals: willingness to do interviews or in-person sessions, short-notice availability, and feedback style, scored only when a founder asks for them.
Founder dealbreakers: let founders say who is not a fit.
Tester-chosen community share: today, members who join through an organization send 80% of cash rewards to that group; we want testers to choose their split.
Real payments through Stripe Connect and real email verification for organizations.
First partners: Houston accelerators, coworking hubs, university clubs, and community groups as the first organizations.

Try it: https://startup-sandbox.onrender.com (demo accounts use the password demo1234; the first load can take about a minute while the free server wakes up).

Built With

Submitted to

Houston Hackathon 2026

Created by

I helped validate Startup Sandbox's matching experience, and contributed heavily to product testing and customer discovery. I made decisions like making match scores explainable, showing founders and testers what matched and what didn't and contributed to product decisions around founder approval, tester access, capacity limits, and keeping human choice in the matching process.
I tested the founder, tester, organization, matching and feedback flows on the deployed application, including verifying the complete founder → match → tester → feedback loop. During organization testing, I traced a verification difference through the React component, route and Rails controller to identify why the deployed Rails version behaved differently from the Artifact version. I also researched deployment options and helped the team work through moving from the Artifact toward a publicly accessible Rails deployment.
For engineering contribution, I implemented event attendee check-in across the frontend and Rails/local backend after the Events flow was proposed, including host authorization, timing rules, RSVP-scoped check-in and the database migration, and then tested the flow.
I also took Startup Sandbox into the Houston community for customer discovery, interviewed founders/builders about how they currently find early users. I brought those findings back to the team and helped incorporate them into our problem framing and product story, giving us early real-world evidence for the problem we were trying to solve.

Sara Rauf
I designed the matching system at the core of Startup Sandbox: the taxonomy of 60 categories and 724 tags ("categories are who you are, tags are what you're into"), the weighted match scoring, the match tiers from Poor to Crazy Match, the rule that 60% or higher joins directly and anything below applies, and the tester, founder, and organization onboarding questions. I also drafted our original database schema.

On the code side, I shipped 15+ merged pull requests, built with Claude Code: the AI tester onboarding chat, the "Why X% match quality?" breakdown for testers and founders, the Account page and profile setup, password field fixes, honest payout wording, switching our default AI to Gemini Flash Lite, a fix so Rails respects tester exclusions, the demo dataset (11 more founders and tests, 9 fictional organizations, and applicants), and a fix for a broken live deploy.

This was my first group coding project, and I learned a lot about Git, pull requests, and keeping two backends in sync.

Marrz Lundquist
Started and built the project: set up the repository and wrote the foundation, about 85% of the application code, across both the Rails app and the Claude artifact version.
Defined the product: turned the original prototype and our category and tag data into the full product plan, and made the key product decisions along the way, including the organization-first payout split, verification before organizations go live, and AI-assisted onboarding.
Designed the organization partnership model: the plan to work with community organizations so they bring their members in as testers.
Designed the rewards system: pooling money from each test's founder to the testers who take part, and how swag is distributed.
Designed the event pages: meet-and-greets hosted by founders and organizations.
Chose and defended the technical direction: picked Ruby on Rails, set up the two-version approach so the team could test instantly on the Claude artifact, and kept both in sync with automated tests.
Integrated Claude and Gemini for the app's AI features, and handled environment keys and secrets.
Deployed it: set up hosting on Render, with PostgreSQL.
Led the team's integration: reviewed and merged the first pull requests, and resolved merge conflicts on teammates' branches while keeping their work.
Kept the team aligned: explained the stack and design choices, and supported teammates with setup (API keys, Rails, the Claude artifact).

Uchenna F. Okoye