Changelog

Text area under AI assistant is now expandable for better UX with multi-line prompts (PR)

PR: https://github.com/supabase/supabase/pull/26809

Added placeholder for function body editor section to hint the syntax if language selected is plpgsql (PR)

Logs Explorer

Fixed logs explorer placeholder query for local set up (PR)

Postgres 13 Deprecation Notice

Jul 12, 2024

Supabase support for Postgres 13 is being deprecated as of 15th July 2024, and support for it will be fully removed on 15th November 2024.

All Postgres 13 projects should be upgraded to Postgres 15 before 15th November, 2024.

Any projects still on Postgres 13 after the 15th of November 2024 will be automatically upgraded to Postgres 15. If any Postgres extensions or functions are in use that cause the upgrade process to fail, a backup will be taken instead, and the project will be paused.

Postgres 15 comes with numerous features, bug fixes and performance improvements. Check out the announcement blog posts to find out what each version introduces.

Deprecation Timeline

15th July: All users are notified via email about Postgres 13 Deprecation. Users can self-serve upgrade to Postgres 15 from our dashboard.
30th September: Users are reminded of impending deprecation via email.
30th October: Users are sent a final email reminder.
15th November: Any remaining projects on PG13 start getting migrated to PG15 (or paused, if there are upgrade issues).

Dashboard Weekly Updates [01/07/24 - 08/07/24]

Jul 9, 2024

Option to disable Data API when creating projects

You can now opt to disable the Data API when creating a new project under a section called "Advanced Options", such that you will only be able to connect to your database via connection string. Note that this setting can be subsequently updated again in the project's API settings if and when you want to connect your project via the client libraries.

Link: https://supabase.com/dashboard/new/_

Authorization for Realtime is now available!

You can now control client access to Realtime Broadcast and Presence by adding Row Level Security policies to the realtime.messages table! Read more about through our documentation here!

PR: https://github.com/supabase/supabase/pull/27362

Link: https://supabase.com/dashboard/project/_/realtime/inspector\

Optimizations for table editor row count query

Previously, the Table Editor on the dashboard would run a select count(*) from table query to retrieve the number of rows in the table and display it in the editor (this also supports the pagination logic as well). However, understandably this query can be resource intensive and expensive if the table in question is particularly large. As such, we've chucked some optimizations around this logic to only retrieve the exact row count if the table has less than 50k rows, otherwise we'll retrieve an estimate of the row count instead. You'll still be able to get the exact row count but on demand instead.

PR: https://github.com/supabase/supabase/pull/27612

Link: https://supabase.com/dashboard/project/_/editor

Support showing all entity types in the database/tables page

PR: https://github.com/supabase/supabase/pull/27749

Link: https://supabase.com/dashboard/project/_/database/tables

Other improvements and bug fixes

More granular project statuses for pausing and restoration (PR)
Support filtering projects by status (either active or paused) (PR)

Account

Added instructions on how to change your email for your account (PR)

Storage

Fix uploading a folder to the storage explorer causes all files to be uploaded in a flat list with the folder name prefixed to the file name (PR)

Optimized table editor select query when cutting off column values (PR)

PR: https://github.com/supabase/supabase/pull/27268

Added labels and grid to SQL editor charts (PR)

Dashboard Weekly Updates [17/06/24 - 24/06/24]

Jun 24, 2024

Greater clarity on costs when creating new projects

One of our bigger papercuts in terms of billing is customers not understand compute pricing and that they cannot launch unlimited projects for $25 in total per month. Customers also get confused with "Compute Hours" on their bill. The changes aim to alleviate any "surprise" compute charges and serves as kaizen improvement.

Changes involved are only applicable to paid plan organizations, as it's irrelevant for free plan organizations.

Link: https://supabase.com/dashboard/new/_

Address Table Editor "resorting" of rows when rows are updated and no active sorts applied

If you've tried updating a table via the Table Editor without an active sort in place, you'd have noticed that the rows seem to re-sort themselves, specifically the row that you were updating. While this is because rows are returned in an unspecified order without a sort clause from the select query, it certainly must've been a confusing UX. We've alleviated this problem by setting a default sort by clause when reading the table via the Table Editor, which will get overriden once you've set a sort via the UI.

PR: https://github.com/supabase/supabase/pull/27097

Link: https://supabase.com/dashboard/project/_/editor

Other improvements and bug fixes

Greater granularity in project statuses, specifically for when project is restoring, when restoring failed and when pausing failed (PR)

Table searching is now case in-sensitive (PR)
Add duplicate table CTA (Similar to the Table Editor) (PR)

Auto limit fix for when SQL query has "fetch first n rows only" (PR)
Preserve whitespace in results (PR)

Query Performance

Support index advisor for queries from Postgrest (PR)

Org Billing

Users can now only manage a single tax ID instead of multiple (PR)

Paused Free Plan projects are restorable for 90 days

Jun 24, 2024

This only impacts projects on the Free Plan because projects in any of the paid plans cannot be paused.

Beginning June 24, 2024, we're updating some project pause/restore behavior:

paused Free projects are restorable for 90 days following their pause date
any Free projects paused before June 24 will be able to restore at any point before September 22, 2024 so they have a full 90 days from when this announcement is made
once a project is no longer restorable, the "restore" option is replaced with an option to download the latest logical backup, taken right before the project is paused, and all Storage objects

This change is being made to enable us to maintain high development velocity on the platform. Previously, paused projects could be restored indefinitely. That creates the need for the platform to remain fully backwards compatible with outdated versions of Postgres and associated extensions. The update allows us to provide a reasonable pause/restore window while gaining the ability to evolve the platform.

Edge Functions are now Deno 1.43 compatible

Jun 18, 2024

Supabase Edge Runtime version 1.54 is compatible with Deno 1.43.

Supabase's hosted platform was upgraded to use this release when serving Edge Functions starting today.

If you're using Supabase CLI for local development latest stable release 1.176.10, it adds compatibility for Deno 1.43.

How do I find which version of Edge Runtime I'm running?

Supabase CLI (local)

When you run supabase functions serve, it should show the current version of Edge Runtime used (and its Deno compatibility)


_10> supabase functions serve
_10
_10Setting up Edge Functions runtime...
_10Serving functions on http://127.0.0.1:54321/functions/v1/<function-name>
_10Using supabase-edge-runtime-1.54.2 (compatible with Deno v1.43.0)

Hosted Platform

You can check the served_by field in log events to see which Edge Runtime version was used to serve your function .

We try our best to maintain backward compatibility in these upgrades. If you're experiencing any issues, please feel free to make a support request

Developer Updates - May 2024

Jun 18, 2024

Supabase underwent Consolidation Month™ to focus on initiatives that improve the stability, scalability, and security of our products. We also have exciting product announcements that we can’t wait to share. Let’s dive in!

Consolidation Month™

We kicked off Consolidation Month (no it’s not actually trademarked) during the month of May. During this time, every product team within Supabase addressed outstanding performance and stability issues of existing features. Here’s a small subset of initiatives and product announcements as part of Consolidation Month:

Auth Launches @supabase/ssr for Better SSR Framework Support

The newly released @supabase/ssr package improves cookie management, developer experience, and handling of edge cases in various SSR and CSR contexts. We’ve added extensive testing to prevent issues that users experienced with the @supabase/auth-helpers package.

pgvector v0.7.0 Release Features Significant Performance Improvements

pgvector v0.7.0 introduced float16 vectors that further improve HNSW build times by 30% while reducing shared memory and disk space by 50% when both index and underlying table use 16-bit float. The latest version also adds sparse and bit vectors as well as L1, Hamming, and Jaccard distance functions.

Edge Functions Improves Memory Handling

The Edge Functions team has significantly reduced the error rate for functions encountering memory issues by implementing better safeguards. This has greatly minimized errors with the 502 status code. Additionally, status codes and limits are now documented separately.

Status Codes | Limits

Dashboard Supports Bigger Workloads as Projects Grow

The Supabase Dashboard is now better equipped to handle your projects, regardless of their size. We have implemented sensible defaults for the amount of data rendered and returned in the Table and SQL Editors to prevent browser performance issues while maintaining a snappy user experience.

Go here for latest update

Realtime Standardizes Error Codes

Realtime now emits standardized error codes, providing descriptions of their meanings and suggested actions. This enhancement improves your error-handling code and helps to narrow down whether the issue lies with the database, Realtime service, or client error.

Realtime Error Codes

RLS AI Assistant v2

We’ve improved the prompt and output of our RLS AI Assistant by including best practices found in our RLS docs and upgrading to OpenAI’s newest GPT-4o. We’ve also introduced numerous test scenarios to make sure you’re getting the right security and performance recommendations by comparing parsed SQL with the help of pg_query.

Pull Request

Quick product announcements

[Functions] JSR modules are supported in Edge Functions & Edge Runtime [Announcement]
[Functions] Debug Edge Functions with Chrome DevTools [Docs]
[Functions] Use HonoJS web Framework with Edge Functions [Docs]
[Analytics] Log Drains is in Private Alpha [Announcement]
[Realtime] Realtime Authorization Early Access [Announcement]
[Docs] SQL to PostgREST API Translator [Docs]
[Client libs] Supabase JavaScript SDK Sentry Integration now supports Sentry SDK v8 [Commit]

Made with Supabase

GroupUp - organize social gatherings to hang out with friends [Website]
HabitKit - track habits, view daily progress, and stay motivated as you work towards your goals [Website]
Meteron AI - LLM and generative AI metering, load-balancing and storage [Website]
EQMonitor - An app that displays and notifies earthquake information in Japan [Website]
GitAuto - AI software engineer that writes, reads, and creates pull requests [Website]
GenPPT - Free AI powerpoint presentation generator to help you create beautiful slides in minutes [Website]

Community highlights

