Why we built ɳSelf: self-hosted backends should not be hard

Every developer deserves a production-grade backend that they fully own. The problem was always setup complexity: Postgres, GraphQL, auth, storage, SSL, nginx, backups. Hours of configuration before writing a single line of app code.

We built ɳSelf to fix that.

The frustration

Self-hosting a production backend used to mean: provision a server, install Docker, write a docker-compose.yml, configure nginx, generate SSL certs, set up Postgres, install Hasura, wire up auth, configure MinIO, set up monitoring, and then figure out backups. That is a week of DevOps before you write any product code.

The alternative was a managed backend like Supabase or Nhost. They are great tools. But your data lives on their infrastructure, and costs compound quickly at scale. A serious project on Supabase costs $25/month before it has its first user. Hit any meaningful traffic and you are looking at $200-500/month, locked into someone else's pricing decisions.

We kept running into this trade-off on our own projects. We wanted the convenience of a managed backend with the ownership of self-hosting. So we built it.

The $40K wake-up call

The final push came from a real incident. A customer we were helping migrate off Firebase had been running a mid-size SaaS with about 50,000 active users. Their Firebase bill had been creeping up for months: $800, then $1,200, then $2,400. By the time they decided to move, they were paying $3,100 per month for Firestore reads, Cloud Functions invocations, and bandwidth.

The migration itself cost $40K in engineering time. Not because the data was hard to export. Because every query pattern, every auth flow, every real-time listener had been written against Firebase's proprietary APIs. There was no "export and import" button. It was a full rewrite.

That crystallized our thinking. Vendor lock-in is not an abstract risk. It is a concrete, measurable cost that compounds the longer you wait to address it. The solution is not "use open-source databases" because that just shifts the complexity to you. The solution is a tool that gives you the convenience of a managed backend while keeping everything on your own infrastructure, using open standards.

What ɳSelf actually does

ɳSelf is a single Go binary. You install it, point it at a server, and it builds the entire backend stack from a .env configuration file.

nself build

That one command reads your configuration and generates: a complete docker-compose.yml, nginx virtual host configs with automatic SSL via Let's Encrypt, health checks, logging, and monitoring hooks. Then:

nself start

Everything is running. You get:

• PostgreSQL 16 for your database
• Hasura GraphQL Engine for an instant GraphQL and REST API over Postgres
• Hasura Auth for JWT, magic links, OAuth, and multi-factor
• MinIO for S3-compatible object storage
• Redis for caching, sessions, and job queues
• MeiliSearch for full-text search with typo tolerance
• Nginx with automatic SSL termination and rate limiting
• Monitoring via Prometheus, Grafana, Loki, and alerting

No vendor account. No monthly SaaS fee. Your server, your data. Every byte of it.

The full setup, start to finish

curl -sSL https://install.nself.org | bash
nself init my-project
cd my-project
nself build && nself start

Four commands. Your backend is running on any VPS with Docker installed. Hasura gives you a GraphQL API over your Postgres database, with row-level security and real-time subscriptions out of the box. Auth handles sign-up, sign-in, JWT tokens, and OAuth providers. Nginx terminates SSL, routes traffic, and applies rate limits. Monitoring tracks CPU, memory, disk, request latency, and error rates.

The entire setup takes about five minutes on a fresh $5/month VPS. That is the same stack that costs $200-500/month on managed platforms.

The plugin ecosystem

The core stack covers what every backend needs. But modern apps need more: push notifications, cron jobs, email, AI, video calls, content management, commerce.

Instead of building a monolith, we built a plugin system. There are 112 plugins total: 25 free MIT-licensed plugins and 87 paid plugins organized into bundles.

nself plugin install cron notify mail    # free plugins
nself plugin install ai claw mux         # pro plugins (requires membership)

Each plugin adds its services, database migrations, Hasura metadata, and nginx routes to your stack. The nself build command wires everything together. No manual Docker configuration, no copying YAML snippets from documentation.

The free plugins cover the basics: cron scheduling, push notifications, email sending (with support for 16 providers), webhooks, and more. The paid plugins go further: AI with multi-model routing, a personal assistant (ɳClaw), video calls via LiveKit, content management, e-commerce, and media processing.

Why Go

We started ɳSelf as a collection of Bash scripts. It worked, but it was fragile. Bash 3.2 compatibility on macOS, inconsistent behavior across Linux distributions, no proper error handling, no type safety. At 10,000 lines of Bash, every change was a gamble.

In March 2026, we rewrote the entire CLI in Go. Single binary, cross-platform, fast. The rewrite took two weeks and eliminated an entire class of bugs. Installation went from "curl a script and hope your shell is compatible" to "brew install nself" or download a binary. Go's static typing caught bugs that Bash happily ignored for months.

The Go CLI is 161 source files and 40 test files. It handles everything from Docker orchestration to SSL certificate management to database migrations. One binary, no runtime dependencies beyond Docker.

The philosophy: own your stack

There are two approaches to developer tools. One says: give us your data, we will manage it, and you pay us monthly. The other says: here is the tool, run it yourself, own everything.

We picked the second one. Not because managed services are bad. They are excellent for prototyping and small projects. But at any meaningful scale, the math changes. A $5/month VPS running ɳSelf gives you more compute, more storage, and more control than a $200/month managed backend plan.

More importantly, you own the exit. Your data is in a standard Postgres database. Your API is standard GraphQL. Your auth tokens are standard JWTs. If you outgrow ɳSelf or decide to go a different direction, you take your data and go. No migration cost, no rewrite, no $40K surprise.

MIT licensed, forever

The core is MIT-licensed and free forever. We fund development through plugin bundles: each of the five paid bundles (ɳChat, ɳClaw, ɳFamily, ɳTV, ClawDE) costs $0.99/month. ɳSelf+ at $3.99/month gets you every bundle, every app, and email support. You pay for the functionality you need, not for the right to own your data.

This is a deliberate choice. The CLI, the core stack, and all 25 free plugins will always be MIT. We believe the right way to fund open-source infrastructure is by selling optional functionality on top of a solid free core. The $39.99/year ɳSelf+ plan gets you everything, including every plugin and email support. That is less than one month of Supabase's Pro plan.

What comes next

We shipped v1.0.3. The focus now is stability, documentation, and community. We are building seven products on top of ɳSelf ourselves: ɳTasks (task management), ɳChat (messaging), ɳClaw (AI assistant), ɳTV (media player), ClawDE (AI dev environment), and more. Every one of them runs on the same ɳSelf stack. We eat our own cooking every day.

If you have tried ɳSelf and hit friction, we want to hear about it. File an issue on GitHub, join the Telegram, or just reply to this post.

Check out the full comparison with Supabase to see where each tool fits. Or just install it:

brew tap nself-org/nself
brew install nself
nself init my-project
cd my-project
nself build && nself start

Five minutes. Your backend. Your server. Your data.