Skip to content
Fluxbase

Introduction

Fluxbase is a lightweight, single-binary Backend-as-a-Service (BaaS) alternative to Supabase. It provides essential backend services including auto-generated REST APIs, authentication, realtime subscriptions, file storage, and edge functions - all in a single Go binary with PostgreSQL as the only dependency.

Why Fluxbase?

Section titled “Why Fluxbase?”

Single Binary Deployment

Section titled “Single Binary Deployment”
  • Compact: Deploy one ~70MB binary or ~110MB container
  • Easy to operate: An admin UI lets you manage and update all configurations without restarts
  • Scalable: Scale horizontally if needed

Minimal Dependencies

Section titled “Minimal Dependencies”
  • PostgreSQL Only: No Redis, no RabbitMQ, no additional services
  • Self-Contained: Everything runs in one process
  • Easy Operations: Less moving parts = less complexity

High Performance

Section titled “High Performance”
  • Efficient: Written in Go for maximum performance
  • Scalable: Handle 1000+ concurrent connections
  • Fast: Sub-millisecond response times

Developer Friendly

Section titled “Developer Friendly”
  • PostgREST Compatible: Use existing Supabase knowledge
  • Auto-Generated APIs: Database tables become REST endpoints automatically
  • TypeScript & Go SDKs: First-class support for modern development

Core Features

Section titled “Core Features”

REST API

Section titled “REST API”

Automatically generate CRUD endpoints from your PostgreSQL schema with PostgREST-compatible query syntax:

Terminal window
# Filter and select
GET /api/v1/tables/posts?published=eq.true&select=id,title,author(name)


# Order and paginate
GET /api/v1/tables/posts?order=created_at.desc&limit=10&offset=20


# Complex queries
GET /api/v1/tables/posts?or=(status.eq.draft,status.eq.published)&author_id=eq.1

Authentication

Section titled “Authentication”

Built-in authentication with JWT tokens:

  • Email/password authentication
  • Magic link authentication
  • Session management
  • Protected endpoints

Realtime

Section titled “Realtime”

WebSocket-based realtime subscriptions:

  • PostgreSQL LISTEN/NOTIFY integration
  • Channel-based subscriptions
  • Presence tracking
  • Broadcast capabilities

Storage

Section titled “Storage”

File storage with access policies:

  • Local filesystem or S3-compatible backends
  • Bucket management
  • Public/private access control
  • Image transformations

Edge Functions

Section titled “Edge Functions”

JavaScript/TypeScript function execution:

  • HTTP-triggered functions
  • Scheduled functions (cron)
  • Database webhook triggers
  • Deno runtime

AI Chatbots

Section titled “AI Chatbots”

WebSocket-based AI chatbot integration:

  • SQL query assistants with natural language
  • Streaming responses via WebSocket
  • Custom chatbot creation with TypeScript
  • Provider management (OpenAI, Anthropic, etc.)
  • Rate limiting and token budgets
  • Conversation persistence

Quick Comparison

Section titled “Quick Comparison”
FeatureFluxbaseSupabaseFirebase
Deployment~70MB binary / ~110MB container~13 containers (~2.5GB)Cloud only
DependenciesPostgreSQL onlyPostgreSQL + 5+ servicesProprietary
Self-hosting✅ Easy⚠️ Complex❌ No
REST API✅ Built-in✅ PostgREST✅ Auto-generated
Authentication✅ Built-in✅ GoTrue✅ Built-in
Realtime✅ WebSocket✅ WebSocket✅ WebSocket
Storage✅ S3 or local✅ S3 or local✅ Cloud Storage
Edge Functions✅ Deno✅ Deno✅ Cloud Functions
AI Chatbots✅ Built-in❌ No❌ No
Background Jobs✅ Built-in✅ pg_cron (ext)❌ No
DatabasePostgreSQL 15+PostgreSQL 15+Proprietary (NoSQL)
Row-Level Security✅ Yes✅ Yes⚠️ Rules-based
Client SDKTypeScript/JSTypeScript/JSTypeScript/JS
Horizontal Scaling✅ Yes (distributed backends)✅ Yes (read replicas)✅ Yes (auto)
Open Source✅ AGPLv2✅ Apache 2.0❌ Proprietary

Getting Started

Section titled “Getting Started”

Prerequisites

Section titled “Prerequisites”
  • Go 1.25+ (for building from source)
  • PostgreSQL 15+

Quick Install

Section titled “Quick Install”
Terminal window
# Download the latest binary
curl -L https://github.com/fluxbase-eu/fluxbase/releases/latest/download/fluxbase-linux-amd64 -o fluxbase
chmod +x fluxbase


# Or use Docker
docker run -p 8080:8080 ghcr.io/fluxbase-eu/fluxbase:latest


# Or build from source
git clone https://github.com/fluxbase-eu/fluxbase.git
cd fluxbase
make build
./fluxbase

Your First API

Section titled “Your First API”
  1. Create a table in PostgreSQL:
CREATE TABLE public.posts (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    title TEXT NOT NULL,
    content TEXT,
    published BOOLEAN DEFAULT false,
    created_at TIMESTAMPTZ DEFAULT NOW()
);
  1. Access your auto-generated API:
Terminal window
# Create a post
curl -X POST http://localhost:8080/api/v1/tables/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "Hello World", "content": "My first post!"}'


# Query posts
curl http://localhost:8080/api/v1/tables/posts?published=eq.true

That’s it! Your API is ready.

Architecture

Section titled “Architecture”

Fluxbase is built as a monolithic Go application with a modular architecture:

graph TB
    Client[Client Application]


    subgraph Fluxbase ["Fluxbase (Single Binary)"]
        API[REST API Layer]
        RT[Realtime Engine]


        Auth[Auth Service]
        Storage[Storage Service]
        Functions[Functions Runtime]
        DB[Database Layer]


        API --> Auth
        API --> Storage
        API --> Functions
        API --> DB
        RT --> DB
        Auth --> DB
        Storage --> DB
        Functions --> DB
    end


    PG[(PostgreSQL)]
    S3[S3/Local Storage]


    Client --> API
    Client --> RT
    Fluxbase --> PG
    Storage --> S3

Next Steps

Section titled “Next Steps”

Community & Support

Section titled “Community & Support”

License

Section titled “License”

Fluxbase is open source and released under the AGPLv2 license.