Make your queries 43,240x faster [Video]
Exploring Support Tooling at Supabase: A Dive into SLA Buddy [Article]
FlutterFlow SuperApp Complex Template : Developing Feed with Supabase [Video]
How We Use Supabase in Betashares Direct [Video]
AI Assistant to Chat with Supabase Database [Video]
How to use wrappers in Supabase [Video]
Build Realtime Apps with Next.js and Supabase [Video]
SvelteKit & Supabase Project Build [Video]
Next.js 14 x Supabase — Build a Team component using shadcn [Article]
Create a Real Time Chat App with Supabase and Angular [Article]

This discussion was created from the release Developer Updates - May 2024.

Dashboard Weekly Updates [03/06/24 - 10/06/24]

Jun 11, 2024

You might be wondering what we've been up to the past few weeks when we'd usually have some cadence in our weekly updates with our GitHub discussion updates - the team at Supabase had decided to commit to a month of consolidation by putting our efforts into each of the following pillars: Alerting, Testing, and Scaling. Let's jump right in to see what this means for the Dashboard! 💪🏻

🚨 Alerts: Enabling proactive resolution to issues that users run into

We want to find out about bugs before you do. In an effort to lower the time between deploying a bug and fixing it, we’ve set up some alerts that will enable us to be more proactively catch bugs, in particular for show-stopping problems (e.g that awful “A client side exception has occurred” screen)!

Added alerts for critical points of failures (PR) This includes any errors that will completely prevent you from using the Supabase dashboard.
Added alerts for full page client crash events with a custom error boundary (PR) Having a custom error boundary also allows us to potentially provide contextual hints/resolutions to the problem faced, such as what we did in this PR.

🛠️ Testing: Identifying and covering critical points of failure

We believe in ensuring that minimally our critical paths are covered by tests as opposed to ensuring our dashboard has 100% test coverage. Anything that might completely block our users from doing what they need to do should be caught as much as possible before reaching production.

Moved to Vitest + Integrating packages to make writing tests easier (PR) We’ve revamped our current test set up to use Vitest instead of Jest and have integrated Mock Service Workers (MSW) and next-router-mock. These are all to support writing better tests easier, and also to reduce the amount of configuration we need to set up the tests.
Expanded on Playwright for E2E tests (PR) We previously had a couple of Playwright tests written over in our tests repository that we’ve decided to shift over to our main repository. We’re also in the midst of writing more tests and making them public

📈 Scaling: Supporting bigger workloads as the project grows

The dashboard should be able to keep up with your projects, no matter how big they grow - and even if unable to, it should never block you, or leave you feeling confused. This effort involved several solutions: gracefully failing if unable to handle large workloads, better observability, or even just better error handling to allow our users to self-service most errors. We were able to get improvements out for several common issues. Check out each individual PR for more information 😄

Rendering large column data within the Table Editor (PR) We’re now limiting rendering each text/JSON based column data in the table editor at a max of 10kB when initially viewing the table, which should alleviate browser performance issues when rendering tables with large row data. You may load the entire column data on demand instead.
Handling large results within the SQL editor (PR) A limit parameter will now be added as a suffix to select queries that are run in the SQL editor, which should prevent the browser performance from degrading when trying to query too much data. The limit parameter can be optionally removed if your intention might be to pull data in greater quantity.
View ongoing queries in the SQL editor and support terminating them (PR) This came in response to a user who accidentally ran a large query through the SQL editor which ended up in the API request timing out, giving the impression that the query stopped running when in fact it was still running on the database in the background. This should help surface such problems and give the tooling required to abort erroneous queries.
Contextual errors when something goes wrong (PR) While the attached PR was more of a POC, this is the direction we want to move towards to by providing contextual information and suggest possible resolutions whenever users run into an error

Of course consolidation is not a one time event, but an ongoing effort that our team is committing to in parallel to shipping new and exciting features. We hope that as our users, you will all be able to benefit from this with less blockers to keep you from building cool stuff 🙂

As always, if you have any feedback for us - we're just a message away through the feedback widget to the top right corner of the dashboard! We're always listening 👂🏻 (as in reading 👀).

@supabase/ssr updates and roadmap towards v1.0.0

Jun 5, 2024

Hey everyone,

I'm Stojan a member of the Supabase Auth team, bringing some updates about what's next with @supabase/ssr. This is the recommended package that helps you use the Supabase JavaScript client with SSR frameworks such as NextJS, Remix, SvelteKit and others.

We've been quite busy recently gathering feedback, reviewing common complaints and bugs with the package, and using it in the popular SSR frameworks. We've identified a few areas needing improvement and we've already started implementing them.

The package is still on major version 0, indicating its beta status. We plan to move it to major version 1 in the coming months making it the preferred way of using the Supabase JavaScript library in your favorite SSR framework.

First, we'll extract @supabase/ssr's code from the auth-helpers repository into its own. We’re doing this because:

@supabase/auth-helpers-x (like for NextJS) is no longer supported by the team, as we expect people to move to @supabase/ssr.
It's no longer about "auth-helpers," but rather about how you can most effectively and ergonomically use the Supabase Client in various SSR and CSR contexts.
A standalone repo makes it easier for the community to contribute and for us to track issues.

We're going to release a fairly ground-up reimplementation of the package. This should come as version 0.4.0 around mid-June. We've received a lot of signal in the past months from developers and the community about possible improvements for developer ergonomics and better handling for edge cases.

The reason for this change is because @supabase/ssr is really just a thin layer for cookie management on top of @supabase/supabase-js. We've identified some improvements that reduce odd and difficult-to-diagnose behavior. The new implementation will boast over 90% test coverage, including testing for issues that we’ve seen commonly reported so far.

As part of the new implementation, we are changing the API. The old API will be deprecated when we reach v1.0.0. This is to ensure the best possible experience for both developers and users. For most use cases and happy paths, the deprecated API will continue working during the phase-out, but we encourage switching as soon as possible. Once we release v1.0.0, major version 0 will no longer be maintained.

The change in the API is quite simple, so here’s an example of how it will look like. Instead of defining three cookie access methods get, set and remove like so:


_13createServerClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
_13	cookies: {
_13		get: async (name) => {
_13			// ...
_13		},
_13		set: async(name, value, options) => {
_13			// ...
_13		},
_13		remove: async(name) => {
_13			// ...
_13		}
_13	}
_13})

You would need to define two — getAll and setAll cookie access methods like so:


_10createServerClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
_10	cookies: {
_10		getAll: async() => {
_10			// return all cookies you have access to
_10		},
_10		setAll: async(cookiesToSet: { name: string; value: string; options: CookieOptions; }[]) => {
_10			// set the cookies exactly as they appear in the cookiesToSet array
_10		}
_10	}
_10})

Note that for createBrowserClient nothing needs to be done in most cases, it automatically works with the document.cookie API.

The change should be trivial for most SSR frameworks, and we'll be sure to update the guides to instruct you on how to change your code into this new way of accessing cookies.

Thanks for all your feedback! Feel free to ask any questions below!

Log Drains Private Alpha

May 22, 2024

Log drains is currently private alpha, and is available for Teams and Enterprise customers. We are still firming up the pricing and documentation, however it will likely involve a flat fee and variable egress usage. This will be announced separately through official channels.

We will be supporting Datadog as our initial provider.

The following destinations are in the works:

Elastic/Filebeat
Syslog

We are currently onboarding interested customers manually, so please fill out this form to get started: https://forms.supabase.com/logdrains.

Updated deployment instructions for supabase-grafana monitoring application

May 17, 2024

We've released a fix to the deployment instructions for the supabase-grafana monitoring application.

If you're ingesting the metrics endpoint into your pre-existing managed infrastructure without using the supabase-grafana app, this change does not affect you. If you're running the supabase-grafana app using the docker-compose mechanism, you are also not affected.

Fly applications launched off the repository between December 10, 2023, and May 16, 2024 are impacted, and will experience:

Fly application being shut down after periods of inactivity of a few minutes (default Fly.io behaviour)
Historical data will not be persisted after such a shutdown

The fix to the deployment instructions ensures that a persistent volume is created to store the data on, which prevents loss in case of a machine shutdown or restart. Additionally, autoshutdown behaviour is disabled, in order to prevent the app from being paused due to inactivity.

In order to fix an existing, already deployed Fly application, you can edit its configuration to disable auto_stop_machines, and create a persistent volume, and mount it at /data (similar to the updated deployment instructions). Please note that as the newly created persistent volume will be empty to start, any existing metrics data will not be preserved as part of this change. If doing so is necessary, you can initially mount it at a separate path, copy the data over, and finally mount it at /data.

If you need further help, please reach out to Support via https://supabase.help

Dashboard Weekly Updates [06/05/24 - 13/05/24]

May 15, 2024

Conversational AI assistant in the SQL Editor

This was previously behind a feature flag but we're now making this available by default, which will replace the existing single prompt UI that you saw previously at the top of the SQL editor. Once again, thank you all so much for the feedback that you've left us - we really appreciate them and they definitely do help in guiding us towards the ideal dashboard experience for everyone. 🙂🙏

We're also aware that the feature preview functionality is missing in the local set up - rest assured we're looking into it and hope to get a fix out soon for everyone!

PR: https://github.com/supabase/supabase/pull/23142

Link: https://supabase.com/dashboard/project/_/sql

A step towards slightly more contextual error messages

A topic that came up in one of our discussions internally was regarding self-serviceability, and we realised that our error messages could do a much better job than just informing users what the error is about - especially when their errors from Postgres directly and the messages could be slightly cryptic for those not familiar with Postgres (yet 😉). The PR linked here is just a small idea and example for what we plan to do with error messages in the future, by giving users more context about the errors like possible solutions and links to relevant documentation. Hopefully this will make using the dashboard slightly more easier 🙂

PR: https://github.com/supabase/supabase/pull/23135

Link: https://supabase.com/dashboard/project/_/editor

Other improvements and bug fixes

Branching

