Supabase Launch week with Jon Meyers
===

[00:00:00] hello and welcome to PodRocket, a web development podcast brought to you by LogRocket. LogRocket helps software teams improve user experience with session replay, error tracking, and product analytics. You can try it for free at logrocket. com. I'm Noel, and today we're welcoming back John Myers. John's a developer advocate at Superbase.

He's here to talk to us about the recent launch week. Welcome back, John.

Hey, thanks for having me. Yeah. I feel like I was just here only a couple of months ago, but I guess this is how launch weeks go at Superbase. They happen quite frequently.

. Good frequent releasing all the time is usually good, especially when it comes to dev tooling, I guess, as long as it's paired with general stability. And I feel like that's what we've seen. So I think that's a good vibes. Yeah, it's all good.

Absolutely.

Yeah, so I guess maybe to frame this slightly, can you give us like a real quick overview on what Superbase is for listeners , . that kind of, . , I have a hunch, a pretty large demographic have at this point. But if, if you can give us the 30 second elevator pitch.

For sure. So Superbase [00:01:00] is a collection of open source tools that wrap around a Postgres database. And so we give you things like database hosting, authentication, file storage, real time and wrap all of that up in a nice little convenient package called Superbase.

Okay. So then what's, launch week? Why do we care about launch week?

Yeah, so launch week is a crazy time at Superbase where we decide to launch a new feature every day of the week. And it used to only be every day of the week, but now it seems to be the week before every day of the week and also over the weekend and also the week after. So it's just, it's growing and growing.

But the original idea was that we would launch a new feature every day and shout about it and get excited about it. And yeah, basically take over all the social media yelling about how awesome Superbase is. It's awesome.

It is, I think it's, there's, it's, some shouting is warranted. I think a lot of these features are really cool. And I feel like Superbase is one of those products where once people try it and get pulled in, they're usually pretty enthusiastic. Yeah, so it's cool. It's cool to see the launch weeks going on.

I always see the [00:02:00] posts go up on Hacker News and stuff, and it's a, it's an exciting time. But yeah, let's just start going through some of the features for this launch week. I know you said there was like more than one a day. There's a lot to talk about. But yeah, let's just start at the top.

Let's Superbase AI. What's, what is that and what does it let devs do?

Yeah. So Superbase AI was, well, AI features were a big focus for this launch week. It spread over, two days. One of them was a whole bunch of new Superbase tooling that we've released using hugging face models in either JavaScript or Python. So this allows you to generate. Custom embeddings for additional stuff that you want to for example, train, chat, g b t on.

So if you wanna give it some really specific context, you can generate your own embeddings and store those in a vector column in in superb base or in Postgres. And then be able to query that as well. So we released some really convenient tooling around using models from hugging face for all of that for our JavaScript people and our Python people.

And then another big feature was[00:03:00] the AI SQL editor. And so, we've had super base AI, or what we were referring to as Clippy for a while which is like a little helpful AI assistant that can that can give you some hints as to things, errors that you might be having or how to do specific things in super base.

So it was trained on all of the documentation. We've now brought that into the SQL editor in super base. So it can give you really specific, feedback about your SQL queries. It can write SQL for you. It's basically an interactive conversation. So you can tweak the query that has been written.

And then yeah, if you're experiencing any kind of syntax errors or debugging errors, you can actually feed that into. The AI SQL editor assistant as well. And it can try and work out what's going on for you. So this has been a huge time saver for me, especially putting together examples and things.

It's already basically replaced my entire brain of SQL knowledge. Cause I can now just rely on the robots to do it in a much better way that I can anyway.

So is this AI SQL [00:04:00] editor. Is this in the studio, the super base studio, or can you do it in your own editor or what's the interface?

Yeah, so this is within the Superbase Studio, which is like the dashboard that you interact with \ to build out your Superbase project. So it lives within there. There's a page for the SQL editor where you can basically write. SQL and execute it directly on your Postgres database.

Cause as I said, Superbase is just a collection of tools that wrap around a Postgres database. So you can write SQL directly and execute it against your Postgres database. So the AI assistant now just lives at the top of that and can yeah, give you helpful suggestions on what you're writing.

So you can either. Just use it generally to ask it questions about SQL or you can actually send your Postgres schema along with your query so it can give you really specific suggestions based on your Superbase project.

