Back

AI Extension Builder: add a Supabase database to your app

on 

The AI Extension Builder already lets you create a custom app section by describing it in plain language. Now those sections can remember and share real data. Ask for a poll, a booking list, or a guestbook, and the builder sets up the data behind it and connects it to your live app — through a new integration with Supabase.

The AI Extension Builder just got a memory

Until now, the AI Extension Builder was brilliant at one thing: turning a sentence into a working section. Describe a countdown, a mood board, a mini-game — it appears in your app, styled to fit right in. But every section it built lived entirely on the visitor's device. Nothing it produced could hold on to information or pass it between people.

That was the limit. Ask for a "reader poll" and you'd get a poll that worked perfectly for one person, on one device. The votes lived in the browser. Close the app, and they were gone. Open it on another phone, and the count started at zero. A guestbook only you can read isn't a guestbook. A booking list that resets on every device isn't a booking list.

The reason was always the same: those features need a place to keep their data, and a set of rules for who can read and write it. That layer — a backend — is the hard part, and it's exactly the kind of thing that used to sit among the limitations of no-code app builders. The new Supabase connector brings it inside the builder. The AI Extension Builder now builds the data layer along with the section, in the same conversation, before it writes a line of code.

(If you're new to building sections this way, start with how the AI Extension Builder works — this article picks up from there. It's the same tool that recently learned to handle file uploads, now with a data layer too.)

Describe the feature, and its data comes with it

Take a yoga studio that wants an in-app class-booking section. You describe it: "a list of this week's classes, and a button for members to reserve a spot, with the number of spots left updating as people book."

The builder plans the feature, recognizes that reservations have to persist and be visible to everyone, and sets up a place to store them. When a member books on Tuesday, the studio owner sees it on Wednesday, and the next member sees one fewer spot. The data is real, shared, and it survives — because the section now has a backend wired into it, not just a screen.

You describe what the feature does. The builder works out what data it needs and builds that too.

How the Supabase connection works

The first time one of your sections needs to store data, the builder asks you to connect Supabase — a widely used open-source backend platform with a generous free tier. You click Connect, sign in once through Supabase's own login (the same kind of "connect your account" step you already know from linking any service), and you're back in the studio. Every later section that needs data reuses that same connection with a single click.

Behind that one click, the builder handles the parts that are normally fiddly and easy to get wrong:

  • It creates the data structure for you. You describe the feature; the builder works out what a "reservation" or a "vote" or a "sign-up" is made of, and sets up the storage to match.
  • It secures the data. Every table ships with access rules (Row-Level Security) so your data isn't left wide open — reads and writes are governed from the start.
  • It manages the connection keys. The builder distinguishes the key that's safe to ship inside your app from the one that must stay private, and handles that itself.
  • It asks before changing anything sensitive. If an edit to your feature would alter or remove data you already have, the builder stops and asks you, in plain language, before touching it.

The whole thing renders live in the preview while you refine it, and ships inside your published app.

It's still a fully integrated GoodBarber section

This is the part that matters. The section the builder produces isn't a loose piece of code you have to host, deploy, or maintain somewhere. It's a first-class part of your app — it inherits GoodBarber's hosting, follows the Smart Design system, and ships inside your published iOS, Android, and web apps through the same store-deployment pipeline as every other extension in the 190+ Extension Store catalog.

The data layer follows the same logic. The builder doesn't hand you a database and leave you to plug it in. It provisions the storage, secures it, connects it to the section, and drops the finished feature into your app. You get a feature that works, in the stores, not a technical project to assemble.

Why Supabase?

Supabase is one of the most widely used open-source backend platforms in the developer world. Under the hood it's PostgreSQL — the same battle-tested database that runs serious software everywhere — wrapped with an instant API, authentication, file storage, and real-time updates. It's trusted precisely because it's open, standard, and not a black box.

What GoodBarber adds is everything that normally makes that foundation hard to use — the setup, the security rules, the connection to your app — so you get Supabase's power without touching its dashboard.

What you can build now

The rule of thumb is simple: if a feature needs to remember something, or show the same thing to more than one person, it now has a home. A few of the things that become possible just by describing them:

  • Guestbooks, comment walls, and reviews — visitors leave a message, everyone sees it.
  • Polls, votes, surveys, and ratings — collect responses and show the live tally.
  • Sign-up forms, waitlists, and event RSVPs — capture registrations you can actually retrieve later.
  • Bookings and reservations — class slots, table reservations, appointment availability shared across all users.
  • Leaderboards and scoreboards — cross-user high scores that update as people play.
  • Live chat and message boards — real-time conversation inside your app.
  • Collaborative lists and shared notes — a community wiki, a shared to-do, anything many hands edit.

Features that are genuinely personal — a private habit tracker, a calculator, a solo game's progress — don't need any of this, and the builder won't add a backend where one isn't warranted. The data layer appears when the feature calls for shared or lasting information, and stays out of the way when it doesn't.

Good to know

  • The data lives in your own Supabase project. You connect your Supabase account, so your feature's data sits under your control, on infrastructure you own. Supabase's free tier covers a lot of ground before a paid plan ever comes up. (This is separate from your GoodBarber app content, which stays hosted by GoodBarber.)
  • The access rules are set up for you, and worth understanding. Every table gets sensible read/write policies out of the box. As your features grow, it's useful to know what those rules do — the builder makes the secure path the default.

Further reading

FAQ

What is the Supabase connector in the AI Extension Builder?

It's an integration that lets the AI Extension Builder give a generated section a real backend. When you describe a feature that needs to store or share data, the builder sets up the database tables it needs, secures them, and connects them to your section — so the feature can remember information and show it to every user, not just to one person on one device.

Do I need to know how to code, or write SQL?

No. You describe the feature in plain language. The builder works out what data the feature needs, creates the structure, sets the access rules, and writes the code that reads and writes to it. You review the result live in the preview.

Why does the AI Extension Builder use Supabase?

Supabase is a widely used, open-source backend built on PostgreSQL, with database, authentication, storage, and real-time features. Building the connector on a trusted, standard platform means your data stays on a portable, well-supported foundation — while GoodBarber handles the setup, security, and integration so you never have to work in Supabase directly.

Do I need a Supabase account?

Yes. The first time a section needs to store data, the builder asks you to connect Supabase — an open-source backend platform with a generous free tier. You sign in once through Supabase's own login, and every later section reuses that connection with one click.

Where is my app's data stored, and who owns it?

In your own Supabase project, under your account, on infrastructure you control. This is separate from your GoodBarber app content (articles, products, media), which stays hosted by GoodBarber.

Is the data secure?

Every table the builder creates ships with Row-Level Security policies, so reads and writes are governed from the start rather than left open. As your features grow, it's worth understanding what those rules do — the builder makes the secure setup the default.

What kinds of features can I build with it?

Anything that needs to remember something or share it between users: guestbooks, comment walls, polls and surveys, sign-up forms and waitlists, event RSVPs, bookings and reservations, leaderboards, live chat, and collaborative lists. Purely personal features — a calculator, a private habit tracker, a solo game — don't need it, and the builder won't add a backend where one isn't warranted.

Can several sections share the same database?

Yes. After the first connection, each new section that needs data reuses your existing Supabase project in one click, while keeping its own data separate.

Try it on your next idea

Open the AI Extension Builder in your GoodBarber back office and describe a feature you'd filed under "too complicated" — the reader poll, the event RSVP, the booking list, the guestbook. The first time it needs data, connect Supabase in a couple of clicks, and watch the feature come to life with a real backend behind it. Then tell us what you built, and what you want it to do next — that's what shapes the release after this one.