Why everyone asks me about Supabase
People ask me about Supabase all the time in my work. Usually it's someone who came across the name in an article or heard it from a developer, and who wants to know whether it matters for their company, their project or their next decision. The honest answer: it depends. But in many cases, the answer is yes.
In this article, I'll explain what Supabase is and what it actually does. I'll also cover the part most explanations leave out: what each feature means for different types of companies. A tool that halves a startup's development time can send the wrong signal in a large enterprise's architecture decision. And vice versa.
The short answer
Supabase is an open-source backend platform built on PostgreSQL. It gives you database access, authentication, realtime features, file storage and serverless functions, all through a single API and one central dashboard. The goal: you should be able to set up a complete backend without having to integrate five different services.
Supabase was founded in 2020 and quickly established itself as a serious alternative to Firebase. Today it's one of the fastest-growing open-source projects in the backend space.
The key difference from Firebase: Supabase is built on PostgreSQL instead of a proprietary NoSQL database. That's not a minor detail. It's the decision that makes Supabase interesting for production-critical applications.
PostgreSQL at the core
Before you can understand Supabase, you need to understand why PostgreSQL is the right foundation.
PostgreSQL is the world's most advanced open-source relational database. It has been around for more than 35 years, is actively developed and runs in production everywhere from small startups to multinational corporations. Building on it means investing in something that won't disappear and won't suddenly change its licensing policy. And in something backed by a global market of expertise.
Supabase didn't reinvent PostgreSQL; it makes the database accessible. Every Supabase instance is a full PostgreSQL database: no proprietary query format, no hidden abstraction. If you know SQL, you know Supabase. And if you don't, the dashboard gives you a visual interface for managing tables, relations and data.
For a startup, this means you're building on a technology that grows with you. No migration three years from now because the database can no longer keep up with your requirements. PostgreSQL scales from the first row to billions of records, with the same system and the same query model.
For a mid-sized company, it means your in-house developers or external service providers already know how to work with PostgreSQL. Nobody has to specialize in a proprietary system. The database layer is documented, standardized and replaceable.
For a large enterprise, it means PostgreSQL is enterprise-ready. There are commercial support options, a broad knowledge base and compatibility with existing database tools, BI systems and reporting infrastructure. The argument that open source isn't fit for critical systems hasn't held up for PostgreSQL in years.
Authentication: managing users without your own auth server
Authentication is the part of a backend most developers underestimate, and the one where mistakes cost the most. Supabase ships a complete authentication solution out of the box: email and password, magic links, social login via OAuth providers such as Google, GitHub, Apple and others, plus phone-based authentication via SMS.
All user management runs through Supabase Auth: sign-up, sign-in, password reset, session management, token handling. Frontend integration is documented through SDKs for JavaScript, Flutter, Swift and other platforms, and it's easy to work with in practice.
One important aspect: Supabase Auth is tightly integrated with the database. Row Level Security (more on that in a moment) lets you tie access rights at the database level directly to the authenticated user. That's not a feature you bolt on later. It's a design principle.
For a startup, that's a significant time saver. Setting up your own auth server, configuring it securely and running it takes real effort, and in an early project phase it's often not the best use of development time. Supabase Auth takes hours to integrate, not weeks.
For a mid-sized company, the relevant point is the connection to existing systems. If you already have Active Directory, an LDAP server or an existing single sign-on system, Supabase Auth reaches its limits. In those cases, I recommend combining Supabase Auth with Keycloak, or using Keycloak as the primary identity provider and connecting Supabase via JWT tokens. That's technically solvable, but it takes configuration work you need to plan for.
For a large enterprise, Supabase Auth on its own usually isn't enough. Enterprise requirements such as SAML, Active Directory integration, compliance-grade audit logs for access, and fine-grained role models across many systems go beyond what Supabase Auth offers natively. Here, Keycloak is the better choice as the primary identity management system, with Supabase as the connected data layer.
Row Level Security: data access that enforces itself
Row Level Security, or RLS for short, is one of PostgreSQL's most powerful features, and Supabase makes it accessible. The idea: access rules aren't defined in the application logic, but directly in the database.
A policy defines which users may read, write or delete which rows of a table. The database enforces this policy itself, regardless of how the query was made.
That has a decisive advantage: no application-layer bug can accidentally expose another user's data. The access rule sits deeper than the application. It sits in the database.
In practice, it looks like this: when users fetch their own orders, the database automatically returns only the rows that belong to their account. No WHERE clause a developer could forget. No middleware that could be bypassed. The restriction is structural.
For a startup, RLS is insurance against a common mistake in early projects: too little time for security logic. If RLS is configured correctly from the start, a substantial part of data access security is already taken care of, even if your team is small and working under time pressure.
For a mid-sized company, RLS is especially valuable when you have several user groups with different access rights. Think of a customer portal where each customer sees only their own data. Or an internal tool where different departments manage different records. What used to require multi-layered application logic, you can now model clearly and traceably in the database layer with RLS.
For a large enterprise, RLS is a recognized security pattern that can play a role in compliance requirements such as SOC 2 or ISO 27001. The access rules can be versioned, audited and reviewed independently of the application logic. That's a real advantage over systems that spread access logic across several application layers.
Realtime features: data that updates itself
Supabase offers realtime subscriptions over WebSockets. That means your application receives database changes in real time, without having to poll for them.
A dashboard that updates automatically when new data comes in. A chat that shows new messages instantly. A collaboration app where several users edit the same record at the same time and see each other's changes immediately.
Under the hood, this is based on PostgreSQL's LISTEN/NOTIFY mechanism, which Supabase translates into WebSocket connections through its Realtime infrastructure. You get fine-grained control over which table changes are broadcast: inserts, updates, deletes. And RLS applies to realtime subscriptions too.
For a startup, this opens up use cases that would otherwise mean significant infrastructure work. A realtime dashboard, a live notification feature or a collaborative feature that used to require a dedicated WebSocket server: you can integrate any of these in an afternoon. That's no exaggeration. It's the difference between a feature a team builds and one it drops because it seemed like too much work.
For a mid-sized company, realtime features are often exactly what makes internal tools compelling. A logistics dashboard that shows shipment status in real time. An internal ticketing system that makes new entries visible instantly. A monitoring tool for production data. You can build all of this with Supabase Realtime without running your own WebSocket infrastructure.
For a large enterprise, the deciding question is how scalable and resilient the realtime infrastructure is. Supabase Realtime scales horizontally. With very high numbers of concurrent connections, tens of thousands or more, you need to plan the architecture carefully and, if necessary, fall back on dedicated realtime solutions such as Apache Kafka or your own WebSocket servers. For most internal enterprise applications, Supabase Realtime is sufficient; public-facing services with very high concurrent user loads deserve a closer evaluation.
Storage: files without a separate service
Supabase Storage is a file storage system built directly into the Supabase infrastructure. Images, documents, videos: you can upload, manage and serve all of them through a simple API. Access rules work much like RLS: buckets can be public or private, and private buckets follow the same user-based principles as the database.
Supabase Storage doesn't replace a specialized CDN when media volumes are very high. But for most applications it's enough: user avatars, uploaded documents, product images in an internal application. You save yourself the integration of a separate service such as AWS S3 or Google Cloud Storage.
For a startup, this means one less service. No separate AWS account, no S3 bucket configuration, no separate access management for files. Storage, database and authentication run on one platform, with one consistent API and one consistent permission model.
For a mid-sized company, it's worth taking a look at your existing storage solutions. If you already have S3-compatible infrastructure or your own file server system, you need to weigh whether Supabase Storage replaces or complements those systems. Supabase Storage is S3-compatible and can be configured to point at existing S3 infrastructure. That gives you flexibility, but it requires technical setup.
For a large enterprise, Supabase Storage usually isn't the first choice for high-volume, production-critical media workflows. For secondary systems, internal tools or applications with moderate file volumes, it's a pragmatic solution that keeps integration effort low.
Edge Functions: serverless logic without your own server
With Supabase Edge Functions, you run server-side logic directly in the Supabase infrastructure: no server of your own, no deployment pipeline for backend code. Edge Functions are based on Deno, run globally distributed and can be called through the Supabase API.
Typical use cases: processing webhooks, handling payments via Stripe, sending emails, calling external APIs or running more complex calculations that shouldn't happen in client code.
Edge Functions don't replace a full backend framework. But for clearly scoped tasks that have to run server-side, they're a lean, well-integrated solution.
For a startup, Edge Functions are the key lever for getting by without your own server infrastructure. A Stripe webhook, a welcome email after sign-up, an external API integration: you can handle all of it in Edge Functions. The result is an architecture that lives entirely in the Supabase infrastructure and needs no separate backend server.
For a mid-sized company, Edge Functions are interesting for clearly scoped integration tasks. For example, a webhook handler that processes incoming orders from a third-party system. Or a function that regularly pulls data from an external source and writes it to the Supabase database. For more complex business logic, I recommend a dedicated backend framework such as Next.js API routes or a Node.js server, because testing, versioning and debugging Edge Functions takes more effort than with classic backend code.
For a large enterprise, Edge Functions usually aren't a primary tool. Enterprise backend requirements such as complex business logic, strict testing requirements and fine-grained deployment management are a better fit for established backend frameworks. For specific integration tasks that are decoupled from the core logic, though, they can be a sensible choice.
Self-hosting vs. Supabase Cloud: a decision with consequences
Supabase is open source. That means you can run it on your own infrastructure: completely, with no dependency on Supabase as a vendor. The entire platform is available on GitHub, deployment via Docker Compose is documented, and an active community supports self-hosted setups.
Supabase Cloud is the hosted version: easy onboarding, automatic updates, no operational overhead. The price you pay is a dependency on Supabase as a vendor and, depending on the region you choose, limited control over where your data is stored.
This isn't a trivial decision. I recommend basing it on three questions: How strict are your data protection requirements? How much in-house operational effort can you take on? And how important is long-term cost control to you?
For a startup, Supabase Cloud is the right way in. Onboarding takes minutes, your first projects run right away, and costs are easy to predict in the early stages. Self-hosting becomes an option once the product grows, you've built up in-house expertise, and cost control or data protection requirements call for it.
For a mid-sized company, the question of where data is stored is often decisive. Supabase Cloud offers EU regions such as Frankfurt. The contracting party, however, is Supabase Pte. Ltd. in Singapore, and the sub-processors include US companies such as Supabase, Inc. and AWS. That makes access under US law (the CLOUD Act) possible. If you want to rule that out, there's no way around self-hosting on European infrastructure, preferably at Hetzner. With sensible automation, the operational effort is manageable, but you have to plan for it.
For a large enterprise, self-hosting is in most cases the only option that's realistically on the table. Compliance requirements, internal IT policies and data sovereignty rule out managed services with US sub-processors for many data classes. Self-hosting on your own infrastructure or in a certified private cloud is then the right path, and it's technically very feasible.
What Supabase is not
This is where honesty matters.
Supabase isn't a finished application. It's an infrastructure platform, not a product you buy and put into production tomorrow. It needs developers to set it up, configure it and integrate it into an application. That's not a criticism; it's simply the right expectation to have.
Supabase isn't a complete identity management solution for complex enterprise scenarios. For single sign-on across many systems, SAML integration, Active Directory connectivity and fine-grained enterprise role models, Keycloak is the stronger choice: as the primary identity provider, with Supabase attached via JWT.
Nor is Supabase a realtime data processing platform for very high data volumes. For large-scale event streaming, complex stream processing pipelines or systems with hundreds of thousands of concurrent connections, you need dedicated solutions.
And Supabase is still a young platform. Development moves fast, which is a good thing. But it also means you need to keep an eye on updates, watch for breaking changes and adjust your implementation from time to time. That's true of almost any actively developed platform, but with Supabase you'll notice it more than with a system that has been in enterprise use for ten years.
Why I still recommend Supabase
In my day-to-day work, I regularly see projects that put too much effort into the wrong places. Teams that spend weeks building an authentication solution that Supabase delivers in three hours. Architectures that end up fighting for a relational database because an ill-fitting NoSQL solution was chosen early on. Backend infrastructure that eats up a substantial share of the development budget before the first line of product logic is written.
Supabase doesn't solve these problems by magic. It solves them because it carefully chose which problems to solve, and it solves those problems well.
PostgreSQL as the foundation takes the database decision off the table for most projects. Auth out of the box saves weeks of development work. RLS eliminates an entire class of security bugs. And realtime without your own WebSocket infrastructure opens up use cases that would otherwise be too much effort.
It's not a stack for every use case. But it's a stack that works impressively well for the right job, and it's built on a technology you can rely on long term without regrets.
Next steps
If you're weighing whether Supabase is the right foundation for your project, I'm happy to work through it with you in concrete terms. We'll look at your requirements and figure out whether Supabase Cloud, self-hosting or a different stack is the right way to go. Book a no-obligation consultation and let's talk about your project.