Oh, very cool. So does it, does this even work? If you're running the studio locally you have the Docker stack, the container stack running and [00:05:00] you're like doing, using the studio locally for. Development.

Yes, I believe so. I'm going to, I'm going to claim yes. And look into it later. It either does work right now or it will work soon. But yes, I believe it does work when running locally.

That's cool. I'm just personally invested in that because I have found the local studio to just make my development flow so quick and beautiful. It's like the best of both worlds. I get my like immediate local dev responsiveness and all the power of just like this, gooey studio to try stuff and experiment quickly.

So yeah it's super cool to see, I guess that kind of does segue me into I was curious about the language server as well. And like, . Is there any crossover between kind of the feature set there and what the AI tooling is doing, or is the language server like a totally different feature?

Yeah, no, this is I believe it's what is being used under the hood. But yeah, the language server is. a general Postgres language server that we released again, before, before launch week started another one of those ones that snuck in over the weekend before launch week. But yeah, it was something that we just put [00:06:00] out on Hacker News and people are super, super excited about it.

But for anyone that doesn't know, a language server basically just. Provides intelligence to your code editor. So these are things like syntax highlighting or maybe showing you inline errors. If the thing that you've written is, there's a syntax error or something like that.

It can give you auto completion and also code formatting. So all of that, the way that works is usually it is sending your code or. A version of your code to some kind of server to say, is this correct or is this not correct? And so that is what we have built out is one of those specifically for Postgres.

So there have been SQL language service SQL language servers that have been released in the past, but it's generalized across all of the different flavors of SQL. Whereas this is a specific one written just for Postgres and. Knows all of the Postgres D specific things and yeah, it's, it seems like people are very excited about it.

And it's things like this that , enable the. AI SQL editor [00:07:00] to know so much about Postgres and write such a well formatted concise code.

, the language server internet itself was something I was very excited about. I mean, I think the AI, like having an AI assistant there to help write code is very helpful. But for me, it's just I don't know, in my day to day when I'm, writing migrations and stuff, it's still just, I'm just like, making sure syntax is a hundred percent correct.

Like looking at strings, it feels very I don't know, old school without having a server there, like checking me all the time. So I think that, like this will be super. Super handy and just saving devs a little Oh, oops, I fat fingered this, or I forgot one character here. And yeah, it'll just be, it'll be really nice.

I've got one more on the database front. I saw the database branching blog post. Can you explain a little bit about what that empowers?

Yeah. So database branching is probably our most requested feature since we kicked off super base which is basically a way to have a separate database for every single branch in your, in GitHub, for [00:08:00] example. So when you're working on a feature. You want to be able to like you, you keep all of that code separate from your main branch, obviously uh, while you're working on the feature.

So you might have a feature branch called like implement dashboard or something like that. And so while you're working on that, you're working on a separate branch. And so database branching allows you to also have a separate database attached to that branch. So you can make all of your.

Changes to your database and the structure of your database along with your feature. And then when it's ready to merge into production, you merge in your feature branch into your main branch, and that will trigger the migrations and basically bringing your production database up to the same state as your feature branch that you're working on.

So this actually goes hand in hand with that local development. Workflow that you were talking about. So we've actually improved that significantly and added some tooling around creating migrations. So you can run the super base stack locally, like you were talking about running it in a [00:09:00] Docker container.

And then you can make changes to the structure of your super based project. So the structure of your Postgres database, adding tables, adding columns just changing it however you would like using the UI. And then you can run some super based commands to generate migrations based on those changes.

So it will introspect your database schema. It will look at the database schema of the of Basically your production database, and then write out all of the different steps that it would take to to migrate from one of those to the other. And so, yeah this kind of goes hand in hand with that branching feature that now you can create these migrations with your feature that you're working on.

And then when you merge it into production, it can run all of those migrations against your production database.

That's super cool to see. And I feel like this is a, it's an odd discussion to be having for people that are maybe used to like a more traditional development flow or they're like running everything locally all the time and they have a CICD server and it's like building all this stuff for them.

They're like, of course I would always have a [00:10:00] database, for every build, but I feel like this is a pretty unique one for a tool chain as robust and sophisticated as super bases is there Any other kinds of tooling in this space that you guys looked at or used as influences here, like to help figure out what the best practice would be to like help, larger devs, teams or teams as they scale to use these kinds of tooling where you get so much off the shelf, but we need to empower, this like multiple devs working on things concurrently.

