Why We Dropped Supabase and Rebuilt on AWS

Tearing down your infrastructure three months after launch — on Christmas Day — probably sounds like an odd call. It's supposed to be a quiet day, and the natural instinct for any live service is "don't create risk for no reason." But that's exactly when we stepped away from Supabase and moved to our own AWS stack.
At that point, operating predictably mattered more than shipping faster, and the constraints Supabase imposed had outgrown its benefits.
We didn't leave because we disliked Supabase. Early on, it was the best choice we could've made. We were prototyping to survive, and what we needed was speed, not polished infrastructure. Build, attach, test, read the reaction, change it again — in that phase, BaaS speed raises your odds of survival. The Supabase era was entirely rational, even in hindsight.
As the service grew, we needed control
The problems started once the service grew and operations got deeper.
From that point, every decision stopped being about "can we ship it this week" and started being about whether it'd still run stable next week. Against that question, managed-platform convenience starts turning into the cost of giving up control.
This isn't about Supabase being bad. Managed services are structurally limited in what you can do when the platform has issues. When traffic is small, you can ride it out. But as users grow, that "riding it out" turns into a gamble.
There comes a point where a single outage shakes trust hard, and the accumulating sense of "there's not much we can do" drains you more than you'd expect. Moving to AWS wasn't just about running our own servers — it was about designing availability and performance ourselves and making the system predictable.
We wanted to touch the DB ourselves
Supabase is PostgreSQL-based, so it's obviously powerful. But as systems scale, it's less about "we use Postgres" and more about how far you can actually control it.
Fine-grained parameter tuning, introducing specific extensions, configuring backup and dump strategies to match business needs — those moments come, and at that stage Supabase couldn't give us the freedom we wanted. Especially as data grew more critical, the core operational question became: can we back up the way we want, design recovery scenarios the way we want, and run DR the way we want.
Now on RDS, we run DB settings and backup/recovery scenarios tailored to our workload. It's tangibly less stressful.
Auth — we decided to build it ourselves
Supabase Auth is convenient, no question. The problem was that the more we tried to extend auth flows — custom domains, OAuth expansions — the more the cost and constraints became impossible to ignore.
As a product grows, auth moves from a nice-to-have to core infrastructure. When core infrastructure starts getting limited by an external service's pricing tiers, that's not developer inconvenience anymore — it's a structural business problem.
We reimplemented auth logic to stay as compatible as possible with Supabase's Auth table structure, cut unnecessary fixed costs, and gained the freedom to run our service's complex auth flows however we needed. It wasn't trading convenience for pain. It was more like prepaying effort now to reduce it long-term.
We blocked direct DB access from the frontend
Supabase naturally encourages a pattern where the frontend talks to the DB directly. But we designed everything to go through a Backend API — for security and business-logic cohesion.
Direct frontend-to-DB access is fast, sure. But as a service scales, security boundaries blur, logic scatters, permission models get complex, and maintenance costs tend to explode. We held the principle that the DB stays behind the server from the start, and under that structure, Supabase's client-oriented features started becoming overhead.
After moving to AWS, we fully blocked frontend DB access and established a cleaner API-based communication layer. This wasn't slowing down — it was building the structure that lets you maintain speed later.
Cost and operational visibility
Once traffic starts growing, "how much will this month's Supabase bill be" becomes a bigger source of stress than you'd think. Managed services can make costs feel like a black box, and a pay-per-addon structure erodes operational predictability.
AWS, for better or worse, is calculable. Reserved Instances exist, granular cost monitoring makes budgeting clear, and CloudWatch lets you pull deep logs and metrics — which changes incident response speed entirely.
"Please don't let outages happen" is a wish. "When they happen, detect and recover fast" is a system. We'd reached the stage where we needed the latter.
Migration was brutal
Migration doesn't end cleanly. Three things were especially brutal:
- Data compatibility. We had to meticulously design schemas to preserve Supabase Auth's table structure while moving to our own logic.
- Min-downtime. We had to craft a tight data migration strategy to avoid wrecking the user experience.
- Dependency removal. Ripping out the Supabase SDK embedded throughout the client code and replacing it with pure API calls.
These aren't "just do it" tasks. One mistake destabilizes the entire product, so they demanded serious focus.
A choice to run farther
Looking back, this was something that had to be done. Supabase is still a great tool, and for fast idea validation it remains one of the best options out there.
But once a service hits its stride and you're accountable for long-term operations, building your own infrastructure becomes an act of buying predictability and control.
December 25th was that day. Not a day to run faster, but a day to re-lay the foundation so we can run farther.
Thanks to that choice, performance and cost are now predictable variables. That's the biggest thing we gained.