How Nodabase works

Nodabase sits between the application you are building and the infrastructure it uses. Your application talks to one client, and the client talks to the services that back each capability.

Architecture

                              Node.js Application
                                       |
                                       v
                                nodabase client
                                       |
+------------+------------+------------+------------+------------+------------+
|            |            |            |            |            |            |
      v           v           v           v           v           v
  PostgreSQL    GoTrue     Dragonfly     MinIO        NATS      Job Runner
   Database      Auth        Cache      Storage      Queues   + PostgreSQL

Your application

The Node.js application the developer is building. It runs as a normal Node.js process and does not need to know how each service is provisioned.

Nodabase client

One Node.js package, nodabase, providing access to the platform:

Client moduleBacked by
nodabase.dbPostgreSQL
nodabase.authGoTrue
nodabase.cacheDragonfly (Redis-compatible)
nodabase.storageMinIO / S3-compatible object storage
nodabase.queNATS / JetStream
nodabase.jobsJob Runner + PostgreSQL
js
import { nodabase } from "nodabase";
 
const { rows } = await nodabase.db.query(
"SELECT NOW() AS time"
);
 
console.log(rows[0]);

Infrastructure

Each capability is backed by a real service rather than a reimplementation. PostgreSQL remains PostgreSQL, and the same is true of authentication, cache, storage and messaging. You can connect to the underlying services directly when you need to.

Runtime

Nodabase can provide the Docker-based runtime for Node.js applications. The platform runs the application alongside the services it depends on, using the same Docker Compose stack for local work and for your own servers.

Self-hosting

The developer controls the infrastructure, the data and the deployment. Nodabase runs on a laptop, a VPS or your own servers, and nothing leaves your machines unless you send it.

Why doesn't Nodabase build all of this itself?

Because these problems are already solved.

PostgreSQL, GoTrue, Dragonfly, MinIO and NATS are mature technologies with well-understood behaviour. Replacing them would mean inheriting years of missing edge cases, and it would give you an implementation you could only trust as far as its test coverage.

Nodabase deliberately composes this infrastructure instead of recreating it. What Nodabase adds is the layer in between: one configuration surface, one Docker-based runtime, one management API, one dashboard and one Node.js client. The pieces underneath stay recognizable, debuggable and replaceable.

That is the central idea in this documentation. Whenever you are reading about a Nodabase capability, you are reading about how it is composed — not about a new implementation of it.