Yeah, well, I think just Git in general was a huge inspiration for this, having these collaborative workflows around a whole bunch of different people working on a feature at once or working on one on many features across one code base. And so, yeah, that was a big inspiration. The, this one has just been launched into alpha, and so it's not generally available.

You need to apply for a private alpha to get access. And we're going through that process to collect feedback about how we've started to implement it. And tweak it based on, on, on what [00:11:00] people actually need to build out their applications.

Yeah, cool, cool. That's very cool to see. And I'll be watching this one closely as well. In that same vein on, like what's, how do you make this more collaborative? I also saw that there was a post on the integrations marketplace. I didn't read this one much, so you'll have to fill me in.

So what kind of integrations, does this empower and how do they interact with like a Teams Superbase instance?

Yeah. So, the super base integrations marketplace is basically a collection of tools that you can use to connect to your super base database and make it even more powerful. And so, we'll make sure there's a link in the description, but you can check out all of the different integrations. There are ones for Cloudflare workers, Vercel, Trigger.

dev, Snaplet, there's a whole collection of tools. But. One of the things that we've launched with with launch week is the management API, which allows you to programmatically manage your super based projects. So this will allow you to build your own custom tooling on top [00:12:00] of all of these different integrations and tools that exist within the integrations marketplace.

So if there is a specific thing that a superpower that you wish that your super based database had or a tool that you wish you could. Really easily integrate your projects with then now you can build your own with the super based management API.

So how do these integrations actually like manifest within a project? Are these like strictly managed through the super based dashboards? Are these making changes to the SDK? Are they like functions you can call within, your language of choice? How does this actually look for a dev to use?

Yeah. So these these integrations can go either way. So some of them will live inside the Superbase dashboard and it will be like a tight integration with that tool where you can spin up a Cloudflare worker that's attached to your Superbase database, or for example, with our Vercel integration, which we've just launched a new V2 version of our tight integration with Vercel. When you're creating a Vercel project whether that be through the Vercel project dashboard or whether [00:13:00] it's through a deploy button you can.

Now create a super base database or a super base project attached to that project in Vercel. And so this will automatically create a super base project and. Basically populate all of the things that you need in Vercel to connect to that project. So things like environment variables and everything that you need to get up and running.

And so these integrations allow us to create some much more helpful templates and things which is something that we're about to do a lot of work on is creating things like some really good starters where you can basically click one button and have a SAS project up and running that's completely hosted on Vercel and the integration is already set up with Stripe.

This is what those sorts of this is what this integration marketplace kind of unlocks.

Very cool. Very cool. I'm curious on some of these, it feels super base has been trying to go go wide with the feature set, provide as much as we can off the shelf. [00:14:00] So devs can, stay in this ecosystem for the most part, like we have functions in the database and hosting and all these things.

How do you guys think about. When a dev should be reaching for something like the cloud flare integration, for example, versus just like using super base functions.

Yeah, I think it, it depends how much it's coupled to the database. I think one of the reasons that we launched database webhooks so that you could create webhooks within your Superbase database is a lot of the things that you would need to listen to webhook requests for are things that need to interact with your database directly.

And so creating those within the Superbase ecosystem or a super based environment we can give it privileged access and much more prioritized access directly to that database. So an example of that would be like if you're creating a webhook to listen for payments in Stripe the reason that you want to listen to those payments is because you want to update a column in your database to say that this customer has bought this product.

[00:15:00] So an example of when we would not build that into the super base platform and we would reach outside for something like an integration is something like.

Web hosting, like we offer file storage and we offer edge functions, but we don't want to be a web host that is hosting your entire application and trying to create a really good experience around that people like Vercel already provide an excellent experience around that. And so we would rather build an integration Because that's outside of just that database hosting authentication, like everything about storage and access to \ , that data, anything that lives outside of that, we would rather reach out to a really good tool that already does that and build a tight integration with them to be able to make that experience as seamless as possible, but let.

Those professionals deal with that problem.

Yeah, I think it's cool to see that this kind of API opening up. I guess if there's other people listening, and they're like, developers on more on platforms or on tools that might integrate with super base [00:16:00] itself. Is it hard to build these integrations?

