Push a schema into Bubble

This is the one nothing else does: take a schema that exists only as a diagram and create every data type, field and option set inside a real Bubble app, in one action.

It works through the LumiDevKit Chrome extension.

What you need

A schema on the Database Visualizer canvas — uploaded, AI-generated or built by hand.
The LumiDevKit Chrome extension installed.
The Bubble editor open on the app you want to fill.

Installing the extension

The extension ships in the LumiDevKit repository at bubble-paste-extension/. To load it:

Open chrome://extensions.
Turn on Developer mode.
Choose Load unpacked and select the bubble-paste-extension folder.

The flow

A fresh Bubble app starts close to empty: Bubble's own starting types, and a User carrying nothing but its built-in fields.

The Data tab before pasting. Two entries, both Bubble's own: App Variables, and the built-in User with its four built-in fields.

In LumiDevKit, click Copy for Bubble. This puts a structured payload on your clipboard, and it is the only thing that produces that payload: a schema download gives you a plain {user_types, option_sets} file, which the extension does not recognise. If your browser blocks clipboard access, retry the copy, because there is no file version to fall back on.
Switch to the Bubble editor tab for your target app. Any tab of it will do, the extension opens the Data tab itself.
Open the extension popup and paste the payload into the box, or click Load .json if you saved the payload to a file yourself.
Check the badge, then click Paste to App.

The extension works by writing Bubble's own clipboard format and driving the editor's native paste, which is why it does not need DevTools and does not touch Bubble's database directly.

While it runs

The extension drives the editor tab for you: it opens the Data tab, moves between Data types and Option sets as the payload requires, and creates each item in turn. A counter, a progress bar and a running list show where it has got to.

Part-way through the option sets. Each finished item gets a tick, and the counter tracks the whole payload.

Three things are worth knowing while it works:

You can close the popup. The paste runs in the editor tab, not in the popup, so closing it changes nothing. Chrome closes the popup by itself whenever it loses focus, which is why this matters more than it sounds. Reopen it and the progress is still there.
Leave the editor tab open. If the tab is hidden or your screen locks, the paste pauses and picks itself back up. Reloading or closing that tab is what actually ends a run.
Stop is safe. It stops at the next item boundary, so whatever was being written finishes first. Click Paste to App again to carry on: anything already created is skipped rather than duplicated.

When it finishes

The finished run: 57 items pasted, 1 skipped, none failed, plus 24 fields added to the built-in User. Below it the run is stamped with the app it went into and when.

The summary counts four separate things: items pasted, items skipped because a namesake already existed, items that failed, and fields added to types that were already there.

That result outlives the popup. Come back an hour or a day later and reopening it still shows Last paste, with the app name and the time, which is the quickest way to tell whether the app in front of you is one you have already filled.

What gets created

Every data type, with its fields.
Every option set, with its values, display labels and sort order.
Types and option sets are ordered so that anything referenced is created before the thing that references it.

The Data tab afterwards. Every type in the schema exists, and User carries its custom fields with their types intact: lists (List of Profiles), references to other data types (Profile), and option sets (-Role).

Option sets arrive whole. This one kept both of its options and the order they were defined in, which Bubble exposes as move up and move down.

Types that already exist

Bubble's clipboard cannot merge. Pasting a type whose name already exists produces "X copy" rather than adding to it, so the extension skips those types instead of duplicating them.

App Variables was in the app before the paste began, so it is reported as "exists, not updated" instead of being pasted a second time.

Only active types count as existing. If the only namesake is a type you deleted in Bubble, the paste goes ahead and creates the type fresh; the deleted one stays in Bubble's deleted list, untouched.

Deleted option sets are the one exception, because Bubble treats them differently: pasting an option set whose deleted namesake still exists produces an "X Copy" duplicate instead of reusing the name. The extension skips those and lists them in the popup — restore each one in Bubble (Data → Option sets → Show deleted types → Restore), then re-run the paste.

On its own that would silently drop your changes, so there is a second mechanism: Add missing fields to existing types, a checkbox in the extension popup. With it on, the extension selects each existing type, compares its fields against your schema, and creates the missing ones one at a time through Bubble's field dialog.

It is off by default. Pasting a type that does not exist yet is additive and safe; writing fields into types you already built is a bigger commitment, so it is opt-in. Turn it on when you are deliberately pushing schema changes back into an existing app.

Bubble's built-in User

The User type always exists in every Bubble app, so it can never be pasted as a type. Its fields are a different matter.

LumiDevKit carries them in the payload as an advisory, and the extension creates them using that same field-by-field mechanism, last, once every other type and option set exists. That requires Add missing fields to existing types to be on.

The extension driving Bubble's own Create a new field dialog, one User field at a time. It runs last so that every option set a field might point at already exists.

If it is off, or if an individual field fails, the popup lists exactly what still needs adding by hand, with a copyable list.

This is worth turning on. A mature app can carry twenty or more custom fields on User, and each one added by hand means opening the dialog, typing a name, opening the type dropdown, choosing a type, sometimes ticking "list", and confirming.

Other advisories

Before pasting, LumiDevKit checks the payload and warns about:

An empty schema.
More than 80 items, which takes a couple of minutes to paste.
References that do not resolve — these will paste unresolved, so fix them first. See the schema format for why a reference might not resolve.

Where this fits

The full chain is: LumiDevKit export → the bubble-design-system skill → the bubble-element skill → this extension → your Bubble canvas. This page covers the database half; the design-system half starts at Design System.

If Bubble's editor changes

The extension targets Bubble's DOM, so a Bubble redesign can break it. All the selectors are centralised in one file in the extension (lib/selectors.js) precisely so that it is a one-file fix rather than a rewrite.