Blog · Guides · 2026-11-11

Figma Make Testing: How to QA Your Prompt-Built App

TL;DRFigma Make produces working code, not a clickable mock, so test the layers a prompt never described: auth and data boundaries, server-side validation, and what happens when a request fails. Test in order of blast radius, not in screen order. And because re-prompting can rewrite the code that carried an earlier fix, a fix is only as durable as the automated check guarding it.

Figma Make testing means verifying the app behind the prototype, not the pixels in front of it. Start with the layers a prompt cannot see: auth and data boundaries, validation that runs on the server rather than in the browser, and what the app does when something fails — empty results, an expired session, a double-tapped submit button. Then walk the two or three flows that actually earn money or sign-ups, on a real phone, with deliberately bad input. A Figma Make app looks finished long before it behaves correctly, because the tool is optimising for a screen that renders. The gap between "it renders" and "it holds up" is where every bug your users find already lives.

Why is Figma Make testing different from design review?

Figma Make turns a prompt — or an existing Figma frame — into a running web app you keep shaping by chatting with it, and gives you a link you can publish and share. The output is working code, not a clickable mock. That single fact changes your obligations: the moment a published link exists, someone can type into your forms, paste an emoji into a name field, open it on a cracked Android phone, and hit refresh halfway through a submit.

Design review and QA ask different questions, and teams get into trouble when they do the first and assume it covered the second.

QuestionDesign reviewQA pass
What is being judgedThe screen you were shownThe states you were not shown
Typical inputRealistic placeholder contentEmpty, enormous, duplicated, malicious
Who is assumedOne signed-in, well-behaved userA logged-out visitor, a second tenant, a bot
Definition of doneIt looks rightIt fails safely and recovers

This is the same discipline we lay out in the complete guide to AI QA — the difference with prompt-built apps is only how quickly you reach the point of needing it.

What should you test first in a Figma Make app?

Test in order of blast radius, not in the order the screens appear. If you only get through the first three, you have still removed the failures that are expensive to discover later.

  1. Auth and data boundaries. Open the published link in a private window while signed out. Can you reach a page or an API response that should require a login? If the app stores records per user or per client, sign in as a second account and confirm you cannot see or edit the first one's data. Permissive read access is the single most consequential defect class in generated apps, and it is invisible from the UI.
  2. Server-side validation. Browser-side checks are a convenience, not a control. Submit a form with the required attributes stripped, or with values no front end would send — a negative quantity, a 500-character name, a malformed email. If it saves, the rule only ever existed in the markup.
  3. Destructive and irreversible actions. Delete, cancel, refund, send. Confirm each one is intentional, scoped to the right record, and idempotent — click submit twice, fast, and check you did not create two of something or charge twice.
  4. Failure and empty states. Throttle the network to a slow connection and reload. A generated app frequently treats an error as nothing-to-show, so a broken request renders as a tidy empty list and no one notices for a week.
  5. Mobile at real widths. Not the canvas preview — an actual device or an emulated 375px viewport. Check sticky headers, keyboard overlap on inputs, tap targets, and anything in a modal.
  6. The one flow that matters end to end. Signup, checkout, or booking, completed for real, including the email or confirmation that is supposed to arrive afterwards.

Which bugs show up most often in prompt-built apps?

These patterns recur because of how the code gets written, not because any one tool is careless. A model generates what satisfies the request it was given; the request rarely mentions the second tenant or the failed network call.

Bug classWhy prompt-built apps get itFastest way to catch it
Client-only validationThe visible form was the specified artefactSubmit values the UI would never send
Over-permissive data accessNothing in the prompt described who must not see a rowTwo accounts, side by side, in two windows
Swallowed errorsError handling was not asked for, so failures return quietlyThrottle or block a request and watch the console
Re-prompt regressionsA later instruction rewrites code that carried an earlier fixAn automated check on the flow you already fixed
Placeholder content shipped liveSample copy was convincing enough to stop looking atSearch the published page for dummy names and lorem text

The fourth row is the one specific to iterating by prompt, and it is worth dwelling on: in a prompt-driven tool, a fix is only as durable as the test that guards it. You can correct a bug on Monday, ask for an unrelated layout change on Thursday, and get the bug back — with no diff you were watching and no reason to re-check that screen. Manual verification does not survive regeneration. A check that runs on every version does.

