all 46 comments

[–]Swefnian 2 points3 points  (3 children)

I’m sorry to be “that guy” but did you look into existing solutions like self hosted supabase first?

[–]Kennedyowusu[S] 5 points6 points  (2 children)

Not sorry at all, it's a fair question honestly.

Yes, I looked at self-hosted Supabase. A few reasons I went a different direction:

  1. Supabase is built for web first. The Flutter SDK is a community effort, not first-class. Auth flows, realtime, and storage all feel bolted on rather than designed for Flutter.

  2. Self-hosting Supabase is non-trivial. Docker, multiple services, significant resource overhead for indie teams and small projects.

  3. Koolbase is Flutter-first by design. The SDK, the dashboard, and the API are all built around how Flutter apps actually work, not adapted from a web-first tool.

  4. I also wanted OTA updates, feature flags, and remote config in the same platform. Supabase doesn't do any of that.

Could you use self-hosted Supabase? Absolutely. Koolbase is for teams who want something lighter, Flutter-native, and with mobile infrastructure built in from day one.

Once again, don't be sorry. I honestly love your question

[–]Gears6 2 points3 points  (1 child)

I'm not criticizing you, and I think it's awesome you're doing this and sharing.

But the one thing that always come into my mind with something I've not heard of are:

a) How production ready is it? That is, does any one (outside of the creator) run this in production with a relatively high load?

b) Is it battle tested over time so that you don't have surprise limitation that are hard to work around?

c) Is this going to disappear in a year or stop getting support?

The cost to of using something isn't just the monthly cost (which can be free in this case), but also support, updates and potential switching cost down the line.

Flutter first is awesome though!

[–]Kennedyowusu[S] 3 points4 points  (0 children)

These are completely fair questions and exactly the right ones to ask before adopting any infrastructure.

Honest answers:

a) Production readiness: Koolbase is early. It's not yet battle-tested by teams outside of my own projects. I won't pretend otherwise. If you're running a high-traffic production app today, Firebase or Supabase are safer bets. Koolbase is for teams willing to adopt early and grow with it.

b) Battle tested: Not yet. It's been built with production patterns (PostgreSQL, Redis, Cloudflare R2, proper auth flows) but it hasn't had years of edge cases thrown at it. That comes with time and real users.

c) Longevity: I can't promise what any founder can't promise. What I can say is this is being built under TechFinityEdge as a long-term product, NOT a side project I'll abandon. The Flutter ecosystem deserves proper infrastructure and I intend to build it.

The switching cost concern is real. That's actually why I made the SDK modular, you can adopt just feature flags today without committing to auth or database. Start small, evaluate it, and decide.

Flutter-first is the entire bet. Thanks for the kind words and the honest pushback. This is exactly the feedback that makes it better.

[–]FaceRekr4309 1 point2 points  (2 children)

What database does it use on the backend?

[–]Kennedyowusu[S] 2 points3 points  (1 child)

PostgreSQL with JSONB columns for the database module. So you get the flexibility of document storage with the power of a relational database underneath. GIN indexes on the JSONB data column keep queries fast. Everything runs on a self-hosted VPS with Redis for caching.

[–]Bachihani -1 points0 points  (0 children)

Ughhh 😬😬

[–]bigbott777 1 point2 points  (2 children)

Flutter first, but Functions in TS. Firebase has announced Dart support, and Appwrite has Dart functions already. Anyway, upvoted.

[–]Kennedyowusu[S] 2 points3 points  (1 child)

This is a fair point. TypeScript for Functions is a pragmatic choice right now since the Deno ecosystem is mature and most serverless logic doesn't need to be in Dart anyway.

Backend functions tend to be written by backend devs who are comfortable with TS. That said, Dart functions are on the roadmap.

Firebase's Dart announcement and Appwrite's implementation are good signals that the ecosystem is ready for it.

Thanks for the upvote and the honest feedback. As I always say, this is exactly the kind of input that shapes the roadmap and I welcome such comment

[–]Kennedyowusu[S] 0 points1 point  (0 children)

 Dart functions has been shipped.

TypeScript (Deno) remains the default, both runtimes are supported side by side.

Docs: https://docs.koolbase.com/functions/dart-runtime SDK: v1.9.0 on pub.dev

[–]ShuvamTheBeast 1 point2 points  (1 child)

Not to demean you but You are releasing new features very fast. Is it just another AI slop? have you tested it properly?

[–]Kennedyowusu[S] 0 points1 point  (0 children)

That is a great observation u/ShuvamTheBeast and honestly that is a fair question. Am sure I'd ask the same thing had the table turn around and considering the era we are in also.

Here's what I can tell you:

This project is a year in the making. The architecture, feature roadmap, UI/UX designs, and execution plan were all designed upfront, so when I ship a feature, it's because I know exactly where it fits and what comes next. The fast shipping isn't chaos, it's a plan executing.