Is this spec open? Is it something anyone can work on or is it more of a, like a partnership?

It's, yeah, it's something that anyone can work on. So we have hooks that you can tie into to to create databases, to to update databases or , when they have been changed on our end. And so, yeah, it's this the new management API that we have released makes it much easier to to actually.

Manage your projects on the super base side. So previously you would need to go through the dashboard to be able to create a new project or to modify something about it. Whereas this management API now means that anything outside of that can programmatically make those changes. And so someone else can build a tool or an integration that is able to create super base projects on behalf of that user.

All of that is made possible by that management API.

And it's very cool. Kind of A, like a meta API for interacting with super base services as a whole is is very [00:17:00] cool. It sounds like \ it's one of those though, that is, is a very, would be a very powerful tool set to be using is there a lot of work that's had to go had to go into security and authorization in this API.

Yeah, a huge amount of work. That was the big reason that this has taken so long to get out is obviously we need to to roll it out securely and make sure that, all of the boxes are ticked. And so, yeah, this is why we built it , as an entire separate API.

that you can enable access to, so you generate an access token to say That you want to grant this integration permission to be able to create projects in your super base organization. And then you can revoke that access at any point. And so, yeah, this was the management API itself was the initial problem that we needed to solve to roll out a bunch of stuff like database branching and this.

Really tight Vercel integration and a whole bunch of other stuff that we can't talk about yet, but get excited. There's more cool stuff coming.

. I'm one more kind of [00:18:00] little particular I'm curious about here. It sounds like a lot of this is trying to empower dev teams to think about a super based project is more of a, like a Ephemeral thing that can be like created and used for whatever purpose is needed to test something to like, you know Do a little mock and then spin it back down Versus like it being a long lived thing where there's always production data of course like your production instance may be more like that or your production project But is that a pretty common thing you guys are seeing like devs are using like tyings or teams I guess are tying super based projects to like a specific branch and then a dev each dev has like their own like development project and things like that.

Is that, are those the workflows that are trying to be empowered here?

Yeah, absolutely. And I think that's always been something that we haven't entirely nailed. Which is why we've put so much work into this new local development workflow and the migrations and database branching. Like all of this is to enable that collaborative workflow that I think hasn't been as seamless an experience as we'd [00:19:00] like it to be since day one.

So we've put a lot of work into. Thinking about how teams actually interact with each other and collaborate with each other. And yeah, the best workflow to enable them to not bump into each other constantly. And I think that kind of thinking about databases in the same way as you think about a git Tree of commits is a, it's a really good way of thinking about it.

So every migration is like a different commit on that tree. And everyone who's working on the project can bring their database up to exactly the same structure as anyone else in the team. And if someone's working on a specific feature and then someone else wants to jump in there and add something to it, again, they can run all of the migrations necessary to bring up their local development environment to be.

Perfectly in sync with any feature that the team is working on. So yeah, those kinds of collaborative workflows have been something that our community has been asking for, for a long time which, yeah, we're very excited to finally be enabling.

\ , I think it will be really cool to see, I'm going to put you on the spot slightly, if you can't answer this, that's okay, but I guess , if you were, starting a new project with a [00:20:00] small team at this point, what would the recommended development?

Set up for them be like now, or, in the next several months, when some of these have solidified, do you think you'd still be recommending that people run the super base, it's stack and dashboards locally, or do you think it'd be possible to have everyone have their own, just like fully, run in the managed cloud version.

So just get stuff developed.

Yeah, I would recommend going with the local development workflow for all of your local dev work and then Because yeah, with our new tooling, you can now pull down migrations from production and run them locally. You can create new migrations, you can push them up to production. And so I would think of your super base project as being one production version of your super base project, which is the hosted project hosted by super base and then a.

Every feature that you're working on or every dev has their local environment running the super base stack locally, and then. In between anywhere where [00:21:00] you push up a feature to get hub to do something like open a PR to go into the main branch, that would be where database branching spins up these kinds of preview database branches.

So, yeah, I would say everything locally should be using the local development workflow. Anything that is a preview branch should be using branching and then anything that is in main. Should be either like, Postgres is an open source project. You can take it and run it anywhere. So that would either be like the production version of your application would either be something you're self hosting wherever you'd like or the hosted version of Superbase in Superbase cloud.