How do you QA a Figma Make app without a QA team?

Most people shipping from Figma Make are a designer, a founder, or a one-person agency — there is no QA function to hand this to. The workable substitute is three passes, each cheap enough to actually repeat.

1. A persona pass, before you share the link

Have the app walked by users who are not you: someone signed out, someone on a phone, someone who abandons a form halfway and comes back. This is what Sims automates — AI personas that exercise your flows the way awkward real people do, rather than the way the builder demonstrates them.

2. A capture pass, for everything a reviewer finds

When a client or a friend reports "the booking thing broke", you need the console errors, the failed request, the browser, and the exact DOM state — not a cropped screenshot. Snap turns a right-click into a report carrying that evidence, which is the difference between fixing it in one pass and three rounds of "cannot reproduce".

3. A guard pass, so re-prompting cannot undo your work

Put an automated end-to-end check on the two or three flows you cannot afford to break. AutoSim heals the selectors when a regenerated UI moves them, which matters here specifically: in a prompt-built app the markup is rewritten often, and brittle tests that fail on every change get switched off within a fortnight.

When should you stop prompting and export the code?

Iterating by chat is genuinely faster, right up until it isn't. Treat these as the signals to move the project into a normal codebase with a developer and a staging environment:

  • The same bug comes back twice. You are now fighting regeneration, not the bug.
  • You need a change you cannot describe precisely. "Make the permissions correct" is not a specification; a schema and a policy are.
  • Real money, real customer data, or anything regulated is involved. Those need review, logging, and a rollback path.
  • You want to test before you publish. A separate environment is the prerequisite for every other QA practice.

If you reach that point, our walkthrough on handing a vibe-coded app to developers covers what to package up. The same priority order applies to any prompt-to-app tool, so the checklists in how to QA a vibe-coded app and Lovable app testing transfer directly.

What does a 30-minute pre-share QA pass look like?

Do this before the link leaves your hands, every time you publish:

  • Open the published URL signed out, in a private window. Note anything reachable that shouldn't be.
  • Sign in as two different accounts and attempt to cross the boundary between them.
  • Submit every form empty, then with absurd input, then twice in a row quickly.
  • Reload on a throttled connection and watch for silent failures in the console.
  • Run the primary flow to completion on a real phone, including whatever email or confirmation follows.
  • Grep the live page for placeholder names, test emails, and lorem text.

None of this requires a QA background. It requires deciding that "it rendered" is not the same claim as "it works" — and then spending half an hour on the difference before a client does it for you.

Try it on your next Figma Make build

Klavity is built for exactly this gap: AI personas that walk your flows, right-click bug reports with real evidence attached, and E2E checks that survive a regenerated UI. Try Klavity free and run a QA pass on your next prompt-built app before you share the link.

Key takeaways

  • Test signed out and as a second account before anything else.
  • Re-submit every form with values the UI would never send.
  • Throttle the network — generated apps render errors as empty states.
  • Guard fixed flows with automated checks that survive re-prompting.

FAQ

Does a Figma Make app need real testing, or is design review enough?

Design review judges the screen you were shown; QA judges the states you were not shown. Figma Make publishes working code behind a shareable link, so once that link exists people can submit empty forms, open it signed out, and reload mid-submit. Those paths need checking explicitly.

What should I test first in a Figma Make app?

Auth and data boundaries first: open the published link signed out and see what is reachable, then sign in as two accounts and try to cross between them. Next, server-side validation, then destructive actions, then failure and empty states, then mobile at a real 375px width.

Why do bugs come back after I fix them in Figma Make?

Iterating by prompt means later instructions can rewrite code that carried an earlier fix, with no diff you were watching. Manual verification does not survive regeneration, so put an automated end-to-end check on the flows you cannot afford to break.

When should I move a Figma Make project into a real codebase?

When the same bug returns twice, when you need a change you cannot describe precisely in a prompt, when real money or customer data is involved, or when you need a staging environment to test in before publishing.

Catch bugs the moment a human sees them

Klavity: right-click bug reports, AI personas that review your product, and self-healing tests.

Get started free