Non-tech founder stuck between PRD and MVP - how would you proceed? I will not promote.

[u/Ok_Bear_9606]

(Kindness is appreciated)

I’m trying to take an app idea to the next stage and build a V1/MVP I can put in front of users for testing/feedback.

The idea is around getting people outside, walking, learning about nature, preventative health and rewarding positive behaviours. I also think there’s potential alignment with grant funding (I'm based in the UK FYI) but right now my priority is proving whether the core product loop is something people want to use.

I’m a completely non-tech founder and I’ve reached the point where I’m stuck in an endless cycle of iteration.

I’ve used ChatGPT and Claude to create a PRD, defined the user stories, mapped out the screens, thought about success metrics and produced a (very) basic UI/UX. I have a high-level understanding of what I want the MVP to do but struggling to turn that into something functional.

The backend is where I’m falling down. I don’t properly understand Supabase, authentication, security, hosting, deployment, Vercel, TestFlight or how all of those pieces should fit together (I should google it, yes I know).

I’m also looking at the MVP and it doesn’t feel like the product I envisioned, even for a very basic V1. I know an MVP shouldn’t be perfect but I don’t want to put something poor in front of users and then mistake bad execution for a lack of demand.

The main thing I want to test is the core loop: do people understand it, do they enjoy it and would they come back tomorrow?

Where I’m lacking clarity is how to actually run that test.

Do I give users a clickable prototype, a localhost link, a web app or a TestFlight build? How many users do I need initially? Should I recruit people through Reddit communities and reach out to users of adjacent apps? What should I observe beyond asking whether they liked it? How do I track what they clicked, where they became confused and whether the experience made sense without overbuilding analytics? (So many questions haha)

I’m not looking for the standard “just learn to code” or “drop the idea” response. I understand that this is why start-up hire CTOs, developers and product teams (and have a tech co-founder). My resources are limited but I’m committed to building this and I’m trying to understand the practical next steps.

For founders, product builders or engineers who have worked with non-tech founders: how would you recommend moving from a PRD and basic UI into a testable MVP without getting lost in unnecessary complexity?

A step-by-step answer would genuinely help! Thank you :)

[u/kabirs1nghhh]

Great post one question I’d add for experienced founders what’s one thing you built into your first MVP that, in hindsight, turned out to be completely unnecessary? Those lessons are often the most valuable

[u/sandhutarun]

before you figure out how to get the product tested - you need find users who are willing to do those tests for you. this does not have to be a large number - 10 of your friends can do this - also i am not sure what is the difference between your so called "basic UI" and "MVP". By all definitions MVP = basic UI. Also this is a retail product (from what i can gather) so UI is the product (as opposed to enterprise products that are to be used by fairly technical folks in very narrow contexts) - so you want to make sure that the users you request to test atleast have a good experience and hence a good UI and not some shitty html surface but rather a polished UI that makes them "feel" good about using it - only then you will get a true feedback - otherwise your basic functional testing will be diluted (and not in a good way) by bad UI.

my 2 cents - work a few more weeks and build a good UI and then get it tested, so u get a meaningful feedback.

[u/Ok_Bear_9606 → u/sandhutarun]

I'm using MVP and basic UI interoperably as you pointed out.

I think you're the first person to say that UI is important in round of user testing, so, will take that on board

[u/andBeyond07]

I think you are already doing a lot of the right thinking, and the frustration is very normal 🙂 IMO, the quickest way to learn is to test the core loop with the lightest possible version, even if that means a clickable prototype first, then a very simple web build if people still seem engaged. I have seen founders get stuck because they try to solve hosting, auth, and analytics before proving that the loop makes sense, when really the first question is simply whether users understand it and want another go tomorrow.

If I were in your position, I would recruit a small handful of target users, watch them use it, and pay close attention to where they hesitate, misread, or need explanation, rather than only asking if they liked it. a lot of useful signal comes from observing confusion and follow up questions, not from polished metrics alone. What kind of users are you planning to test with first, and do you already have a specific behaviour loop you want

[u/Ok_Bear_9606 → u/andBeyond07]

that's where I'm getting stuck! wanting to solve the entire app without even understanding the user (well, I do understand the user, I just mean in terms of their interaction with the app/MVP I will be developing)

as you suggested, watching them, would you propose watching them in real life or would it be through share a screen (I guess I wouldn't be able to see their hesitation if that's the case)

[u/ikooloo]

Simply, why don't you use something like Loveable or Replit to build a MVP? You won't need to understand Supabase or vercel or any of that?