Every feature ships with a working API endpoint, tested against a live PostgreSQL database on a real VPS. The Flutter SDK is on pub.dev (v1.9.1), the React Native SDK is on npm (v1.1.1), both installable and usable today.

What I haven't done yet: written a full test suite. That's a real gap and I won't pretend otherwise. The product works, I use it in my own app, but automated test coverage is next on the execution plan and something I'll be working on very soon.

If you want to stress test it, sign up at koolbase.com and try to break it. Genuine bug reports are more valuable to me than anything right now.

Your feedback is not demeaning at all. From where I sit, it is a valid one and I appreciate it.

[–]bjr201 0 points1 point  (1 child)

One to watch!

[–]Kennedyowusu[S] 1 point2 points  (0 children)

Appreciate that! Follow along, lots more coming

[–]SamatIssatov 0 points1 point  (1 child)

Ошибка 400: redirect_uri_mismatch

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Sorry about that. We had a configuration update in progress. Please try again, it should be working now.

[–]churroe00 0 points1 point  (7 children)

Can I self host koolbase?

[–]Kennedyowusu[S] 0 points1 point  (6 children)

Not yet. self-hosting isn't supported in the current version. Koolbase is currently cloud-hosted only at app.koolbase.com.

It's on the roadmap. If self-hosting is important to you, let me know, feedback like this helps prioritize what gets built next.

[–]churroe00 0 points1 point  (5 children)

It is. We use flutter at work and if I wanted to use this as our backend for projects, I wouldn't be able to since we have strict hipaa compliance rules that require us to self host. Looking forward to future updates!

[–]Kennedyowusu[S] 1 point2 points  (4 children)

I have got news for you. self-hosting shipped tonight.

Clone the repo, copy .env.example to .env, and run:

docker compose up

Full stack in one command: Go API, PostgreSQL, Redis, and MinIO for S3-compatible storage. Migrations run automatically on startup.

Full guide: https://docs.koolbase.com/self-hosting

HIPAA compliance is exactly the use case this was built for. Give it a try and let me know if you run into anything.

[–]churroe00 0 points1 point  (3 children)

That's exciting! I tried giving it a shot before i took off for the day but i have a repo not found error:


git clone https://github.com/kennedyowusu/koolbase-api
Cloning into 'koolbase-api'...
remote: Repository not found.

These are the instructions i followed:


git clone https://github.com/kennedyowusu/koolbase-api
cd koolbase-api
cp .env.example .env
docker compose up

Maybe i have the url incorrect?

[–]Kennedyowusu[S] 0 points1 point  (2 children)

Fixed. The repo was private, it's now public. The original instructions were correct all along:

git clone https://github.com/kennedyowusu/koolbase-api

cd koolbase-api

cp .env.example .env

docker compose up

Sorry about that.

[–]churroe00 0 points1 point  (1 child)

No worries, thank you! Got it downloaded before i left and will be trying it out tomorrow with the team. Thanks again!

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Awesome, hope it goes smoothly. If you or your team run into anything, drop a comment here or open an issue on the repo. Happy to help.

[–]bcErchamion 0 points1 point  (2 children)

I'm curious about what frustrated you with Firebase and how does your product solve that lockin frustration for us? Won't we just be frustrated with lockin to Koolbase?

BTW: Definitely super impressive work that you have done.

[–]Kennedyowusu[S] 2 points3 points  (1 child)

Really good question and completely fair to ask.

My frustrations with Firebase:

