Collaboration Hierarchical Taxonomy


I want to create a collaborative UI that enables the users to create hierarchical taxonomies together.

Is this possible with .bubble?

The UI will have the following features:

All Users
Create taxonomies
Define tag types (Several different taxonomies are included into one taxonomy)
Create individual tags
+/- Open/Close Children Tags. If no children, then no +/- appears

Change individual and parent/child location and hierarchical placement


Music Taxonomy

Tag Types
Artist, Album, Song, Genre, Record Label, Release Date, Musicians

The following is what the users see in both the UI and in the posted Music Taxonomy

+Genre | Rock and Roll
+Genre | Blues
-Genre | Jazz
…-Genre | Bop
…-Genre | Hard Bop
. . .-Artist | Miles Davis
. . . +Album | Miles Ahead
. . . - Album | Birth of the Cool
. . . . . .Record Label | Capital
. . . . . .Release Date | 1957
. . . . . .Musician | Junior Collins
. . . . . .Musician | Bill Barber
. . . . . .Musician | Lee Konitz
. . . . . .Musician | Gerry Mulligan
. . . . . .Musician | Al Haig
. . . . . .Musician | Joe Shulman
. . . . . .Musician | Max Roach

The periods at the beginning of each line should not appear, but I did not know how else to indent the tags.


Yes. Interfaces for things like this are almost trivial to build in Bubble. You’d use nested Repeating Groups. Here’s an example that’s not as complex, but shows the principle:

In run mode, this is:

Then you’d use the same technique to display the info to users without giving them access to “edit” capability.

Probably the only hard-ish part you’re talking about is interface for changing “order” of things. You can build slick drag/drop reordering, but it takes a little learning. But to do that with just an input for “index” or whatever (or clickable up down arrows that would change an index value being used to sort the RG) is quite easy.

Also, if you’ve never thought about ordering and priority of items before in the context of data structures, well now you will!

Here’s (sort of) an example of what I’m talking about. This is an administrative interface (and no it’s not pretty, it’s just a quick and dirty way to get this job done) for adding the names of days of the week in various languages:

In run mode, with this interface populated with data (czech language), we see:

The highlighted thing is a numeric input that represents an index property. Index 0 represents “Sunday”. Obviously, I wouldn’t go around changing those index/order numbers, but you can imagine a different application of the same idea.

Anyway the interface part of all this isn’t particularly hard, but you do need to do some thinking about how you will want to represent this in your database. Bubble’s very flexible there and you have a lot of options.

Aside: Since you’re compiling music album info, you might not want to start from scratch there. There are quite a few music APIs with at least some of what you are trying to compile. At the very least, examining those APIs will give you ideas about how this sort of data should best be structured. APIs to look at would include Gracenote, Spotify,, musixmatch, iTunes and others.

1 Like

Hello Keith,

Thanks for such a detailed response! You’ve given me a lot to get my app started, and no doubt you have saved me a lot of time too.

On thing though. The music example was just an example. My goal is to create a generic app that can be used for a multitude of purposes. So I must build in flexibility and customization to enable a wide range of possibilities.

Thanks again!


You’re welcome. It was an interesting question.

The thing you might run into is that — at the database level — you cannot just let users create new data types. Now you’re at the Bubble admin level (you can’t use Bubble to create Bubble, basically).

You can abstract some of that (like you could model some generic data type and wrap it in your own super-datatype), but it’s not going to be particularly performant.

If you’re looking to use Bubble to model hierarchies and export them as JSON representations, that’s possible but not necessarily easier than other paths. (Parsing text isn’t a built in thing in Bubble.)

Bubble is great for rapid app / MVP development, but not necessarily great for meta-app development. (You can’t really build an app for developing apps in an app that’s an app for developing apps, right? That would be stupid [on the part of the providers of the app for developing apps], if you see what I’m getting at.)

Again, if you’re trying to build Bubble, you’ll have to build Bubble. You can’t use Bubble to build Bubble.