Disable branch reset while branch is initializing (PR)

Allow searching for schema and tables when creating indexes (PR)
Allow SQL language for writing database functions (PR)

Developer Updates - April 2024

May 8, 2024

Here’s everything we shipped during our GA week:

Day 1 - Supabase is officially launching into General Availability (GA)

Supabase has moved to General Availability (GA) with over 1 million databases under management and over 2,500 databases launched daily. We’ve been production ready for years and now we are fully confident that we can help every customer become successful, from weekend projects to enterprise initiatives at organizations like Mozilla, 1Password, and PwC.

Full announcement | Video announcement | X space

Day 2 - Supabase Functions now supports AI models

Supabase Functions has added a native API that makes it easy to run AI models within your functions while removing nasty cold starts. You can use the gte-small embedding model to generate text embeddings or bring your own Ollama server to tap into many more embedding models and Large Language Models (LLMs) like Llama3 and Mistral. Soon we’ll provide hosted Ollama servers so you won’t have to manage them yourselves for a more seamless experience.

Day 3 - Supabase Auth now supports Anonymous sign-ins

Supabase Auth heard your requests and went to work building anonymous sign-ins which enable you to create temporary users that have yet to sign up for your application. This lowers the friction for visitors to use your application while making it easy to convert them to permanent users once they’re hooked.

Day 4 - Supabase Storage now supports the S3 protocol

Supabase Storage already has standard and resumable uploads and now supports the industry standard S3 protocol enabling multipart upload and compatibility with a myriad of tools such as AWS CLI, Clickhouse, and Airbyte for a wide array of use cases.

Day 5 - Supabase Security & Performance Advisor

Supabase has managed over 1 million databases over the last four years and has seen all manner of use cases with common pitfalls that we’re helping our customers address with our Security, Performance, and Index Advisors. These Advisors will help to surface and fix insecure database configurations and recommend database and query optimizations to keep your database secure and performant for your mission critical workloads.

Full list of winners | All the submissions

GA Week Hackathon Winners

We are delighted that so many high quality projects were submitted but in the end there could only be one Best Overall Project. The decision wasn’t easy but the Supabase panel of judges chose vdbs (vision database SQL) for the honorific. Congratulations 👏 to @xavimonp who will receive the prize of Apple AirPods.

One more thing from GA Week

Just kidding, there’s always more than one. Here’s more awesome things we shipped:

Community Highlights

Changing Databases 5 Times in 48 Hours Boosted Our Launch to 35,000 Views [Article]
Crazy new Supabase feature: Understand and learn about anonymous users [Video]
Support unstructured data in Postgres with JSON columns [Video]
Build an AI-powered blogging platform (Next.js, Langchain & CopilotKit) [Article]
How to Secure Your Supabase Database and Storage [Blog post]
Self-host Protomaps PMTiles on Supabase Storage [Video]
Supabase Realtime - How to deal with multiplayers in Next.js [Blog post]
The Hard Parts of Building an Application, Made Easy with Supabase [Article]

This discussion was created from the release Developer Updates - April 2024.

JSR modules are supported in Edge Functions & Edge Runtime

May 7, 2024

You can now use JSR packages in your Edge Functions. JSR is a modern package registry for JavaScript and TypeScript created by the Deno team. With JSR support, you can use the latest versions of popular Deno packages like Oak.

How to use:


_10import { Application } from "jsr:@oak/oak/application";
_10import { Router } from "jsr:@oak/oak/router";

For local development, you will need to update Supabase CLI for the version v1.166.1 or above.

Edge Functions also supports using NPM and deno.land/x packages. If you are already using them, no changes are needed.

Dashboard Weekly Updates [22/04/24 - 29/04/24]

Apr 30, 2024

Other improvements and bug fixes

We've been focusing on improving existing features on the dashboard and fixing some issues over the past week, so while we've got nothing shiny to shout out about, here's still a list of things that we've shipped! 🙂 As always, feel free to let us know if there's something that you guys really want to see in the dashboard - we'll see how we can make it happen 😉

Feedback widget will not clear its contents when closing until explicitly cleared or submitted [PR]

Reinstate link button for foreign keys in table editor side panel [PR]
Fix creating foreign key on new column after changing column's name [PR]

Set column width of results to be relative to column content length [PR]

Authentication

Added Create policy CTA under each table for convenience [PR]

Storage

Added file size validation against project's upload limit when uploading files in dashboard [PR]

PR: https://github.com/supabase/supabase/pull/22289

Query performance: Fix searching via role and query [PR]
Query performance: Add db inspect docs link for visibility to aid in helping identify potential Postgres issues [PR]
Enumerated types: clean up form field when reopening create enumerated type panel [PR]
Tables: Add ellipses to table descriptions to prevent odd wrapping for long descriptions [PR]

Dashboard Weekly Updates [15/04/24 - 22/04/24]

Apr 22, 2024

Supabase GA Week just wrapped up but the shipping doesn't! This just summarises what have been shipped over the last week - and more 😉

Auth support for anonymous sign-ins

Supabase Auth now supports anonymous sign-ins, which can be used to create temporary users who haven’t signed up for your application yet! This lowers the friction for new users to try out your product since they don’t have to provide any signup credentials.

Storage support for S3 protocol

Supabase Storage is now officially an S3-Compatible Storage Provider, and now you can use any S3 client to interact with your buckets and files: upload with TUS, serve them with REST, and manage them with the S3 protocol.

3 new advisors to your database

We've added a Security Advisor, a Performance Advisor and a bonus Index Advisor as tools that can help improve your database, more specifically:

Security Advisor: for detecting insecure database configuration
Performance Advisor: for suggesting database optimizations
Index Advisor: for suggesting indexes on slow-running queries

4 new database foreign data wrappers

We've added support for data wrappers with Auth0, Cognito, Microsoft SQL Server, and Redis! Connect to these external data sources and query them directly from your database.

Link: https://supabase.com/dashboard/project/_/database/wrappers

Updating of some projects pages to more appropriate sections

We've renamed and shifted a couple of pages within a project to sections which we believe are more appropriate and relevant. These include:

Column Priveleges: Shifted from Auth section to Database section
Database Replications: Renamed to Publications within the Database section
Query Performance Reports: Shifted from Reports section to Database section

We've also added more appropriate sections within the Database section in hopes to make things easier to find!

PR: https://github.com/supabase/supabase/issues/22835

PR: https://github.com/supabase/supabase/pull/22486

An option to submit a request to delete your account

If comes the day that you'd no longer want to use Supabase anymore (hopefully not!) and want to be removed from our systems entirely, feel free to submit a request to delete your account through the account preferences page.