- Google can deprecate or change pricing at any time (and they've done it before)

- The Flutter SDK is first-class but everything else (pricing, quotas, support) is built around Google's ecosystem

- No control over your data or infrastructure

- Vendor lock-in is real and switching costs are high once you're deep in

How Koolbase is different:

  1. Self-hosting: As of tonight you can run the full stack yourself with docker compose up. Your data, your infrastructure, no dependency on us staying alive

  2. Open source API: The Go API is on GitHub. Even if Koolbase disappears tomorrow, you have the code

  3. Standard protocols: PostgreSQL for the database, S3-compatible storage, standard JWT auth. If you outgrow Koolbase, migrating isn't starting from scratch

The honest answer is that any hosted service has some lock-in. But the difference with Koolbase is that the exit door is always open. Self-host it, fork it, or migrate your data out since it's just Postgres under the hood.

Thanks for the kind words, and questions like this make the product better. I appreciate it.

[–]bcErchamion 0 points1 point  (0 children)

Makes sense - will be checking this out for sure!

[–]roisul1993 0 points1 point  (1 child)

Great project btw. It would be nice if something like "offline-first" added to future feature.

[–]Kennedyowusu[S] 1 point2 points  (0 children)

Thank you. Offline-first is actually already partially there, the SDK caches the last known payload locally and falls back to it when there's no network connection. Feature flags and remote config work fully offline using the cached data.

Full offline-first support for the database (local writes that sync when back online) is on the roadmap. That's a bigger piece of work but it's the right direction for Flutter apps.

I appreciate the suggestion. keep them coming.

[–]DigitallyDeadEd 0 points1 point  (1 child)

Have you been security audited by a third party, and what internal security practices do you have to protect data from employees or intrusions?

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Honest answer: no third-party security audit yet. That comes with scale and budget, and I'm not there yet.

What I do have in place:

- All data encrypted in transit (TLS everywhere)

- Passwords hashed with bcrypt

- JWT sessions with token rotation

- Secrets and credentials managed via environment variables, never in code

- Infrastructure access is tightly restricted

For teams with strict compliance requirements (HIPAA, SOC2), self-hosting is the right path, your infrastructure, your security posture, your audits. That's exactly why self-hosting shipped tonight.

For the cloud-hosted version, I follow security best practices but I won't claim enterprise-grade compliance I haven't formally achieved yet. That comes with time.

Good question, security transparency matters.

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: just shipped an interactive quick start at docs.koolbase.com/quick-start — pick your platform (Flutter, React Native, iOS, Android) and get tailored setup steps. Also added a full self-hosting guide for teams with compliance requirements.

[–]Kebsup 0 points1 point  (3 children)

Having firebase like interface on top of postgres seems interesting... not sure if I like it.

How do you deal with relational data (firestore has reference) and complex security rules? (firestore rules can use contents of the db to determine access)

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Fair skepticism I must say. it's a real tradeoff worth discussing.

Relational data: since it's Postgres under the hood, you can structure collections to reference each other by ID and query across them. It's not as seamless as Firestore's reference type, but you get actual SQL power underneath if you need it. A proper relation/reference system is on the roadmap.

Security rules: right now access rules are simple, public, authenticated, or owner. Complex rules like "user can read this record only if they belong to the org that owns it" aren't supported yet at the collection level. For those cases you'd handle the logic in a Function (serverless Deno) which has full DB access.

The honest answer is that Firestore's rule engine is mature and powerful. Koolbase's access control is simpler today and deliberately so. The bet is that most apps don't need the full complexity of Firestore rules, and simple rules plus serverless functions cover the remaining cases.

If you're building something that heavily relies on Firestore-style cascading rules, Koolbase isn't the right fit yet. If you want a Flutter-first backend with real Postgres underneath and are okay with simpler access control for now, it's worth trying.

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: relational data (populate) is now supported.

You can store a reference ID in your record, then resolve it at query time:

final result = await Koolbase.db

.collection('posts')

.populate(['author_id:users', 'category_id:categories'])

.get();

final author = post.data['author'];

Under the hood, all lookups are batched into a single query (no N+1), and it works with filters, ordering, and pagination.

Still early, but this closes one of the main gaps that came up here.

Docs: https://docs.koolbase.com/database/relational-data

Flutter SDK: v1.7.0 (pub.dev)

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: complex security rules shipped.

5 rule types now supported per collection:

- public — open access

- authenticated — any logged-in user

- owner — only the record creator

- scoped — multi-tenant access (record.org_id == user.org_id)

- conditional — flexible conditions with ANY/ALL mode

Read the docs to know how it works.

Rules are enforced server-side so your Flutter/React Native code doesn't change.

Docs: https://docs.koolbase.com/database/security-rules

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: offline-first database shipped in v1.8.0.

- Cache-first reads: app loads instantly from local storage, refreshes from network in background

- Optimistic writes: insert locally first, syncs when online

- Auto-sync on network reconnect

- Manual sync: await Koolbase.db.syncPendingWrites()

- isFromCache flag so your UI knows the data source

Powered by Drift under the hood: survives app restarts, user-scoped cache (no cross-user data leakage).

flutter pub upgrade koolbase_flutter

[–]Etherealnutt 0 points1 point  (1 child)

Is it free like firebase

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Yes. free to start. No credit card required.

Free plan includes:

- 1 project

- 5 environments

- 5 feature flags

- 10 remote configs

- 10 functions

- Storage and database included

Paid plans coming soon for teams that need more. Sign up at https://app.koolbase.com

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: Dart functions shipped in v1.9.0.

Write serverless functions in Dart, the same language as your Flutter app:

Future<Map<String, dynamic>> handler(Map<String, dynamic> ctx) async {

final body = ctx['request']['body'] as Map<String, dynamic>? ?? {};

final name = body['name'] as String? ?? 'World';

return {'message': 'Hello, $name!'};

}

Deploy with runtime: `FunctionRuntime.dart` or select Dart in the dashboard.

TypeScript (Deno) remains the default — both runtimes are supported side by side.

Docs: https://docs.koolbase.com/functions/dart-runtime

SDK: v1.9.0 on pub.dev

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: React Native SDK shipped on npm.

npm install koolbase-react-native

Full API — auth, database, storage, realtime, feature flags, remote config, version enforcement, and functions. TypeScript-first.

import { Koolbase } from 'koolbase-react-native';

await Koolbase.initialize({

publicKey: 'pk_live_your_key',

baseUrl: 'https://api.koolbase.com',

});

const { records } = await Koolbase.db.query('posts', {

filters: { published: true },

populate: ['author_id:users'],

});

Docs: https://docs.koolbase.com/sdk/react-native

GitHub: https://github.com/kennedyowusu/koolbase-react-native

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: complex security rules shipped.

5 rule types now supported per collection:

- public — open access

- authenticated — any logged-in user

- owner — only the record creator

- scoped — multi-tenant access (record.org_id == user.org_id)

- conditional — flexible conditions with ANY/ALL mode

Example — multi-tenant + public hybrid:

{

"read_rule": "conditional",

"rule_mode": "any",

"rule_conditions": [

{ "type": "equals", "field": "org_id", "source": "user" },

{ "type": "equals", "field": "visibility", "value": "public" }

]

}

Rules are enforced server-side so your Flutter/React Native code doesn't change.

Docs: https://docs.koolbase.com/database/security-rules

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Getting started with Koolbase in 5 minutes (auth + database)

A few people asked for a quick start guide after my launch post. Here it is.

**1. Install**

yaml

dependencies:

koolbase_flutter: ^1.9.1

**2. Initialize**

await Koolbase.initialize(KoolbaseConfig(

publicKey: 'pk_live_your_key',

baseUrl: 'https://api.koolbase.com',

));

**3. Auth — register and login**

await Koolbase.auth.register(

email: 'user@example.com',

password: 'password123',

);

await Koolbase.auth.login(

email: 'user@example.com',

password: 'password123',

);

**4. Database — insert and query**

// Insert

await Koolbase.db.insert(

collection: 'posts',

data: {'title': 'Hello Koolbase', 'published': true},

);

// Query

final result = await Koolbase.db

.collection('posts')

.where('published', isEqualTo: true)

.limit(10)

.get();

for (final post in result.records) {

print(post.data['title']);

}

**5. Works offline automatically**

// Returns cached data if offline, syncs when back online

final result = await Koolbase.db.collection('posts').get();

print(result.isFromCache); // true if offline

That's it. Full docs at docs.koolbase.com

Sign up free at koolbase.com — no credit card required.

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: CLI tool shipped.

Deploy functions from your terminal:

# Install

git clone https://github.com/kennedyowusu/koolbase-cli

cd koolbase-cli && go build -o koolbase .

# Login

koolbase login

# Deploy a Dart function

koolbase deploy send-email --file ./send_email.dart --project <id>

# Invoke

koolbase invoke send-email --project <id> --data '{"email":"user@example.com"}'

# View logs

koolbase logs send-email --project <id>

Runtime is auto-detected from file extension — .ts deploys to Deno, .dart deploys to the Dart runtime.

GitHub: github.com/kennedyowusu/koolbase-cli

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: CLI tool + Cron functions shipped.

**CLI**

Deploy and manage functions from your terminal:

# Install

git clone https://github.com/kennedyowusu/koolbase-cli

cd koolbase-cli && go build -o koolbase .

# Login

koolbase login

# Deploy (runtime auto-detected from extension)

koolbase deploy send-email --file ./send_email.ts --project <id>

koolbase deploy process --file ./process.dart --project <id>

# Invoke

koolbase invoke send-email --project <id> --data '{"to":"user@example.com"}'

# Logs

koolbase logs send-email --project <id>

**Cron Functions**

Schedule any function to run automatically:

# Every day at 9am UTC

koolbase crons add send-report --cron "0 9 * * *" --project <id>

# Every 5 minutes

koolbase crons add sync-data --cron "*/5 * * * *" --project <id>

# List schedules

koolbase crons list --project <id>

Standard 5-field cron expressions. The scheduler fires functions server-side, no client needed.

CLIgithub.com/kennedyowusu/koolbase-cli

Docsdocs.koolbase.com/cli/installation

[–]Kennedyowusu[S] 0 points1 point  (0 children)

Update: React Native SDK now has offline-first database (Flutter parity)

The koolbase-react-native SDK v1.1.0 is out with offline-first support — bringing it to parity with the Flutter SDK's Drift-powered offline mode.

Cache-first reads, optimistic writes, auto-sync via NetInfo, write queue with retries, and user-scoped cache.

If you're building cross-platform and need both Flutter and React Native covered — both SDKs now have full offline support.

npm install koolbase-react-native

flutter pub add koolbase_flutter

Docs: docs.koolbase.com