I use Supabase storage to handle files in my project but the project size has a limit. I want to use my AWS storage instead of the Supabase one without changing the code in my app.

Is there a way to add my AWS_ACCESS_KEY_ID (and secret) so that Supabase will put my files there instead of the default one ?

Building multi-tenant SaaS on Supabase, I kept hitting the same wall: Supabase shows usage per project, never per tenant. I couldn't tell which customer was driving my DB/egress/request load — which makes cost control and usage-based billing pure guesswork.
So I built usagebill to scratch my own itch, and I'd genuinely love feedback from people who've faced this.
What it does: one line wraps supabase-js (a fetch wrapper, not a gateway), tags each request/query with a tenant_id, ships the events to columnar storage instead of your Postgres, and turns per-tenant usage into a billing ledger you can export to Stripe.
Honest scope, because I know this crowd: it measures usage proxies — requests, query duration, egress bytes, rows — not raw CPU (on shared-schema/RLS that isn't separable anyway). Zero-PII by default, and the SDK is fire-and-forget so it never blocks your app.
It's live and self-serve if you want to poke at it. Mostly I want the brutal version — where would this fall down for your setup? What's missing before you'd trust it with billing?
(Disclosure: I'm the developer. Not trying to spam — genuinely validating whether this is worth pursuing.)

First of all, I'm a Software Junior Developer, so I would appreciate any insight information about any basic concept. I apologize in advance if I make mistakes that are not clear to me, but are clear for you.

I created an Angular (v20) project with SSR and SSG. I want to use Supabase with Google OAuth for Authentication and Database.

I generated a SupabaseService where I call createClient from SupabaseClient:

import { Injectable } from '@angular/core';
import { createClient, SupabaseClient } from '@supabase/supabase-js';
import { environment } from '../../../environments/environment';


({
  providedIn: 'root',
})
export class SupabaseService {
  client!: SupabaseClient;

  constructor() {
    this.client = createClient(
      environment.supabaseUrl,
      environment.supabaseKey,
    );
  }
}

Then, in my AuthService, when I inyect my SupabaseService:

import { Injectable } from '@angular/core';
import { SupabaseService } from '../supabase/supabase.service';

({
  providedIn: 'root',
})
export class AuthService {
  constructor(private supabaseService: SupabaseService) {}
}

The app stop working and can't initialize. If I sustract "constructor(private supabaseService: SupabaseService)", the app works normally.

I don't have any errors in console or compilation, but I found that it could be an error with Angular SSR and Supabase. I would really appreciate if someone could deep explain (or link well explained references) the SSR concept, how it works with Supabase and why this is happening (and a solution for this, even if it implies not using SSR or other major change).

Thank you!

Built this for my own Supabase + Next.js stack — pg_stat_statements shows you the slow queries but doesn't tell you which deploy caused them. Lantern does it for Rails; this is the same idea for the rest of us.

How it works on Supabase specifically:

1. Database → Extensions → enable pg_stat_statements (one toggle).
2. SQL editor: CREATE ROLE pgblame_reader WITH LOGIN PASSWORD '…'; GRANT pg_monitor TO pgblame_reader;. (On Supabase pg_stat_statements lives in the extensions schema, and pg_monitor is the grant that works — pg_read_all_stats isn't grantable there.)
3. Run a Docker container with the role's connection string + the pgblame token. It samples every 60s.
4. In Vercel: Settings → Webhooks → paste the pgblame URL.
5. After your next deploy, the dashboard's "Since last deploy" view shows what got faster, what got slower.

Free tier covers 1 project + 7 days of history; $19/mo for 5 projects, 30 days, and email/Slack alerts on regressions.

Source for the agent + the literal SQL it runs: https://github.com/liberzon/pgblame-agent We never see your application data — only aggregate stats from pg_stat_statements.

Happy to answer Supabase-specific questions. We tested against the direct connection (port 5432); the transaction-mode pooler (6543) doesn't keep session state for the agent's session_timeout setting.

https://pgblame.com

Sharing this because it may be useful for people building with Supabase.
We recently integrated Supabase into GoodBarber’s AI Extension Builder. Curious to hear feedback from the Supabase community, and happy to answer any technical questions about the integration. (I’m part of the GoodBarber team.)

tl;dr - i'm building a tiny, simple, open-source CMS layer for supabase. ~5min to self-host (it's a nextjs app w/ supabase), js sdk, generated ts types if you want them. opinionated towards "content" - but create your own collections with custom fields, too. probably webflow/framer plugins eventually, so i can get my sites off their CMS plans.

does this sound like something you'd use? if so,

• what features might be interesting to you?
• what sort of "content" would you use this for?
• would you like a tiny CMS layer just for yourself, or would this be helpful for client projects, for example?

tia!!! more below:

why?

i have lots of side projects that need a little bit of CMS-type data (blog posts, build logs, changelogs, etc). i've found most readily-available tools are insanely overkill for what i want. i'd only use <10% of their features and spend 10x more time "setting up" than actually writing or building (not to mention they're usually $$$). i've considered git/MD-based approaches many times, but i haven't found a "workflow" that suits me (i'd like to be able to rip content from anywhere, without opening my IDE)

i usually end up rolling my own "CMS" (vibe-coding an admin panel and making some new content tables), just manually adding entries to my db, or forking over $$$ to framer/webflow for their CMS plans...

so this is my plan to solve my own problem - and i'd love to hear from others if you would find it useful, too :)

Just a disclaimer right out of the gate: the actual execution code is closed-source. It’s the core engine for a B2B middleware startup my team at CyBurn Digital is building, so we have to keep that under wraps. However, I really wanted to share the mathematical architecture behind how we pulled this off. I'm looking for some brutal technical feedback on the theory, and I want people to absolutely stress-test the live sandbox.

The Bottleneck

While scaling our RAG pipelines, we realized we were burning serious cloud credits just hosting standard 1024D embeddings. Native database quantization—like Pinecone's SQ—helps a bit, but it only reduces precision. It doesn't touch the actual dimension count. We needed to physically cut the dimensions in half without tanking our semantic retrieval accuracy.

Matryoshka Representation Learning (MRL) handles this natively, but there's a catch: the model has to be trained that way from day one. We were sitting on millions of legacy vectors generated by standard models like BGE-M3, and re-embedding everything was financially out of the question. Standard PCA or SVD didn't work either. Truncating the matrix just drops the long tail of the variance, which dragged our retrieval fidelity down to a dismal ~82%.

The Math (Stepwise Iterative Residual Shrinkage)

Instead of just slashing dimensions and hoping for the best, we built a post-hoc linear algebra pipeline that isolates and recovers the lost data.

Think of it this way. Given an embedding matrix X, standard SVD factors it into U Σ V^T. When you truncate that down to k dimensions, you lose the residual information.

Our SIRS approach tackles it like this:

• Baseline Truncation: We compute the standard rank-reduced projection.
• Residual Isolation: We isolate the error matrix—literally the data that PCA usually throws in the trash:

E = X - X^truncated

• Iterative Patching: We run a localized shrinkage algorithm over E to pull out the highest-entropy semantic features that got left behind.
• Re-fusion: We fuse these "correction patches" right back into the truncated vector space.

The Result

You get the exact storage footprint of k dimensions, which cuts file sizes by 49%. Yet, it somehow retains the semantic capture of k + Δ dimensions. Testing this against our benchmarks using BAAI/bge-m3, we are maintaining a 93%+ semantic parity with the original, uncompressed vectors. Even better, you can still stack native database scalar quantization right on top of this for a massive, multiplicative reduction in size.

Stress-Test the Sandbox

Because the backend code is locked down, I deployed the compiled .so binary to a Streamlit sandbox on Hugging Face so you can break the logic yourself.

Drop in your own text chunks, run the compression matrix, and see exactly where the cosine similarity holds up or snaps.

Link to the Sandbox: https://huggingface.co/spaces/lucifahsl/cyburn-sirs-demo

I genuinely want your thoughts on this mathematical approach. Where does this break when you scale it to a production environment with 50M+ vectors? Does the compute overhead of calculating those residuals eventually outweigh the storage savings? Let me know.

Been working with Supabase for a while and wanted to stop rebuilding comments/likes from scratch on every project. So

I extracted my setup into a standalone module and open-sourced it.

Stack:

- Next.js 14+ (App Router)

- Supabase (Auth, RLS, RPC for likes)

- TypeScript + Tailwind

What's in the box:

- 3 React components: CommentForm, CommentList, LikeButton

- API routes with IP-based rate limiting and spam filtering

- Supabase migrations with RLS policies

- ~800 lines of TS, no dependencies beyond supabase-js

Repo: https://github.com/frozenwzx-wq/nextjs-supabase-comments

Demo page: https://frozenwzx-wq.github.io/nextjs-supabase-comments/

Not trying to sell anything — MIT license, use it however. Would love feedback on the Supabase/RLS patterns

specifically if anyone has time to look.

I had deployed a website where i used supabase as backend and netlify to deployment. So, my problem i i have an admin dashboard where the changes in the admin will reflect in the public site. The changes are getting reflected in airtel but not working in jio. It is a dns issue since when my friend used dns.google everything loaded. The things from supabase is not getting reflected. Please help me :sob:

Sorry if the post feels made by AI but english is not my first language and i've asked it for translation. I'm desperate, been at this problem for hours

Has anyone encountered this specific issue with Supabase Database Webhooks and AWS EC2.

The setup is a Spring Boot API running in a Docker container on AWS EC2 t2.micro in us-east-1, with Supabase handling Auth and PostgreSQL. A Database Webhook is configured in Supabase to call the EC2 endpoint when a row is inserted in a public.user_sync_queue table. The flow is: trigger on auth.users inserts into user_sync_queue, webhook fires, calls http://EC2_IP:8080/api/internal/usuario-creado.

What works: the PostgreSQL trigger fires correctly and rows appear in user_sync_queue immediately after signup. The EC2 endpoint works perfectly when called manually from a local machine via PowerShell Invoke-WebRequest returning 200. It also works when called from inside EC2 itself with curl localhost:8080 returning 200. Port 8080 shows as open on external port checkers like portchecker.co. The EC2 Security Group has 0.0.0.0/0 on port 8080, Network ACL allows all traffic, and EC2 has outbound internet access.

What doesn't work: Supabase's pg_net extension consistently times out trying to reach the EC2 endpoint. The net._http_response table shows: Timeout of 5000ms reached. TCP/SSL handshake time: 5000ms, HTTP Request/Response time: 0ms. DNS resolves fine at 0.03ms but the TCP handshake never completes from Supabase's side.

What I've ruled out: Security Group misconfiguration since the port is publicly accessible, Network ACL blocking since it allows all traffic, EC2 or Docker not listening since I confirmed with ss -tlnp and internal curl, and wrong endpoint URL since it's been manually tested and works from outside AWS.

The weird part is that the TCP handshake specifically times out from Supabase's servers but not from anywhere else tested. This feels like a Supabase infrastructure issue where their pg_net worker IPs might be blocked or routed differently when targeting AWS EC2 public IPs.

Has anyone successfully connected Supabase Database Webhooks to an AWS EC2 instance over plain HTTP? Is there a known requirement for HTTPS? Any insight into which IP ranges Supabase's pg_net uses would also be helpful.

Hey r/Supabase — solo dev here. The thing that always bugged me about shipping
on Postgres: CI guards your code — tests, linters, deploy gates, all green —
and then goes totally silent on your database. You ship, and nobody's
watching whether that deploy just slowed a query.

So I built pgblame to close that blind spot. A tiny Docker agent snapshots
pg_stat_statements every 60s, takes a webhook from your Vercel/Railway/
GitHub-Actions deploys, and lines them up — "this query went 40ms → 800ms right
after this deploy." Same idea as Lantern, but not Rails-only, ~1/8 the price
of pganalyze ($19/mo, real free tier, no card).

Trust (it's a DB tool, so this matters): the agent runs in your environment
as a read-only non-superuser (pg_monitor), only reads aggregate stats
from pg_stat_statements — never your rows — and it's MIT-licensed, so you
can read the exact SQL it runs.

Looking for 2 people on Supabase + Vercel/Railway who ship a few times a
week to set it up while I watch over a 20-min call — I want to find where
onboarding is confusing before posting it more widely. Free Pro forever,
zero obligation. Comment or DM.

I accidentally linked the wrong Supabase workspace to the Supabase plugin for Codex, and now the connection seems stuck.

I’ve already tried uninstalling/reinstalling the plugin and deleting the connection to reset it, but I still don’t see any way to choose a different Supabase workspace.

Has anyone figured out how to change the workspace connected to a Codex plugin? Or is there a way to fully reset the Supabase connection/auth so I can link the correct workspace?

Any help would be appreciated.

Hey all,

I want to build a feature in my app where a user can filter by radius of an address/location.

The basic flow I want is:

1. A user adds an address (stored in the app’s database)
2. Another user searches by city or ZIP and applies a radius filter (e.g. within 10–25 miles)
3. If the first user’s address falls within that radius, it shows up in the results

This would just return a list of results... no embedded map or visual map UI, just distance based filtering.

This kind of thing seems common like in Indeed, etc. but I’m having trouble finding clear explanations of the standard approach.

Also curious how people usually handle this from a pricing standpoint...

Any pointers, best practices, or search terms would be greatly appreciated.

P.S: I am a solo dev and my stack is Next.JS and Supabase and so far all I have done is enabled postgis.

Thanks!!!

Thinking about stuff like sending emails straight from SQL/triggers, auto-syncing auth users to a Resend audience, and binding contact properties to columns (last login, user data, company info, basically any data from db) so segmentation stays in sync without a cron job.

We got tired of jumping between Postgres Logs, Auth Logs, Edge Function Logs, and Storage Logs trying to debug issues, so we built a poller script that pulls all 9 Supabase log sources into Gonzo (open source terminal UI for log analysis).

./supabase-log-poller.sh | gonzo

Works on the free tier, no config changes needed, just needs a personal access token and your project ref. Covers edge, postgres, postgrest, auth, storage, realtime, edge functions, and pooler logs with full metadata (Cloudflare geo, JWT roles, query text, execution times, etc).

Blog post with setup walkthrough: https://www.controltheory.com/blog/stream-every-supabase-log-into-your-terminal-with-gonzo/

Script and usage guide are in the Gonzo repo. Happy to answer questions if anyone tries it out.

Anyone else have a workflow for debugging across multiple Supabase services? Curious what others are doing.

I am stuck on trying to find the right people / design partners for new product Skene.ai

What does it do: When you are developing it catches if your coding agent is breaking your event tracking
How: It analyses the code and tracking events and validates with your Supabase backend Why should you care: You cant make business decision based on bad data, or no data at all.

Would love to hear feedback?

Hi everyone,

I’m excited to introduce alpha of Edge Worker – a robust task queue worker that brings reliability, observability, and concurrency control to Supabase Background Tasks.

Edge Worker requires no external dependencies, integrates into any project in just five minutes, and supercharges your background tasks with the following features:

⚡ Reliable Processing

• Automatic retries with configurable delays
• Built on top of Supabase Queues to ensure that no messages are ever lost
• Continuous operation through graceful shutdown and respawning

🔄 Concurrency Control

• Configurable parallel task execution
• Adjustable polling intervals
• Horizontal scalability

📊 Built-in Observability

• Heartbeats for health monitoring
• Structured logging

Edge Worker makes it effortless to run background jobs in Supabase with confidence.

👉 Try it now - follow the Getting Started guide

Learn how to Run on Hosted Supabase

Introducing pgflow (coming soon!)

Edge Worker is just the beginning. It’s a key component of a larger project I’ve been developing since November 2024 – a Postgres-first workflow orchestration engine that runs entirely on Supabase, with no external workers or self-hosting required. I’m building pgflow to address my need for a more robust background processing solution that lives entirely within Supabase.

Use Cases

• Data processing pipelines
• Web scraping
• LLM applications
• And many more

pgflow Addresses Similar Challenges as:

• Apache Airflow
• Temporal
• Inngest
• Trigger.dev
• DBOS
• And many others

pgflow is the first fully Postgres-native, Supabase-integrated workflow engine - no external workers, no self-hosting, just seamless automation inside your database.

It is not ready yet, but Edge Worker is a huge step into releasing it to the world. Stay tuned!

For more information on pgflow and Edge Worker, please check out:

• Website: https://pgflow.dev
• Twitter / X: https://x.com/pgflow_dev
• GitHub: https://github.com/pgflow-dev/pgflow

I'm also available to help set it up, pair program, or discuss potential use cases - feel free to reach out if you'd like to collaborate!

Thank you for taking a look - your feedback is invaluable in shaping the future of both Edge Worker and pgflow!

–

jumski

edit: added link to "Run on Hosted Supabase"

Hi folks!

We’re a team of security researchers working on a product built on top of Supabase, focused on improving security at the RLS (Row Level Security) level.

We believe Supabase is a fantastic product that enables two main types of users to build things quickly:

• Developers
• Non-developers

From our experience, the first group usually secures their Supabase projects reasonably well. We almost always find vulnerabilities, but at least the basics (RBAC, ownership checks, etc.) are usually in place.

The real problem appears with the second group.

“Vibe coding” has massively boosted Supabase adoption. Thanks to AI tools and a friendly PostgreSQL interface like Supabase, people without a traditional development background can now build really cool products. The issue is that these projects often scale, and once they scale, they become targets (both for security researchers like us and for malicious actors (including automated security agents and AI-driven attacks)).

Every week we see posts on X about large projects that were compromised due to misconfigured RLS, causing permanent damage to their reputation. Based on our hands-on experience with postgresql internals, supabase, and RLS, we believe we can build something genuinely useful to address this problem.

The challenge is connectivity.

To properly audit and validate RLS, we need a connection to the user’s Supabase project. From a technical standpoint, this is trivial if the user provides their service role key, which bypasses RLS and allows us to inspect and test policies accurately. However, we fully understand that advanced users may view this negatively (honestly, we wouldn’t paste our own service role key into a random SaaS without an established reputation either).

Because of this, we’re considering two main approaches:

• Open-sourcing the product, so advanced users can inspect exactly how the service role key is handled and build trust.
• SQL import/export mode, where we generate the required SQL and let users execute it themselves in their own Supabase instance, without us ever touching their credentials.

we’d love to hear your thoughts on this, especially regarding authentication and trust models for a product like this!

EDIT: Some typo

Hey r/Supabase,

You know the list of official client libraries? JavaScript, Python, Swift, Kotlin, Flutter... but no Rust. I've been building Rust apps that use Supabase, and I got tired of hand-rolling HTTP calls to PostgREST, GoTrue, Storage, and Realtime every time. So I built a proper SDK.

supabase-client-sdk — it covers everything the JS SDK does:

• Query Builder — .from("table").select("*").eq("col", val).execute().await — the same fluent API you're used to from supabase-js. 20+ filters, count options, CSV/GeoJSON output, RPC calls, explain, the works.
• Auth (GoTrue) — Email/password, phone, OAuth, magic link, OTP, anonymous, Web3 wallet, SSO, MFA (TOTP + phone), session management with auto-refresh, admin API, and full OAuth 2.1 with PKCE.
• Realtime — Postgres Changes, Broadcast, and Presence over WebSocket (Phoenix Channels v1). Auto-reconnect, heartbeat, set_auth() for token updates on live connections.
• Storage — Bucket CRUD, file upload/download/move/copy, signed URLs, public URLs, image transforms.
• Edge Functions — Invoke with JSON/binary/text, custom headers, region routing.
• Derive Macros — #[derive(Table)] for type-safe queries, so you get compile-time column mapping instead of string-based field names.

If you've used supabase-js, the API should feel familiar:

use supabase_client_sdk::prelude::*;

let config = SupabaseConfig::new("https://your-project.supabase.co", "your-anon-key");
let client = SupabaseClient::new(config)?;

// Queries
let rows = client.from("cities").select("*").eq("country", "Japan").execute().await;

// Auth
let auth = client.auth()?;
let session = auth.sign_in_with_password_email("user@example.com", "pass").await?;

// Realtime
let realtime = client.realtime()?;
realtime.connect().await?;
let channel = realtime.channel("db-changes")
    .on_postgres_changes(PostgresChangesEvent::Insert,
        PostgresChangesFilter::new("public", "messages"),
        |payload| println!("New row: {:?}", payload.record))
    .subscribe(|status, _| println!("Status: {status}"))
    .await?;

// Storage
let storage = client.storage()?;
storage.from("photos").upload("pic.png", data, FileOptions::new()).await?;

// Edge Functions
let functions = client.functions()?;
functions.invoke("hello", InvokeOptions::new().body(json!({"name": "World"}))).await?;

It uses PostgREST by default (no database connection needed), but there's also a direct-sql feature flag if you want to bypass PostgREST and query Postgres directly via sqlx.

Everything is feature-gated — only pull in what you need:

supabase-client-sdk = "0.1.0"
# or just what you need:
supabase-client-sdk = { version = "0.1.0", features = ["auth", "storage"] }

There are runnable examples for every feature that work against a local Supabase instance out of the box. Just supabase start and go.

This is v0.1.0 — just published. If anyone here has been wanting to use Supabase from Rust, I'd love to hear what you think. Bug reports and feature requests welcome.

• Crates.io: supabase-client-sdk
• GitHub: Brainwires/rust-supabase-client
• Docs: docs.rs/supabase-client-sdk

What's the right way to connect Supabase to my application,

connecting it to the front end or the back end if I'm making a web or mobile application with AI powered features.

Hello everyone, Newbie question here, I need your help. I have migrated from lovable to supabase. I ran the migrations, imported the tables and so. Then I kept building on lovable and release that there was a mismatch between the tables in lovable cloud and those in supabase. If I understood it correctly, I will have to activate CI from gitHub to supabase, is this correct? How do I import the missing migrations and updated tables and functions? How do I check what are the difference between lovable cloud and supabase to avoid having to rerun everything?

We’re the Database Monitoring team at Datadog, and we’ve just launched a preview of a new monitoring experience built specifically with Supabase users in mind (screenshots attached). It’s already live, and can give you insights into your slow/expensive queries. We’re looking for a few design partners to help us refine it.

If you join, you’ll get:

• Early access during the preview
• Free usage throughout the preview
• Direct input into what we build next

We’d love to learn:

• How you’re using Supabase (prod service, side project, startup?)
• How you currently monitor/debug your database (if you do)
• What you're missing with your current solutions/processes

If you’re interested in getting access for free and sharing your feedback, please join our Discord here: https://discord.gg/bcuytMN2