Link: [https://supabase.com/dashboard/account/me](https://supabase.com/dashboard/account/me

Other improvements and bug fixes

Added project connection instructions for Vite [PR]

Platform Updates: March 2024

Apr 6, 2024

Join us for a Special Announcement April 15-19

We’re making a Special Announcement on April 15th with a few more surprises throughout the week. Claim your ticket today so you don’t miss out and enter for a chance to win a set of AirPods Max.

Claim your ticket

Increased Supavisor connection pooler limits

We’ve increased the Supavisor client connection limits, the number of concurrent clients that can connect to your project’s pooler, for projects on Small, Medium, Large, and XL compute instances while pricing remains unchanged.

Conversational AI assistant now available in SQL Editor

Introducing a conversational AI assistant in the SQL Editor to help you write and iterate on your queries. This is currently under a feature preview and can be enabled with instructions here.

Supavisor pooler port 6543 is transaction-mode only

We’re simplifying Supavisor connection pooler ports and modes so that port 6543 is only transaction mode and port 5432 continues to be only session mode. If you have pool mode set to session we recommend you switch to pooler port 5432 and set the mode to transaction.

Pull request

Migration to v2 platform architecture

You may have noticed improved performance from your database over the last couple of weeks. We made some architectural changes to free up resources for your Postgres instance by removing Storage, Realtime, and Pgbouncer from your instance and each are replaced with an equivalent multi-tenant solution, including our new Supavisor connection pooler.

Implementing semantic image search with Amazon Bedrock and Supabase Vector

In this post we'll be creating a Python project to implement semantic image search featuring Amazon Bedrock and Amazon Titan’s multimodal model to embed images and Supabase Vecs client library for managing embeddings in your Supabase database with the pgvector extension.

PR: https://github.com/supabase/supabase/pull/21806

Quick Product Announcements

[Postgres Tooling] vector (pgvector) upgraded to v0.6.2 enables faster HNSW index builds using more parallel workers [Commit]
[Postgres Tooling] pg_cron upgraded to v1.6.2 enables sub-minute schedules [Pull request]

Made With Supabase

location-tRacer - Supabase Realtime live location sharing app [GitHub]
Talk to your docs - An example agent providing help on your GitHub documentation [GitHub]
Feedbase - Open-source solution for collecting feedback & communicating updates [GitHub]
Wacky Wordcraft - Create wacky stories with some help from AI [Twitter]
Capgo - Instant updates for Capacitor apps. Ship updates, fixes, changes, and features within minutes [Website]

Community Highlights

Building an Investor List App with Novu and Supabase [Blog post]
3 reasons you should use Postgres Functions and Transactions [Video]
Add image support to Flutter web application with Supabase Storage [Video]
How to set up a secure Supabase project [Blog post]
Dynamic Role and Permission Management in Supabase: Enhancing Security and Flexibility [Blog post]
Simulate Supabase Postgres RLS (Row Level Security) [Blog post]
Monitor Supabase databases and Edge Functions [Blog post]

This discussion was created from the release Platform Updates: March 2024.

Realtime Broadcast and Presence Authorization

Apr 4, 2024

Update

Discussion has been updated with solution chosen.

Realtime Authorization for Broadcast and Presence is now available in Public Beta.

See the official documentation.

Overview

This post explains how authorization works for Realtime Broadcast and Realtime Presence.

This allows you (the developer) to control access to Realtime Channels. We use Postgres Row Level Security to manage access. Developers create Policies which allow or deny access for your users.

Usage

Creating Realtime Policies

Using Studio’s SQL editor you can set RLS rules against the table realtime.messages which will define the rules for your users.


_10CREATE POLICY "presence sync and broadcast listen to authenticated users"
_10ON realtime.messages FOR SELECT
_10TO authenticated
_10USING ( true );
_10
_10CREATE POLICY "presence track and broadcast send to authenticated users"
_10ON realtime.messages FOR INSERT
_10TO authenticated
_10WITH CHECK ( true );

Since you are using RLS policies you can do more complex examples.

In a scenario where you have a schema with a table for rooms and one that creates an association between rooms and users.

Example schema to be used in RLS policies

We'll use this example schema to be showcase RLS policies limiting Realtime functionality

We can build more complex RLS rules using this information:


_26-- Set permission for authenticated users to only listen for Broadcast messages
_26CREATE POLICY "authenticated can listen to broadcast only on their topics"
_26ON realtime.messages FOR SELECT
_26TO authenticated
_26USING ( 
_26	exists(
_26      select 1
_26      from public.rooms r join public.rooms_users ru on r.id = ru.room_id
_26      where ru.user_id = auth.uid()
_26        and r.name = realtime.topic()
_26        and realtime.messages.extension = 'broadcast'
_26  )
_26);
_26-- Set permission for authenticated users to only write for Broadcast messages
_26CREATE POLICY "authenticated can write to broadcast only on their topics"
_26ON realtime.messages FOR INSERT
_26TO authenticated
_26WITH CHECK ( 
_26	exists(
_26	  select 1
_26    from public.rooms r join public.rooms_users ru on r.id = ru.room_id
_26    where ru.user_id = auth.uid()
_26      and r.name = realtime.topic()
_26      and realtime.messages.extension = 'broadcast'
_26  )
_26)

Testing Authorization

Now to test it we can use a quick deno script by creating a index.ts


_21// Run with deno run --allow-net --allow-env --allow-read --allow-ffi index.ts
_21import { createClient } from "npm:@supabase/supabase-js@2.38.5";
_21const url = "https://<project_ref>.supabase.com";
_21const apikey = "<api_key>";
_21
_21const client = createClient(url, apikey);
_21
_21const channel = client.channel("channel_1", {
_21  config: { broadcast: { self: true }, private: true},
_21});
_21channel
_21  .on("broadcast", { event: "test" }, (payload) => console.log(payload))
_21  .on("presence", { event: "join" }, (payload) => console.log(payload))
_21  .on("presence", { event: "leave" }, (payload) => console.log(payload))
_21  .subscribe((status: string, err: any) => {
_21    if (status === "SUBSCRIBED") {
_21      console.log("Connected!");
_21    } else {
_21      console.error(err);
_21    }
_21  });

This will return an error with the message You do not have permissions to read from this Topic

But if we change our code to pass along an authenticated user, then we will be able to connect and receive / send messages.


_28import { createClient } from "npm:@supabase/supabase-js@2.38.5";
_28const url = "https://<project_ref>.supabase.co";
_28const apikey = "<api_key>";
_28
_28const client = createClient(url, apikey);
_28
_28await client.auth.signInWithPassword({
_28  email: "<email>",
_28  password: "<password>",
_28});
_28
_28client.realtime.setAuth(
_28  (await client.auth.getSession()).data.session.access_token
_28);
_28const channel = client.channel("channel_1", {
_28  config: { broadcast: { self: true }, private: true },
_28});
_28channel
_28  .on("broadcast", { event: "test" }, (payload) => console.log(payload))
_28  .on("presence", { event: "join" }, (payload) => console.log(payload))
_28  .on("presence", { event: "leave" }, (payload) => console.log(payload))
_28  .subscribe((status: string, err: any) => {
_28    if (status === "SUBSCRIBED") {
_28      console.log("Connected!");
_28    } else {
_28      console.error(err);
_28    }
_28  });

Do not forget that RLS policies can use other tables in them so this will give you all the flexibility you need to better fit your use case but be aware of the performance impact of heavy RLS queries or non-indexed fields.

Migrating from Public Channels

On connect, you need to send in the configuration that the channel will be private: true

Client library

We’re working on the next version actively so we can provide a good developer experience.

Please check the latest next version at https://www.npmjs.com/package/@supabase/realtime-js?activeTab=versions

This library as changed the configuration settings to add private: true on channel connect to determine if the user will be connecting an RLS checked channel.

How it works

Connection context

When you connect with Realtime we set a connection configuration with your JWT, Topic and Headers using the following query:


_10SELECT
_10	set_config('role', $1, true),
_10	set_config('realtime.topic', $2, true),
_10	set_config('request.jwt', $4, true),
_10	set_config('request.jwt.claims', $6, true),
_10	set_config('request.headers', $7, true)

This query is only run when you connect to a topic.

We’re also providing a new function to easily fetch the realtime.topic configuration with


_10SELECT realtime.topic();
_10
_10-- Usage example
_10CREATE POLICY "authenticated users can only write to topic named foo"
_10ON realtime.messages FOR INSERT
_10TO authenticated
_10WITH CHECK ( realtime.topic() = 'foo' );

Applying RLS Policies

To achieve RLS checks on your Realtime connection we created a new table in the realtime schema to which you will be able to write RLS rules against it to control your topics extensions.

You won’t see any entries recorded in this table as we rollback the changes made to test out RLS policies to avoid creating clutter in your database.

Increased Supavisor Client Connection Limits Across Paid Plans

Apr 4, 2024

Supavisor, Supabase's multi-tenant connection pooler deployed to regional clusters, became production ready back in December 2023. You can read the announcement here.

Since then, we've migrated Supabase projects from PgBouncer, single tenant connection pooler deployed to the project's instance, to Supavisor.

However, we kept the previous client connection limits from PgBouncer during the transition across all compute instances.

Today, we're happy to announce that we've increased this limit for compute instances Small, Medium, Large, and XL so your projects can take advantage of additional client connections while pricing remains unchanged. These new limits have already been applied to all existing projects and any new projects spun up.

Here's a quick breakdown:

Compute Size	Previous Client Limits	New Client Limits
Small	200	400
Medium	200	600
Large	300	800
XL	700	1,000

For a more complete breakdown of your compute instance resources head over to the Compute Add-ons page.

Dashboard Weekly Updates [18/03/24 - 25/03/24]

Mar 26, 2024

Update to the UI for RLS policies

We've been looking into improving the UX for the RLS policy UI after going through feedback of the community's struggles with RLS in general, and this is the next step that we're taking to streamline the UX.

What we're calling as a "hybrid" editor (for now), you'll be able to see the corresponding SQL query for creating or updating your RLS policies while you're editing the policy via the input fields. And if you'd like even greater control, there's always the "Open in SQL Editor" button as an escape hatch where you can edit the SQL query in its entirety.

Templates are now right beside the editor as well, so you no longer have to click back and forth between templates and the editor.

We've always seen the dashboard as more than just a database adminstration tool, but also potentially an educational platform for developers to pick up the SQL language as they build out their database, and we hope that the changes here will help make that even easier.

Link: https://supabase.com/dashboard/project/_/auth/policies

Connection pooler on port 6543 is set to transaction mode permanently

Previously, connection pooler's port 6543 can be set to either transaction or session mode under your project's database settings. This change makes it easier to distinguish between pooler modes and ports by only enabling transaction mode on port 6543 while maintaining session mode on port 5432.

If your using port 6543 and your project's pooler mode is transaction then you won't be able to set the mode to session. You can use port 5432 for session mode.

If your using port 6543 and your project's pooler mode is session then we strongly advise that you use port 5432 for session mode and change the mode to transaction. Once this setting is saved you won't be able to set session mode on port 6543.

PR: https://github.com/supabase/supabase/pull/22150

Link: https://supabase.com/dashboard/project/_/settings/database#connection-pooler

Other improvements and bug fixes

[General]

Home page connect modal fix broken link under pooler mode to Database Settings [PR]
Fix toast messages to handle really long messages, and support closing them in such scenarios [PR]

[Auth]

Fix applying table privileges to incorrect table if there any more than 1 table with the same name in different schemas [PR]

[Table Editor]

Prevent updating RLS via GUI for tables under protected schemas [PR]
Support updating column "is unique" when editing table in side panel [PR]
Fix support NULL values when importing data via CSV text [PR]
Ensure that table and column names are trimmed for whitespaces when saving [PR]

[Storage Explorer]

Fix delete bucket modal styling when bucket name is long [PR]
Fix deleting parent folder not deleting child folders despite child folders being empty [PR]

[Database Pages]

Fix inability to manage foreign keys [PR]
Validate enumerated types to ensure names do not conflict with native PG data type names [PR]
Validate enumerated types to ensure names do not conflict with native PG data type names [PR]
Fix Stripe foreign data wrapper to support selecting a rowid_column, addresses the issue of not being able to update stripe foreign tables [PR]

Migration to v2 platform architecture

Mar 20, 2024

In our previous platform architecture, our Storage, Realtime, and connection pooler (PgBouncer) services were bundled together, with a single instance of each service per project.

For our v2 architecture, we’ve “unbundled” these services, moving to a multi-tenant model, where a single instance of each service serves many projects:

This frees up as much resources as possible for your Postgres databases, while enabling us to offer more resource intensive features for these services, and opens the door to capabilities such as zero-downtime scaling.

With Supavisor replacing PgBouncer, along with some other key optimizations, the final pieces of our v2 architecture are now ready.

Paid plan rollout (completed)

We’ve already fully rolled out our v2 architecture to paid plan projects. You now have more resources available, for the same price that you’ve been paying.

Free plan gradual rollout (20 March 2024 onwards)

20 March 2024: Newly created or unpaused projects will use v2 architecture
28 March 2024: Existing projects will start being migrated to v2 architecture

This will be a gradual rollout - we will email you at least one week before your project is scheduled to be migrated.

Your action for projects scheduled to be migrated

For newly created or unpaused projects on the Free Plan, no action is required.

For existing projects on the Free Plan, up to a few minutes of downtime is expected for the migration. For each of your projects, we’ll identify the 30-minute maintenance window where your project had the least database queries over the previous 10 weeks.

You have two choices:

Automatic Migration: If you don't take any action, we plan to do the migration automatically during that maintenance window with the least historical activity.
Manual Migration: Any time before that, you can go to Project Settings > General to see whether/when the maintenance window is scheduled (timings will also be included in the email). There, you may choose to manually restart the project yourself, at a time that is convenient for you. Your project will be restarted on v2 architecture.

Dashboard Weekly Updates [04/03/24 - 11/03/24]

Mar 12, 2024

Conversational AI assistant now available as part of the SQL Editor

As part of our ongoing efforts to introduce the AI assistant across the dashboard, we're bringing the AI assistant to the SQL Editor next! Some of you might have already been using the AI assistant in the SQL Editor through the green bar at the top of the editor - we're sprucing it up by extending it further to a conversational UX. Go back and forth with the assistant and apply the code snippets that you deem to be the most appropriate!

This is currently under a feature preview - you may enable this feature by clicking on the user icon while in a project at the bottom of the side navigation bar and selecting "Feature previews". From there just enable the preview under "SQL Editor Conversational Assistant". And as always, we're incredibly open to any feedback for this, so give us a shout right here!

PR: https://github.com/supabase/supabase/pull/21388

Link: https://supabase.com/dashboard/project/_/sql/new

Other improvements and bug fixes

Fix creating a table will automatically trim for whitespaces (PR)

Fix snippet names not truncating (PR)

Auth Policies

Fix error message not surfacing in new RLS UI from feature preview (PR)

Database Functions

Fix light mode styling for code editor (PR)

Platform Updates: February 2024

Mar 6, 2024

Matryoshka Embeddings: Faster OpenAI Vector Search Using Adaptive Retrieval

Learn about how OpenAI’s newest text embeddings models, text-embedding-3-small and text-embedding-3-large, are able to truncate their dimensions with only a slight loss in accuracy.

Easily Connect to Supabase Projects From Frameworks and ORMs of Your Choice

Connect to Supabase from any framework or ORM with our new “Connect” panel in Studio. This displays simple setup snippets that you can copy and paste into your application. We’ve started with a selection of popular frameworks and ORMs and you can request more by feature request or pull request.

Pull request

PostgREST Aggregate Functions

PostgREST v12 has been released, and with it, comes the release of the highly requested aggregate functions, avg(), count(), sum(), min(), and max(), that is used to summarize data by performing calculations across groups of rows.

Terraform Provider to Manage Resources on Supabase Platform

We’ve created an official Supabase Provider for Terraform to version-control your project settings in Git. You can use this provider in CI/CD pipelines to automatically provision projects and branches and keep configuration in code.

Support for Composite Foreign Keys in Table Editor

We've shifted the management of foreign keys into the Table Editor’s side panel so you can easily see all foreign keys pertaining to a table as well as referencing columns to composite foreign keys.

Pull request

Build a Content Recommendation App With Flutter and OpenAI

Learn about how we built a movie listing app that recommends another movie based on the movie that a user is currently viewing built with Supabase, Flutter, and OpenAI.

Load Testing Supabase

Performance testing evaluates a system's compliance with its performance requirements. It reveals your app’s ability to handle user load, unexpected spikes, or recover from stressful workloads. In this blog post you will learn about how we automated our performance testing.

PR: https://github.com/supabase/supabase/pull/21447

More Studio Updates

Collapsible main sidebar navigation [PR]
Create charts from SQL Editor [PR]
Resizable main tabs in Table Editor and SQL Editor [PR]
View user metadata from the dashboard [PR]
Bulk delete SQL Editor snippets [PR]
Query Performance updates [PR]
Choose a compute option when creating a project (Paid organizations only) [PR]
Logs Explorer facelift [PR]

Quick Product Announcements

[Auth] Require AAL2 to enroll additional factors for MFA enrollment [PR]
[Storage] Increased maximum file upload size to 50GB for paid plans [PR]

Made With Supabase

Inkvestigations is a webgame using LLM technology (currently GPT) to create interactive mystery games [GitHub]
MathPuzzles- a multiplayer game to outsmart your friends [GitHub]
Create a recipe app with Nowa [Article]
Open-source AI wearable device that captures what you say and hear [GitHub]
Brick yourself - turn yourself into a mini-figure [Website]

Community Highlights

SupaVlog: Vlog Application Starter Kit Built with Supabase, Stream, Hookdeck, and Next.js [Article]
Chat with Supabase PostgreSQL using AI [Article]
How to implement Google sign-in on Flutter with Supabase on iOS, Android and the Web [Video]
They're Making Supabase Better... [Video]
How to send welcome emails with Supabase edge functions and database triggers [Article]
How to Create Email Signup and Login Screens in React Native (Expo), ExpressJS, and Supabase [Article]
Integrating Supabase with Flutterflow [Video]
Join the #SupaBuilders movement and never get your project paused again!

This discussion was created from the release Platform Updates: February 2024.

Dashboard Weekly Updates [26/02/24 - 04/03/24]

Mar 4, 2024

Templates added to new RLS assistant

If you're not aware yet, we previously created a new RLS UI that comes integrated with the Supabase Assistant to (hopefully) help everyone write RLS policies easier and faster. This is currently still a feature preview which you can enable by clicking on your user profile at the bottom of the side navigation bar. We're continuously trying to see how we can improve this to make it a much better UX than the current existing RLS policy user flow.

The first gap that we're trying to address is the ease of referencing existing templates that just work out of the box from the current RLS policy flow - those proved to be really useful when trying to understand the syntax of writing policies, and so we added that in to the new RLS UI. Not just that but we also added more complex templates that work better in the new UI than the current one!

The next item that we're looking into is to see what minimal guard rails we can add to make writing RLS policies even less intimidating since the new UI expects only SQL input. One of the aims of the dashboard is to guide our users to not be afraid of SQL no matter the level of proficiency and we hope that we'll be able to cook up the ideal UX that will allow everyone to write SQL with confidence.

Link: https://supabase.com/dashboard/project/_/auth/policies

https://github.com/supabase/supabase/assets/8291514/070cb030-d249-404d-82cd-3ba92d9309f3

We received many feedback that the icons alone in the navigation bar are not too intuitive in understanding what page they're navigating too. So finally, we're adding some textual cues that show up on hover to the navigation bar in hopes to make navigating around the dashboard easier!

PR: https://github.com/supabase/supabase/pull/21550

PR: https://github.com/supabase/supabase/pull/21638

Make charts in the SQL editor

For the users who leverage on SQL to analyze data, this should be useful for you! You can now plot your data points through the SQL editor after running your query. Choose which columns to be your axes and you're good to go. As always - feel free to drop any feedback for us on this! We're keen to see how else we can make this feature better and stronger 😄

Link: https://supabase.com/dashboard/project/_/sql/new

Foreign Key Management re-introduced into the Column side panel editor

We previously made an update in the Table Editor to shift the management of foreign keys to the table editor as an effort to properly support composite foreign keys. This understandably caused the UX to suffer as we received many feedback around creating simple 1:1 foreign key relations much more troublesome. We've thus re-introduced being able to manage your foreign keys while editing a column! Thank you so much for everyone's feedback around this - it's something that we genuinely appreciate our community for! 🙏

PR: https://github.com/supabase/supabase/pull/21683

Link: https://supabase.com/dashboard/project/_/editor

Toggle intellisense for the SQL editor

Intellisense for the SQL editor was always enabled by default for everyone, but we're now making this a toggleable feature - this is more specifically useful for large projects with many tables as we've noticed the amount of data we try to load into intellisense causes the SQL editor to slow down noticeable (likely due to browser memory issues).

PR: https://github.com/supabase/supabase/pull/21643

Link: https://supabase.com/dashboard/project/_/sql/new

Other improvements and bug fixes

Schema Visualizer

Added legends to the schema visualizer and align icons properly [PR]

Dashboard Weekly Updates [19/02/24 - 26/02/24]

Feb 26, 2024

Paid organizations can now launch projects on bigger compute immediately

Paid plan users can now immediately launch projects on larger compute sizes. Previously, paid organizations had to launch projects on the default "Micro" instance and then separately upgrade their instance. You can always up and downgrade your instance in hindsight. Feel free to leave any feedback in our discussions here!

PR: https://github.com/supabase/supabase/pull/21292

Link: https://supabase.com/dashboard/new/_

Update on Table Editor search input

As mentioned in last week's changelog (and also as always 😉) we see everyone's feedback regarding the changes to the table editor search input and have enacted a slight change to make the search action more prominent and easier to click on! Again, thank you to everyone for sounding your thoughts, we genuinely appreciate them as it helps us guide the dashboard's DX to be optimal - keep em coming!

Separetely - we're also aware of the feedback regarding our change in the way you manage your foreign keys as announced in the changelog discussion 2 weeks ago - fret not! We're actively looking into that as well 🙂

PR: https://github.com/supabase/supabase/pull/21486

Link: https://supabase.com/dashboard/project/_/editor

Resizeable inner sidebars for Table Editor and SQL Editor

https://github.com/supabase/supabase/assets/8291514/1f3d04ef-df86-4398-b7b3-42a9effe950d

For those who might have tables or SQL queries with long names, this should help alleviate some issues with the names truncating. Hopefully it'll be easier to find your tables / SQL queries! 😊

PR: https://github.com/supabase/supabase/pull/21548

Link: https://supabase.com/dashboard/project/_/editor

Connecting to your project - added Expo React Native guides

Last week we announced a quicker way to get your project's connection parameters on the project's home page and we're heartened to already see some community contributions to add more content for different frameworks! Shoutout to @Hallidayo for the help on this - we're always keeping an eye out for more of such contributions 😄

PR: https://github.com/supabase/supabase/pull/21350

Other improvements and bug fixes

Home

Sort projects alphabetically and add search functionality for projects (PR)

Fix missing role impersonation functionality when opening a view (PR)
Fix a11y on table menu items (PR)
Fix inability to update primary key of a table after renaming the table (PR)

PR: https://github.com/supabase/supabase/pull/20328

Fix error highlighting wrong line if running a selected portion of the query (PR)

Paid organizations can now launch projects on bigger compute immediately

Feb 20, 2024

Dashboard Weekly Updates [12/02/24 - 19/02/24]

Feb 19, 2024

A quicker way to get your project's connection parameters

We've made retrieving your project's connection parameters more easily accessible by adding a "Connect" button to each projects' homepage. This will show you some quick instructions on how to either connect to your database directly, or connect to your project via some app frameworks and ORMs. Hopefully this will help both new and familiar developers on Supabase to get to building quicker without having to jump around the dashboard to find these information.

PR: https://github.com/supabase/supabase/pull/19977

We're in the midst of revising the UX around the table editor to ensure that controls aren't sprawled across the page despite us building more and more features - and this is just the first step of more to come. Icons for tables and views have been tweaked to be more minimal, each table has an indicator to whether RLS has been enabled or not, and the search bar has been made a tad sleeker. As an assurance, we definitely hear everyone's feedback about the changes here in particular with the search bar being less visible and are actively looking to improve the experience here! 🙏

Link: https://supabase.com/dashboard/project/_/editor

Table Editor header simplification

Similar to the above, we've updated the layout a little for the Table Editor itself, briefly the changes include

Support for enabling RLS from the Table Editor
Showing an indication of how many policies the table has
Shifting refresh + data/definition toggle to the footer of the grid

All these are tiny steps to allowing us to build more functionality into the Table Editor without turning it into a control panel!

PR: https://github.com/supabase/supabase/pull/18366

Link: https://supabase.com/dashboard/project/_/editor

View auth user details

We've had some feedback from users that they'd want a convenient way to check on their project's users from the UI rather than having to go through the Table Editor or SQL Editor to query the auth.users table, and so we've gone ahead to ship this one.

PR: https://github.com/supabase/supabase/pull/21239

Link: https://supabase.com/dashboard/project/_/auth/users

Other improvements and bug fixes

Fix definition view showing empty result if formatting the definition throws an error (PR)

https://github.com/supabase/supabase/assets/19742402/f50eabbf-9c30-4828-8f5f-0efeef67a025

Refocus to code editor after closing destructive query warning modal (PR)

Authentication

Fix policies under tables from "protected" schemas not showing RLS disabled/enabled state (PR)
- Also show "protected" schemas notice when viewing policies of tables under those schemas
Clicking "Toggle feature preview" from the new RLS creation UI will show a confirmation dialog if changes were made before closing the panel (PR)

Storage

Renaming a file will just highlight the name of the file without the extension, similar to MacOS (PR)

Dashboard Weekly Updates [05/02/24 - 12/02/24]

Feb 13, 2024

SQL editor bulk deletes

We hear you! This has been a very popular request by everyone and we're happy to make the first step to improving the UX around your SQL snippets. You can now delete your queries in bulk - gone are the days of rows full with Untitled queries 😄 Fret not, we're also aware that everyone is also requesting for better organization of snippets (specifically folders) - we're actively figuring out how best to bring that UX into the dashboard for everyone so be sure to watch this space 😉

PR: https://github.com/supabase/supabase/pull/20927

Link: https://supabase.com/dashboard/project/_/sql/new

Query performance updates

Unoptimized queries are a major cause of poor database performance - which is why the query performance report was initially built. We're equipping this page with better tooling, allowing users to:

Search by query or role
Sort results by latency
Expand results to view the full query that was run

As always, if there's anything more we can do for you, feel free to give us a shout in the feedback widget up top 🙂

PR: https://github.com/supabase/supabase/pull/20907

Link: https://supabase.com/dashboard/project/_/reports/query-performance

Logs Explorer face lift

In an effort to make our UI more consistent + coherent across all products, we've revamped the Logs Explorer to look just like the SQL Editor in hopes that there's less UI for users to learn, and users can just stay focused on doing what they want to do.

PR: https://github.com/supabase/supabase/pull/21055

Link: https://supabase.com/dashboard/project/_/logs/explorer

Support for composite foreign keys in table editor

The previous UI for managing foreign keys in the table editor had functional limitations as it assumed single column relations for foreign keys (overly simplified). We've thus shifted the management of foreign keys into the table side panel editor instead. You can manage all foreign keys across all columns on the table in one place, rather than going into each column individually to do so.

PR: https://github.com/supabase/supabase/pull/21078

Link: https://supabase.com/dashboard/project/_/editor

Other improvements and bug fixes

Table Editor

Fixed duplicating a table not saving it's description (PR)
Fixed viewing a reference row in the table editor from the grid not updating the selected schema if referenced row is in another schema (PR)
Fixed errors from adding data via spreadsheet/CSV text not surfacing as toasts (PR)

SQL Editor

Fixed long errors getting cut off / not horizontally scrollable (PR)
Fixed deleting a query that's not saved throws an error (PR)

Logs Explorer

Inserting a source will insert the value after the FROM command (PR)

Database

Fixed enumerated types side panel input fields not resetting after saving (PR)
Fixed roles side panel input fields not resetting after saving (PR)

Misc

Support page is now mobile responsive (PR)

Platform Updates: January 2024

Feb 6, 2024

Supavisor replaces PgBouncer for database connection pooling

We’re deprecating PgBouncer and migrating all projects to our Supavisor connection pooler. Go grab the pooler connection string in your project’s Database Settings.

Direct database connection resolve only to IPv6

[ACTION REQUIRED] AWS is deprecating IPv4, so we’ve migrating your project to IPv6. If your network supports IPv6 and/or you’re using PostgREST then you don’t need to make any changes. Otherwise, you need to update any connections to Supavisor’s connection pooler. We’ve also made IPv4 addresses available to purchase (passing on the cost from AWS).

Supabase Studio's latest enhancements

Improved text editing in Table Editor, with Markdown previews

We’ve made it much better for you to edit text in the Table Editor, including Markdown previews so you can preview your changes with ease. [PR]

Preview HTML email templates right from the dashboard

We’ve added the ability to preview your HTML email templates right from the dashboard. [PR]

Preview SQL snippets for better discoverability

We’ve added previews to your saved query snippets so you can find the one you’re looking for much faster. [PR]

More Studio updates

Quick product announcements

[AI] Added a guide on how to integrate Amazon Bedrock SDK with Supabase Vecs, our vector client for Postgres. [Guide]
[Auth] Improved guide on implementing Server-Side Auth for Next.js. [Guide]
[Auth] Fixed the cookie chunking issue in @supabase/ssr - shout out to SyntheticGoop from Mobbin. [PR]
[Auth] Fixed a bug in using a custom cookie name in @supabase/ssr. [PR]
[Edge Functions] Created a guide on custom routing. [Guide]
[Edge Functions] Created a guide on how to deploy via CI/CD pipelines on GitHub, GitLab, and Bitbucket. [Guide]
[Edge Functions] Edge Runtime now supports Deno 1.39.2. [Learn more]
[Edge Functions] Updated quickstart guide. [Video]

Blog Central

How pg_graphql Works

Learn about how we built the GraphQL Postgres extension, written in the Rust programming language, that powers our GraphQL data API.

Getting started with Ruby on Rails and Postgres on Supabase

Learn about how you can spin up a Rails app, integrate a Supabase database, and deploy it to Fly.io.

PR: https://github.com/supabase/supabase/pull/20498

Dashboard Weekly Updates [22/01/24 - 29/01/24]

Jan 30, 2024

Greater clarity on billing breakdown

We value transparency here at Supabase and that includes ensuring our users having clear visibility over what they are paying for. We've added some details in the organization billing breakdown section to show what are the "Current costs", on top of the "Projected costs" for the organization, and also added information regarding both of them in the form of tooltips. Compute credits are also shown here to ensure that those are considered in the costs calculation.

Link: https://supabase.com/dashboard/org/_/billing#breakdown

In efforts to hopefully to make it easier to find your queries. We're aware that users are facing difficulty in managing their SQL queries, in particular when the number of queries grow really big - we're actively looking into how to make things better 🙏 Watch this space!

PR: https://github.com/supabase/supabase/pull/20694

Link: https://supabase.com/dashboard/project/_/sql/new

Table Editor edit text cells with larger real estate

We've seen some users reaching out to us via feedback that they'd like a larger editor to edit their text-based column cells on the table editor - we hear you! And we've also sprinkled in some Markdown preview for those who might need it 🙂

PR: https://github.com/supabase/supabase/pull/20727

Link: https://supabase.com/dashboard/project/_/editor

Auth email templates preview

Many users have been requesting for this, and so has the team internally - you may now preview your HTML email templates right here in the dashboard. Gone are the days having to manually check your templates elsewhere, hopefully this will make your development lives a little easier.

PR: https://github.com/supabase/supabase/pull/20681

Link: https://supabase.com/dashboard/project/_/auth/templates

Database enumerated types will show enumerated types only

Shoutout to @Nabhag8848 for the help on this! We always appreciate and look up to any support from the community 🙏

PR: https://github.com/supabase/supabase/pull/20576

Link: https://supabase.com/dashboard/project/_/database/types

`cron` schema from the `pg-cron` extension no longer editable via the GUI

The schema is nonetheless still editable from the SQL editor by writing queries directly. This is in efforts to prevent directly inserting/updating rows on the pg_cron extension's cron.job table as it bypasses security checks that would've been asserted when jobs are scheduled/modified via pg_cron functions. More information here.

PR: https://github.com/supabase/supabase/pull/20664

Link: https://supabase.com/dashboard/project/_/editor

Table Editor fix inability to copy input field values in the row side panel editor

PR: https://github.com/supabase/supabase/pull/20671

Link: https://supabase.com/dashboard/project/_/editor

Dashboard Weekly Updates [15/01/24 - 22/01/24]

Jan 22, 2024

Updates to the Database Settings page

We're stream-lining the connection UI on the database settings page to be more concise and simpler in hopes to improve the UX around connecting to your project's database, and a push to using the connection pooler as a recommended practice. As always, feel free to drop us feedback via the feedback widget in the navigation bar up top - we promise that we look at every single one of the feedback that comes in.

PR: https://github.com/supabase/supabase/pull/20575

Link: https://supabase.com/dashboard/project/_/settings/database

Network Restrictions now support adding restrictions to IPv6 addresses

PR: https://github.com/supabase/supabase/pull/20548

Link: https://supabase.com/dashboard/project/_/settings/database#network-restrictions

Network Restrictions addresses will be normalized when adding a new restriction

PR: https://github.com/supabase/supabase/pull/20514

Link: https://supabase.com/dashboard/project/_/settings/database#network-restrictions

IPv4 add-on now available to allow direct connections to your database via an IPv4 address

You may consider enabling this add-on via the dashboard if you're not planning on using our connection pooler (which still supports IPv4) and your environment does not support IPv6. More information regarding this add-on here.

PR: https://github.com/supabase/supabase/pull/20433

Link: https://supabase.com/dashboard/project/_/settings/addons

Logs Explorer support for updating and deleting queries

PR: https://github.com/supabase/supabase/pull/20343

Link: https://supabase.com/dashboard/project/_/logs/explorer/saved

PR: https://github.com/supabase/supabase/pull/20474

Link: https://supabase.com/dashboard/project/_/editor

Removed deprecated LinkedIn Provider from Auth Providers

The LinkedIn provider was scheduled to be deprecated in favour of the current LinkedIn OIDC provider with a notice set up since November 2023 and a couple of email notifications sent out to our users. The LinkedIn provider is now removed from our Auth Providers page. Please do reach out to us via support if you might have been affected by this!

PR: https://github.com/supabase/supabase/pull/20510

Link: https://supabase.com/dashboard/project/_/auth/providers

Supavisor starts enforcing Network Restrictions

Jan 17, 2024

Supavisor, our connection pooler, does not support using Network Restrictions at the moment. Support for Network Restrictions will be enabled on the 24th of January 2024.

If you are not using Supavisor, this change does not affect you.

Starting the 24th, projects with existing network restrictions will have their Supavisor configuration automatically updated with the same restrictions. Changes to any project’s network restrictions will also be automatically propagated to Supavisor.

FAQ

How does the upcoming IPv6 migration affect this change?

If direct connections to your database resolve to a IPv6 address, you need to add both IPv4 and IPv6 CIDRs to the list of allowed CIDRs. Network Restrictions will be applied to all database connection routes, whether pooled or direct. You will need to add both the IPv4 and IPv6 networks you want to allow. There are two exceptions: if you have been granted an extension on the IPv6 migration OR if you have purchased the IPv4 add-on, you need only add IPv4 CIDRs.

IPv4 addon for projects available

Jan 17, 2024

On February 1st 2024, AWS will start charging for IPv4 addresses. We're deprecating IPv4 for direct connections.

For more rationale behind the change, please read our blog post: Brace yourself, IPv6 is coming.

If you plan on not using our connection pooler, which still supports IPv4, and your environment does not support IPv6, consider enabling the add-on.

[!NOTE]
You do not need to enable this add-on if you use Supavisor, our new connection pooler!

The add-on is $4 per month - we're simply passing on the AWS costs to you. The add-on is available for all paid plans.

You still need to migrate away from PGBouncer even with this add-on enabled.

You can now enable the IPv4 addon in your project addon settings.

Additionally, we're working on making this even better by offering dedicated IPv4 addresses which help with IP allowlisting and network restrictions. There will be another update once dedicated IPv4 addresses are ready to use.

Dashboard Weekly Updates [08/01/24 - 15/01/24]

Jan 15, 2024

Column-level privileges management

Manage column-level privileges via the dashboard. This was a long time coming with many users looking forward to the addition of this to the dashboard. Huge shoutout once again to @HTMHell and everyone for their patience while we got this through the gates 🙏

PR: https://github.com/supabase/supabase/pull/13745

Link: https://supabase.com/dashboard/project/_/auth/column-privileges

Table editor support for copying cells via keyboard shortcut

You can now copy cell values in the Table Editor via Cmd+c and Cmd+v (or Ctrl+c or Ctrl+v)! Hopefully this makes managing your data a little more easier.

PR: https://github.com/supabase/supabase/pull/20261

Link: https://supabase.com/dashboard/project/_/editor

Table editor prevent deleting all rows in a table through the GUI while impersonating a role

We're disabling the "Delete rows" action in the Table Editor when you've selected all rows in a table, and are impersonating a role due to an issue which @jacob-8 found (appreciate your report! 🙏) The issue mentioned can be found here.

PR: https://github.com/supabase/supabase/pull/20349

Link: https://supabase.com/dashboard/project/_/editor

Storage Explorer support for emptying a bucket

PR: https://github.com/supabase/supabase/pull/20335

Link: https://supabase.com/dashboard/project/_/storage/buckets

Supavisor 1.1.6

Jan 11, 2024

Released Supavisor 1.1.6

Notable

Fixes a bug which caused prepared statements to fail in session mode

Platform Updates December 2023

Jan 11, 2024

A rundown of everything we shipped during Launch Week X

Day 1 - Supabase Studio: AI Assistant and User Impersonation

Supabase Studio received a major update that reflects our commitment to a SQL-first approach and user-centric development. Awesome features like easy RLS policies with an AI assistant, Postgres Roles, User Impersonation, and much more.

Day 2 - Edge Functions: Node and native npm compatibility

Edge Functions now natively supports npm modules and Node built-in APIs. You can directly import millions of popular, commonly used npm modules into your Edge Functions.

Day 3 - Supabase Branching

A Postgres database for every GitHub branch. Database branching means you can have separate database instances for each feature of your application.

Day 4 - Supabase Auth: Identity Linking, Hooks, and HaveIBeenPwned integration

We announced several new features for Supabase Auth: Identity Linking, Session Control, Leaked Password Protection, and Auth Hooks with Postgres functions.

Day 5 - Introducing Read Replicas

This is a huge one for anyone wanting to serve data closer to the users or distribute loads across multiple databases. Learn how we implemented Read Replicas and how to use them in your projects.

More announcements from Launch Week X

As if all that wasn't enough, we shipped even more cool stuff:

Supavisor 1.1.5

Jan 10, 2024

Released Supavisor 1.1.5

Notable

Pools now start with only 10 connections and create new ones up to tenant default_pool_size or user pool_size
Logs correct tenant id
API endpoints accept PATCH requests

Previously Supavisor would start a deterministic number of connection depending on the pool size specified on the tenant or tenant user.

Now Supavisor will start 10 connections and then allocate more as needed.

It was pretty easy to over-allocate your database max_connections without fully understanding what your max_connections were and how many were currently being used by other services.

This also makes migration from PgBouncer easier as it's much safer to run multiple connection poolers at the same time as you migrate, as long as they both don't need to allocate their full database connection pools.

Also an implied behavior of Supavisor was that each user connected spins up it's own pool. Without understanding this behavior it's easy to over-allocate database connections by connecting different Posgres users to the pooler.

Dashboard Weekly Updates [01/01/24 - 01/08/24]

Jan 8, 2024

Improve loading interface on Auth users page

Navigating between pages if your project has many users is now less jarring.

PR: https://github.com/supabase/supabase/pull/19940

Link: https://supabase.com/dashboard/project/_/auth/users

Fix viewing RLS policies of a table from table editor not selecting its schema on the RLS page

More specifically if the table does not belong to the public schema.

PR: https://github.com/supabase/supabase/pull/20100

Link: https://supabase.com/dashboard/project/_/editor

Fix inability to delete enumerated type from the dashboard if type name has Uppercase initial letter

Thank you @tranhoangvuit for helping us on this!

PR: https://github.com/supabase/supabase/pull/20023

Link: https://supabase.com/dashboard/project/_/database/types

Sort RLS policies alphabetically

Once again, thank you @tranhoangvuit for helping us with this!

PR: https://github.com/supabase/supabase/pull/20163

Link: https://supabase.com/dashboard/project/_/auth/policies

Supavisor v1.1.2 - allow_list and client_heartbeat_interval

Jan 5, 2024

Released Supavisor v1.1.2

Notable

allow_list field on the tenant to support network restrictions
More docs
client_heartbeat_interval on the tenant to detect zombie client connections
Bug fixes
Observability improvements

The client_heartbeat_interval helps us detect client connections from behind a load balancer which are dead but did not close the TCP connection correctly. This interval defaults to one minute but is configurable per tenant.

The allow_list field on the tenant takes a list of CIDR ranges and validates incoming connection addresses against this list. The incoming client address must be in one of these ranges to be accepted.

Also, started a Supavisor FAQ!

Threshold for transitioning projects to physical backups lowered to 40GB

Jan 3, 2024

Further to https://github.com/orgs/supabase/discussions/18654 , the threshold for transitioning large databases to use physical backups for their daily backups is being lowered to 40GB over the next few days.

Physical backups are more performant, have lower impact on the db, and avoid holding locks for long periods of time. Restores continue to work as expected, but backups taken using this method can no longer be downloaded from the dashboard.

Over the next few months, we'll be introducing functionality to restore to a separate, new database, allowing for the perusal of the backed up data without disruption to the original project.

Please refer to supabase.com/docs/guides/platform/backups#daily-backups-process for additional details.

Dashboard Weekly Updates [11th Dec - 18th Dec]

Dec 18, 2023

Launch Week X is just over, but the fun doesn't stop! This changelog summarizes what has been released for Studio over last week as well as other improvements that we shipped behind the scenes while Launch Week X was ongoing.

Supabase Assistant (For Auth RLS policies)

https://github.com/supabase/supabase/assets/19742402/c10ab0bc-a2be-4739-be3a-5eb6ef802af1

We've got a new RLS Editor that brings SQL front-and-center, giving developers access to the full potential of Postgres rather than abstracting it away. Accompanying it is an AI assistant that has been tuned to produce SQL for Row Level Security policies, making it fast and easy to get your policies setup the way you need them.

If you're keen to give this a spin, you may enable this feature from the Feature Previews section (which we'll cover more in the last section of this changelog) while you're in a project. This will replace the current UI for creating RLS policies with this new AI assisted RLS Editor UI.