. That makes a lot of sense to me. I feel like there's just, again, like there's been so much coming out. I feel like it's hard for some people, like. wrangle, you know, what the, what the optimal setup even looks like. so that's good to hear. 

So as we roll out database branching to general availability, we'll be creating a lot of documentation and a lot of tutorials around how to work with that workflow. That's going to be [00:22:00] the suggested workflow. going forward. We just need to really nail down the branching part of it and make sure that really solves the problem in the right way.

And then, yeah that'll be the recommended pathway through the docs, the recommended pathway through any tutorials or streams or anything that we do. But yeah, for now I would say check out the awesome new workflow around working locally and then creating migrations.

Nice. I'm excited to try that new feature you were talking about, about like, Kind of creations derived from changes made in the UI. Cause I've always just done them, done it, you know, manually by hand like, and it's fine, but it'll be cool to see that come back full circle.

Cool. And then I think the last big one list of features from launch week was the supervisor for connection pooling. Can you tell us a little bit about what problem this solves

yeah. So Postgres wasn't really designed with this kind of jam stacky serverless architecture in mind where you have a whole bunch of of requests coming in from serverless functions that are all these kinds of short lived functions that spin up. Make a database request and then shut down again.[00:23:00] 

Postgres was designed with this solid connection to the database in mind So if you think more of that traditional like monolithic api that's always on And has a direct connection to the database And can send all of the database requests down that connection so a connection pooler is basically that idea of that API, but just for the connections to the database.

So it sits in front of your database and then takes requests from all of those serverless functions, all those different clients that exist out there and then it manages sending those requests down a collection of solid connections to the database. So this is similar to something like pgBouncer, if you're familiar with that.

This feature definitely caused the most confusion out of all of them. I don't know if I, I didn't present it as clearly as I should have, but a lot of people were like, Oh, how do I get this for my super base database? And. The answer is that this is, or this is already a solved problem.

If you're using JS Postgres, which is one of the tools that we wrap around [00:24:00] has connection pooling built in. So you don't need to worry about this if you're using Superbase directly. But if you're connecting to your database with something like Prisma, or if you're using the connection string to connect to your database direct, directly then that's where you would need a a connection pooler.

So. Yeah, you should check out the blog, which we'll have linked in the description for some proper benchmarks, but basically supervisor can handle like a million active connections or active requests to the database. Whereas something like PG bouncer, I think it's recommended around like the 10, 000.

Connection mark. So it's just a much more scalable connection puller built for the kind of world that we live in currently.

Yeah. Yeah. Again, like in the world of functions and workers and all these little short lived things that make one request and then fall off. It's. It's a bit of a different ask, but it's totally really nice if we can use all the niceties that Postgres affords us. So it's cool that there is tooling cropping up and you guys are able to integrate it to give us the best of [00:25:00] both worlds there.

Yeah, let's see. Is there anything that we've covered a lot in 30 minutes or so here? Is there any other highlights from launch week you wanted to cover?

Yeah. One, one big announcement that's, it's like you either like really care about it or you just don't care at all is that we are now SOC2 and HIPAA compliant which is a really big deal for enterprise companies and. Absolutely worthless to like indie developers. So it depends what your audience is, but this is yeah, a huge deal that, that we are now SOC 2 and HIPAA compliant.

And it's allowed me to to use the awesome pun that there is nothing HIPAA. Then compliance uh, which I've been saying regularly throughout, throughout super base. And I'm glad to now be able to reuse that joke here. But yeah, these are basically yeah, compliance thresholds that we need to hit is to how we store data, where we store data, your access to data, our ability to permanently delete your data and all of that stuff.

Which is, yeah, usually a requirement if you want to build applications [00:26:00] using your customer data and you want to build something with Superbase SOC2 and HIPAA compliance are very important pieces there. Another big one on a personal note is I released a new egghead course showing you how to build a Twitter or X clone uh, using Superbase and all the new Next.

js app router things. So this is a course I've been working on for a couple of months. And yeah, has people have seemed to really enjoy it. So it's an entirely free egghead course that you should totally go and check out at egghead. 

Nice. Cool. We'll get a link to, everything we've discussed here, all the posts that we can in the show notes as well. As a link there thank you so much for coming on and chatting with me, John. It's been a pleasure.

Yeah. Thanks for having me.