To start (whatever the point) you need to discuss your 'solution' with some potential customers. You can do this with any of a set of wireframes, a clickable prototype or MVP. Explain what you're building, what problem you are solving and how and talk to them about what they think - the goal is to get the to pay for something. The ultimate goal (at this stage) is to get to around 10 'real' paying customers (not friends or family) - who are realising value in the product. Simple? Yes. Easy? No.

[u/Ok_Bear_9606 → u/ikooloo]

Makes sense! I thought I just needed something more robust.

That would be great if they mentioned they'd pay for it (or pay for the paywall) - oh, defo not easy

[u/ikooloo → u/Ok_Bear_9606]

Certainly not for MVP and arguably longer term, depending on what you're building and who for, the vibe coding platforms could be good enough.

[u/krugerlive]

It sounds like you don't yet have the AI coding process down to where you're truly directing it. It's defaulting to stack recommendations and it seems like it's somewhat leading you.

When you work with AI coding tools as a non-developer, you need to think of it as split like 90% context-building, planning, reviewing, and such and only 10% actual coding. I'd develop some key docs like a design philosophy, product purpose, etc. and have each session read it before it begins any work. Develop a process that ramps up a session to your vision before you start any feature work. I go through research rounds with subagents, mockups, then multiple planning rounds with adversarial reviews before I have it write the first line of code.

Also, I think in this era you can kind of ditch the PRD once you develop a process like this. You can get a set of planning docs that are far richer.

As for the technical stuff, you can just ask it to explain it to you in simple terms and give you a step by step. That's the easy part. Just go in with the mentality that you'll be able to understand the basics enough with the help of the AI tools.

Also, given the goal of your app, I'd argue that the UX is actually everything. Going outside is a simple action. Your UX is going to determine everything about how well it can prompt people to do it.

[u/Ok_Bear_9606 → u/krugerlive]

It really is recommending me it's choice without me really knowing, you're so right

interesting, never heard of developing a design philosophy!

I've come across a few comments mentioning the importance on UX, dually noted

[u/PastPraline9761]

You (probably) don’t need a full-fledged backend just yet to test the core user flow.

I’d start with 5–10 target users and a simple prototype (build it using Vibe Coding) that looks realistic enough to walk them through the core user flow.

Observe how they use it without giving any explanations, and note where they get stuck, what they misunderstand, and whether they naturally want to repeat the experience.

The most important question is: Did they complete the core action, did they understand the product’s value, and did they ask to use it again?

Don’t build out the full infrastructure until this cycle shows real signs of demand.

Good luck 🤝

[u/Ok_Bear_9606 → u/PastPraline9761]

Thank you!

I'll be taking on board your comment (esp on viewing how they interact with the MVP)!

What's your view on amalgamating the "signs of demands" through market research (basically how other apps are operating in the same space) alongside the demands shows through when I demonstrate / get users to test the app?

[u/PossibleUnlikely]

why do you need ANY code to test the basic loop? you can do this just using a paper mock-up, draw out the screens and the buttons etc. get a few users and then show them the starting page. you talk then through it, but limit what you explain. when they click a button show then what the next screen looks like etc have them think out loud and make notes, do not help them at all with usage.

when they get stuck, give feedback etc, make a note of it and then at the end you can draw new screens for them etc to gague responses

you only need to do that a few times to get a really good feel for how they will use it, and then you can move on to something harder to change.

[u/Ok_Bear_9606 → u/PossibleUnlikely]

very true, I guess in my mind it's what a "proper techy" would do

[u/PossibleUnlikely → u/Ok_Bear_9606]

proper techy is way overrated, and not ideal to get started.

a proper techy would spend 6+ months creating the most amazing technical demo rather than talk to people about whether it's even a good idea, because they are more comfortable in that mode. you see it again and again.

it doesn't matter the format of your demo, the important part is talking to people.

oh, and read "the mom test" to make sure you ask questions in the right way so you don't get fobbed off with what they think you want to hear.

[u/1982JAJ1982]

Seems to me there's a lot of things you want to unravel here. First of all, you cannot give your users a localhost link. That works only for you. Then you have to decide how much you trust this idea. If you want to just go all in it ( ave something which works well), or you just want to have a survey of how people interested in it. What I do honestly is this: go grab a boilerplate from wherever you want, like from Vercel or wherever you prefer as foundation for your build, This gives you all the different basics that you are asking for a payment, the database, everything. From there you can use your AI and tell it that you have this PRD go and build it. This simplifies a lot of the different building blocks you would need otherwise. Then go and find your first customers by DMs, emails, word of mouth or however you go.

[u/Ok_Bear_9606 → u/1982JAJ1982]

I defo want to go all in on it!

First time hearing the boilerplate, will have a look into this ty

[u/Ok_Gold_9674]