PR: https://github.com/supabase/supabase/pull/19166

Link: https://supabase.com/dashboard/project/_/auth/policies

Postgres Roles & User Impersonation

Run queries in Studio using different roles - this is potentially a powerful tool for testing your Row Level Security policies and determining which data each role can access. You may also impersonate a specific user in Studio by "minting" a JWT with their ID and then running the queries using that JWT.

This feature is available not just in the Table Editor, but also in the SQL Editor, GraphiQL interface, and Realtime Inspector (which we'll talk about more right in the next section below)

PR: https://github.com/supabase/supabase/pull/18945

Link: https://supabase.com/dashboard/project/_/editor

Realtime Inspector

An easy way to prototype, inspect, and debug Realtime directly in the Studio. You can use the Realtime Inspector to view messages being sent and received in channels, and also filter messages by type: presence, broadcast, and database changes.

PR: https://github.com/supabase/supabase/pull/17617

Link: https://supabase.com/dashboard/project/_/realtime/inspector

Feature Previews

Our new tool for unveiling new features - we'll release beta features as previews before making them generally available. This will help us to get features out to you faster, make it easier for you to give us feedback, and also shorten the iteration loop.

PR: https://github.com/supabase/supabase/pull/17775

PR: https://github.com/supabase/supabase/pull/19615

Auth Settings added option to support manual identity linking

Supabase Auth allows a user to initiate identity linking with a different email address when they are logged in. More information can be found in our documentation here.

Link: https://supabase.com/dashboard/project/_/settings/auth

Table Editor support selecting types from the `extensions` schema when creating/editing columns

Database extensions that are installed through the dashboard on the database/extensions page are, most of the time, installed by default in the extensions schema (as it's the default dropdown option) unless the extension has a schema that it's required to be in, or the user changes it to be installed in another schema.

If the installed extension (e.g vector) has enumerated types, the Table Editor then can access those types for users to assign them to columns, without having the user to install them in another schema.

PR: https://github.com/supabase/supabase/pull/19580

Link: https://supabase.com/dashboard/project/_/editor

Network Bans highlight IP Address if it belongs to the current logged-in user

PR: https://github.com/supabase/supabase/pull/19666

Link: https://supabase.com/dashboard/project/_/settings/database

Platform updates: October 2023

Nov 6, 2023

Server-Side Auth in Next.js 14

We've released @supabase/ssr, which makes it super easy to use cookies for storing user sessions. We’ve updated npx create-next-app -e with-supabase to use @supabase/ssr and made it compatible with Next.js 14.

Read the blog post.

pgvector vs Pinecone

pgvector is becoming the vector store of choice for developers. We’ve put it to the test against Pinecone and found that it performs better on cost and query throughput, without sacrificing accuracy.

See the full benchmarks

Manage storage buckets from the command line

You can now manage Storage buckets with the Supabase CLI:

supabase storage ls -r: show all buckets and objects
supabase cp -r readme.md ss:///bucket: upload local files to bucket
supabase cp -r ss:///bucket: download objects from bucket
supabase rm -r ss:///bucket: delete files from bucket

Managing Storage buckets with CLI works best if there are less than 100k objects in your bucket and each of them is smaller than 20MB. Reference docs are here.

What's new in Supabase Studio?

Supabase Studio is improved many times per day, here is some of what's new:

Better error surfacing in SQL Editor. [PR]
Break out auth rate limit fields into a separate page. [PR]
Enumerated types management. [PR]
New API side panel. [PR]
Audit logs for organizations available on Team plan.

Check them out.

Multi-factor Authentication in Supabase Studio

Secure your Supabase account with Multi-Factor Authentication. You can now add a time-based one-time password (TOTP), managed by apps such as 1Password, Authy, Google Authenticator or Apple's Keychain.

Check out the doc

Quick product announcements

[Auth] LinkedIn OIDC provider. [PR]
[Auth] Use token to include the redirect URL in your email template. [PR]
[pgvector] Upgrade 0.5.1 (faster HNSW index builds). [Release]
[Dashboard] Scopes for OAuth apps. [PR]
[Postgres] pg_jsonschema upgrade 0.1.4 to 0.2.0. [Release]
[Supavisor] Starts providing Docker Images. [Docker]
[GraphQL] GraphQL user defined functions now supported following the pg_graphql upgrade from 1.2.3 to 1.4.2. [Docs]

Platform update September 2023

Oct 6, 2023

Broadcast realtime messages via REST API

You can now broadcast Realtime messages to all your connected users by simply using a REST API call, removing the need to connect to a WebSocket. This will be especially useful with our Edge Functions!

Broadcast docs

Supavisor is now used for connection pooling in all new projects

Less than two months ago, we announced Supavisor, our own Postgres connection pooler that handles millions of connections. It’s now available in all new projects. You can continue using pgbouncer alongside Supavisor, however, it will be deprecated effective January 15th, 2024.

Moving to IPV6 for Database Connection Strings

With IPv4 addresses becoming increasingly scarce and cloud providers starting to charge for it, we won’t be assigning IPv4 addresses to Supabase projects from January 15th, 2024. [db.projectref.supabase.co](http://db.projectref.supabase.co) will start resolving to a IPv6 address instead. If you plan on connecting to your database directly, you must ensure that your network can communicate over IPv6. Supavisor will continue to return IPv4 addresses, so you can update your applications to connect to Supavisor instead.

Read the Airtable Wrapper docs Learn about Wrappers

New Foreign Data Wrapper: Airtable

Introducing the latest addition to our Wrappers lineup: Airtable! You can use it to query data from your Airtable bases and tables directly from Postgres:


_10select * from my_airtable_table;
_10# data from Airtable

Supabase Studio's latest enhancements

Supabase Studio is under constant improvement, here is what’s new:

Added UI support for cascade updates
Improved JSON previewing and editing
Button for toggling Realtime right from the Table Editor
See View definition and open it in the SQL Editor to modify
UI to view and unban IP addresses to manage banned IPs more conveniently
Import CSV files at the table creation stage and a new button to download the table as CSV

Try them out

HNSW Support for Vecs + pgvector

Added HNSW support inside Vecs, our Python library for pgvector. Vecs automatically creates schemas and collections inside your database, making it one of the easiest ways to get started with pgvector.

Read the HNSW docs

Quick product announcements

[PostgREST] JWT caching just landed. API requests are about to get 100ms faster. [PR]
[Auth] Added a default in-memory storage mechanism to allow using supabase-js in these environments to fall back to use this default storage mechanism now. Upgrade to supabase-js v2.36.0 or gotrue-js v2.54.0 for the latest changes. [PR]
[Edge Functions] Supports much simpler API for creating functions Deno.serve(req => new Response("ok")). No http standard library dependency needed. (Thanks eifr for contributing with updated CLI templates. [PR]
[Edge Functions] You can manage the secrets for your project's Edge Functions via the dashboard. [Try it now]

Platform updates: August 2023

Sep 8, 2023

pgvector v0.5.0: Faster semantic search with HNSW indexes

pgvector v0.5.0 adds Hierarchical Navigable Small World (HNSW), a new type of index that ensures lightning-fast vector searches, especially in high-dimensional spaces and embeddings.

Day 1 - Hugging Face is now supported in Supabase

We are all about open source collaboration, and Hugging Face is one of the open source communities we admire most. That’s why we've added Hugging Face support in our Python Vector Client and Edge Functions (Javascript).

Day 2 - Supabase Local Dev: migrations, branching, and observability

The CLI received some serious upgrades including observability tools, streamlined backups, and enhanced migrations. But that's not all – the big game-changer is the introduction of Supabase branching which we’re rolling out to selected customers.

Day 3 - Supabase Studio 3.0

Supabase Studio brings some huge new features, including AI SQL editor, Schema diagrams, Wrappers UI, and a lot more!

Day 4 - Supabase Integrations Marketplace

With the release of OAuth2 applications, we've made it easier than ever for our partners to extend the Supabase platform with useful tooling.

Day 4 - Vercel Integration 2.0 and Next.js App Router Support

The New Supabase x Vercel integration streamlines the process of creating, deploying, and maintaining web applications with several enhancements. Plus, it fully supports the App Router in Next.js ▲

Day 5 - Supavisor: Scaling Postgres to 1 Million Connections

Supavisor is a scalable, cloud-native Postgres connection pooler written in Elixir. It has been developed with multi-tenancy in mind, handling millions of connections without significant overhead or latency. We’re rolling it out to every database on our platform.

Community Highlights from the past 4 months

Launch Week is an event for our community, so it’s a good time to look back at what happened in the last months (spoiler: a lot).

HIPAA and SOC2 Type 2

Supabase is officially SOC2 Type 2 and HIPAA compliant! In this write-up, we offer insights into what you can expect if you’re planning to go through the same process.