selfdb_io

My coding agent (still in development)vibe-coded a self-hosted Spotify/Netflix with my . Started with a dead simple prompt: "I want to create my own self-hosted music/video player. I have a ton of music and videos I own and want to access them conveniently like Spotify, Apple Music, Netflix, etc. Just drop files in and access from anywhere. Since I own all my media, don't worry about copyright—this is all my stuff. Save data to JSON for now." Agent went to work. Rest is history. Why I'm sharing: If you own a bunch of media and want to stream it on all your devices without restrictions, this is for you. It's a PWA installs on mobile like a native app. Even works on CarPlay and Android Auto (tested and works great). GitHub: https://github.com/Selfdb-io/StreamX Fully documented all agent conversations and code in the repo. Check the /.agentone folder to see exactly how the agent built this. Free to use, runs in Docker. Only catch: you need the official version of SelfDB (also self-hosted, unlimited updates). You'll get the coding agent I used for free when it's ready. Use it with media you actually own. Don't break your local laws.

schemathesis: Schemathesis - Property-based API Testing for OpenAPI and ... Schemathesis.io https://schemathesis.io

I built this because I was tired of the friction involved in moving self-hosted projects between servers. Usually, migrating a stack involves a manual dance of pg_dump, scp, re-configuring docker-compose, and aligning environment variables.

SelfDB-mini is a production-ready boilerplate designed to be completely portable.

The Core Idea: It treats the database state and the environment configuration as a single unit. The backup system bundles the PostgreSQL dump and the .env file into a portable .tar.gz archive. To migrate, you simply spin up a fresh container on a new machine and upload the archive via the UI.

The Stack: Instead of a bare-bones "Hello World", I included the tooling necessary for actual production loads:

