Figma Make now has a real backend. Your prototype just got judged harder

Figma Make turned a prompt into a working UI you could click through. Now it turns that prompt into an app that remembers you tomorrow.

I've written that your prototype works once but determinism ships it — the second session is the real test. With a database behind the screens, fake data no longer hides a missing model.

Figma Make plus Supabase closes the last gap between fake prototype and working app — and moves the review from how it looks to how it behaves when data persists, auth matters, and empty states can't be faked.

Why did Figma Make add a Supabase backend now?

Because prototypes without data stopped convincing anyone, and Figma already owned the canvas where teams decide.

Make could already generate polished screens from a frame or a line of text, and you could edit directly or copy as layers. What it could not do was keep anything. You'd show a dashboard, then explain the numbers were fake. Figma Make's page showing prompt-to-app with a real Supabase backend now answers that — you can connect a Supabase project and turn the prototype into an app with auth, storage, and live data without leaving Figma.

That lines up with the other shift. Figma's announcement that the canvas is now open to agents made your file the agent's workspace, with components and variables as the source of truth. If agents already edit your real components, they should edit against real data too.

What does a Figma Make app with Supabase actually do?

It gives you the four pieces a solo prototype usually fakes, but now for real.

With the integration connected, you add sign-in with email, magic links, or Google and GitHub, and Supabase ensures people only see their own data. You store and retrieve app data with built-in key-value storage instead of hard-coded arrays. You handle file uploads with access control, and you connect to external APIs with keys managed for you. One Supabase project works across multiple Make files.

The detail that matters is in the Supabase partner catalog page for Figma Make detailing auth and storage — everything stays manageable from your Supabase dashboard when you want more control. You still describe what you need in plain language, but the result persists. Close the tab, come back tomorrow, and your user still exists. That's a demo becoming a product.

Why does a real backend make taste more important, not less?

Because a database forces decisions a pretty screen can dodge.

A mock can show "Projects 24" with no model behind it. A backend asks: what is a project, who owns it, what does a new user see before they create one, and what does a teammate see without access? AI can generate screens in seconds. It can't decide those rules.

I see the same mistakes: founders keep sample data because empty feels scary, so the first real user never sees the empty state. They make everything public because permissions feel like extra work. They let the model invent field names that don't match what users actually say.

Taste is choosing one model and holding it across every screen, error, and email. Log in as two users and drift shows up as a permission miss or a label you don't use. That's the review now — compressed into the 30 minutes after generation.

How do you ship a Figma Make + Supabase prototype without drift?

Treat the backend like part of the design system — one source, reviewed, not re-prompted.

Here's a tight loop for a solo timeline:

• Attach your library before you prompt. Give Make your styling context so it doesn't invent a palette. Set custom rules or paste a frame as reference.
• Keep one Supabase project per idea. Reuse the same project across Make files so auth and storage stay consistent while you explore directions.
• Run the second-session test with two users. Sign up, add data, log out, log back in, upload a file, and revoke access. Check empty states and the "no access" view.
• Write the rules down. One page: who is a user, what they can see, what you never show, and two empty-state sentences in your voice. Keep it where Make reads it.

Figma Make with Supabase doesn't make you a backend team. It removes the excuse that "it's just a prototype." The app now remembers, so users will. Decide the model before you prompt the screens.