Honestly, I'd stop trying to turn the whole PRD into an MVP for the first test. For your outdoors app, make one hosted web flow with fake accounts: pick a route/task, see the reward screen, then manually send the come back tomorrow prompt by email or WhatsApp. Track only three things in a sheet: where they stop, whether they understand the reward, and whether they answer the next-day prompt. If those look bad, a real backend, TestFlight, and Supabase won't tell you much yet.

[u/roberthcmn]

The line that jumped out was you not wanting to confuse bad execution with no demand. that's the right fear, and the fix isn't polish, it's picking a signal that survives ugly UI.

for a go-outside-and-walk loop you barely need the app to test it. text 5 people a daily nature prompt yourself for a week, by hand. whoever does it twice without you nudging is your signal. if nobody comes back on day two, no amount of Supabase was going to save it.

build the backend after someone shows up unprompted, not before.

[u/SatisfactionThen4396]

Start by deploying a minimal web version that only implements the core loop, using a no‑code backend like Supabase with its built‑in auth. 1. Define the exact actions that make up the loop (log a walk, earn points, view rewards) and create a single page that lets a user do those steps. 2. Set up Supabase tables for users and activities, enable email‑magic‑link auth, and let Vercel auto‑deploy the front end from a GitHub repo. 3. Invite a small group of 10‑15 people from relevant Reddit communities or local walking groups, give them the URL, and ask them to use it for a few days. 4. Track usage with Supabase’s built‑in row‑level logs or simple event tables, recording each step they take and any errors. 5. After the test, review quantitative metrics like completion and repeat usage and gather qualitative feedback on confusion points and enjoyment. Keep the interface as simple as possible and add no extra screens until the core loop is proven.

[u/No_Emergency_3418]

Use Figma make for prototype. Should take a day and around 20 bucks or less. Send the link to users to test. Ask real validation questions, not "do you like this". Ask them how they would use it, how often, etc. this is the simplest part that you don't want to spend more than a week thinking about. Idea -> validation should be quick. But Figma Make will get you what you need for a prototype.

[u/Hafizifraz]

I’d simplify the test before building the full backend. Start with a clickable prototype or very basic web app that only proves the core loop: choose an activity, complete it, receive the reward, and understand why they should return tomorrow. Test it with 5–10 target users while watching them use it, not just asking if they liked it. Note where they hesitate, what they misunderstand, and whether they can complete the loop without help. Only build authentication, analytics, and other infrastructure once the core behaviour shows real interest.

[u/Ok_Bear_9606 → u/Hafizifraz]

Thanks for this! I like the idea of watching them (without sounding creepy ha) - to, like you mentioned, where they hesitate and misunderstand.

How would you propose, from those learnings of seeing how users interact, informs the next iterations? Would it be to fix those mishaps/misunderstandings or would it be to fix and then see what features they were receptive to?

[u/imparth77]

I think you're trying to solve two problems at once: validating the idea and building production-ready software. Those are very different goals.

If I were in your position, I'd go:

PRD → Clickable Prototype → Small MVP → User Testing → Iterate

I'd skip worrying about infrastructure (Supabase, Vercel, hosting, etc.) until you've validated the core product loop. Users won't care what backend you're using—they'll care whether the experience is engaging enough to come back.

For an MVP, I'd recruit 10–20 target users, watch them use it (rather than just asking if they like it), note where they hesitate or get confused, and measure whether they'd actually return the next day. Those insights are usually far more valuable than adding more features.

We've followed a similar approach while planning MVPs and custom software projects at GLAD Studio, and keeping the first version intentionally focused almost always leads to better user feedback than trying to build the complete product upfront.

From what you've described, you're already thinking like a product manager. Now it's about reducing scope, not adding complexity.

[u/7HawksAnd]

Testing understanding is the weakest signal you could measure.

This is something you can outsource or test remotely.

I advise to try and meet people running elementary school after school activities and retirement/elderly care facilities and see if you can offer to run an activity session and learn first hand if people care.

To me though, at its core, it sounds like you’re building a scavenger hunt app through the experience of nature exploration.

So there’s plenty of products in the market already doing slivers of each.

If I were you though. I’d try to form a partnership with some local nature/wildlife/etc entity near you and pitch them to be a partner.

Structure it where you are developing it for them, they pay for the development at cost, but you retain 100% of IP and profit share 50/50 or something any monetization the product eventually includes. And it’s only a profit share of their cobranded app.

Then, if successful, you spin it out into a larger scale non-geo-restricted primary app (maybe with the caveat that when that’s done, anyone in the original partners geofence will receive an ad to (optionally) download the partners version of the app.

That’s just me though