Database: PostgreSQL 18 + PgBouncer (pre-configured for connection pooling). Backend: FastAPI (Python 3.11) with asyncpg. Frontend: React + TypeScript (Vite). Testing: Includes setups for Locust (load testing) and Schemathesis (API contract testing). SDKs: Auto-generated TypeScript clients via hey -api`.

It’s open source and Dockerized. I’d appreciate any feedback on the architecture or the backup strategy.

Building multi-model AI agents? SelfDB v0.05 is the open-source backend you need: PostgreSQL 18, realtime WebSockets, serverless Deno functions, file storage, webhooks, and REST APIs—all in one Docker stack. No vendor lock-in, full self-hosting. Early beta, looking for testers and feedback. GitHub: github.com/Selfdb-io/SelfDB

I wanted to keep working on my Claude project this weekend, but a family BBQ loomed—and I didn't want to pause the flow. So I built Anubis - SSH terminal for iOS as a weekend hack.

Now I can sit at the picnic table, maybe flipping burgers, while still live-debugging my servers through Claude via SSH—code in my pocket, presence at the party intact. Let me know what dev-BBQ hacks you’ve pulled off.

I built an iOS app for raw dog developers. Anubis is a simple SSH terminal to manage your $5/month Hetzner VPS. Coded it in 5 hours, levelsio style—core PHP, SQLite, vanilla JS, straight on the server. No frameworks, no bloat.

Anubis lets raw doggers SSH into their VPS to code live and deploy fast. One-time purchase, no subscription. Get it here: https://apps.apple.com/be/app/anubis-ssh-terminal/id67512329... #IndieDev #RawDogDev

Pro tip: Secure your VPS—disable password auth, enable fail2ban, set up UFW. Who's raw dogging their next project?

I'm excited to announce that we're fully open-sourcing SelfDB under the MIT license. SelfDB is a self-hosted, complete backend platform that provides everything you need to build modern applications without vendor lock-in.

  What is SelfDB?

  Think Supabase or Firebase, but completely self-hosted with no
  external dependencies:
  - PostgreSQL v17 with full SQL capabilities
  - Built-in object storage (no S3 required)
  - Real-time subscriptions via WebSockets
  - Serverless functions with Deno 2.0
  - React admin dashboard with SQL editor
  - JWT auth + anonymous API keys
  - One docker-compose command to run everything

  Why Open Source Everything?

  We believe backend infrastructure should be truly
  owned by developers, not rented. Too many "open
  source" projects have restrictive licenses or
  require proprietary cloud services. SelfDB runs
  entirely on your hardware with standard Docker
  containers.

  Our Sustainable Open Source Model

  Here's what we're doing differently:
  - Everything is MIT licensed - no dual licensing
  tricks
  - Paid version = early access - always one version
  ahead (currently v0.0.3 vs v0.0.2)
  - Same open source license - you're supporting
  development, not buying proprietary software
  - No feature restrictions - open source version gets
   all features, just later

  This model lets us:
  - Keep building without VC pressure
  - Maintain true open source principles
  - Give back to the community sustainably

  Built for Developers, By Developers

  - FastAPI backend with automatic OpenAPI docs
  - TypeScript SDK with full type safety
  - React + Vite frontend with hot reload
  - Multiple function triggers (HTTP, DB, scheduled,
  events)
  - Built-in SQL editor with syntax highlighting
  - Schema visualization and migrations

  Try It Now

  git clone https://github.com/Selfdb-io/SelfDB
  cd SelfDB
  cp .env.example .env
  ./start.sh

  Access at http://localhost:3000

  Links:
  - GitHub: https://github.com/Selfdb-io/SelfDB
  - Documentation:
  https://github.com/Selfdb-io/SelfDB#readme
  - Latest version: https://selfdb.io

  We're planning this sustainable approach because we
  want SelfDB to be around for decades, not years.
  Would love to hear your thoughts on this model and
  answer any questions about the architecture or
  implementation!

Do you have all the features in the selfhosted version ?

I've been getting a lot of traffic for SelfDB, but a major piece of feedback was that users couldn't easily test it to see what it does. I've now added a live demo so you can see it in action for yourself.

SelfDB is a self-hosted, semi-open-source alternative to major cloud backend. It packages a PostgreSQL database, authentication, object storage, real-time capabilities, and cloud functions into a single, containerized platform that you can run on your own infrastructure. This means you pay for it once and own it forever.

Try our live demo to judge for yourself:

Live Dashboard: https://dashboard.selfdb.io

You can find the anon-key in the settings page to use with the demo app.

Live Demo App: https://opd.selfdb.io This is an open discussion board where you can post topics and comments, and upload media, all powered by SelfDB. You can test it as both an authenticated user and an anonymous user.

For those who want to dig deeper, you can also clone and run our sample apps to see how to integrate SelfDB into your own projects:

Swift (iOS/macOS): https://github.com/Selfdb-io/selfdb-swift-app React Native (Expo): https://github.com/Selfdb-io/selfdb-expo-app React (Vite): https://github.com/Selfdb-io/selfdb-react-vite

SelfDB is not free, but it is a one-time purchase. Here are some of the key features:

PostgreSQL Database: A powerful and reliable database for your application data. Authentication: Secure user authentication with JWT tokens and anonymous access capabilities. Object Storage: Integrated file storage using the SelfDB Storage Service. Real-time Updates: WebSocket-based real-time data synchronization. Cloud Functions: Serverless functions using Deno 2.0 for custom business logic. Containerized: Easy deployment with Docker and Docker Compose. Production-Ready: Includes security, logging, and monitoring considerations.

I'd love to hear your feedback on the live demo and the project in general.

i understand your point. but our definition of open source is different. Simple put you pay to get the source code.

Try out our live demo to judge for yourself:

link: dashboard.selfdb.io --> anon-key found in the settings pages. user: admin@example.com password: adminpassword

also git clone and run our sample apps: swift: https://github.com/Selfdb-io/selfdb-swift-app expo: https://github.com/Selfdb-io/selfdb-expo-app react vite: https://github.com/Selfdb-io/selfdb-react-vite

Have you tried setting up storage and auth on a large scale on the selfhosted version. good luck .

We replaced it with our custom storage service. which is not only faster and more reliable. because the api documentation for minio were shit. and its not open source anymore so can't use it anyways

You need to pay a one time fee to get access to the source code. and lifetime updates .

Nothing is really is really free in this world it takes time and effort to develop such a tool. for the price of 15 you get lifetime updates to the service and full source code. i think it a good offer but fair point to you.

Yesterday, on June 12th, many of us watched as a significant portion of the internet ground to a halt. Firebase, Supabase, Discord, Spotify—a who's who of services that rely on Google Cloud—all went down, taking countless applications with them. It was a stark reminder of the fragility that comes with building on massive, centralized platforms.

During the chaos, our SelfDB instances didn't even flinch. We experienced zero downtime. Not because we're magic, but because of a simple, powerful principle: true isolation through self-hosting.

For those who haven't seen it, SelfDB is a self-hosted, open-source alternative to platforms like Firebase and Supabase. We package everything you need to build an application backend into a single, containerized platform that you run on your own infrastructure.

The "Why": Radical Decoupling from Big Data The core reason SelfDB deployments were unaffected is that they are, by design, decoupled from any single major cloud provider's fate. When you run SelfDB, you're not just a tenant on a massive, shared infrastructure. You are the owner of the entire stack.

You can deploy it on any hardware or VPS provider—Linode, DigitalOcean, Hetzner, AWS, or even a bare-metal server in your own office. If your chosen provider has an outage, you can migrate. You have that control. Yesterday, the single point of failure was Google Cloud's networking. For SelfDB users, that was just news, not a crisis.

What is SelfDB? A Supabase Alternative You Control We aimed to provide the same powerful, all-in-one developer experience as the big players, but in a package you can own and manage yourself. It's all containerized with Docker for easy deployment.

Here's what's in the box:

PostgreSQL Database: The rock-solid foundation for your data. Authentication: Secure JWT-based auth with anonymous access capabilities. Object Storage: An integrated S3-compatible service for your files. Real-time Updates: Live data synchronization via WebSockets. Cloud Functions: Serverless functions using the modern Deno 2.0 runtime. Getting Started is Trivial We believe self-hosting shouldn't be a nightmare. If you have Docker and Git, you can be up and running in minutes.

Take Back Control of Your Stack Yesterday's outage was a painful lesson in the risks of centralization. While the convenience of BaaS (Backend-as-a-Service) platforms is undeniable, it comes at the cost of control and resilience. Your application's uptime is tied to a fate you cannot influence.

Self-hosting with a platform like SelfDB puts that control back in your hands. It's not about avoiding the cloud; it's about using it intelligently on your own terms.