From idea to app. And everything after.

Design your app, power it with a complete backend, and keep shipping after release.

Start buildingExplore the platform

Describe what you want to build

01/ 10 · KoolPOS · Point of sale
09:414G

KoolPOS

Point of sale

Terminal
Osu · POS 04
Online
Preparing your workspace
Products & pricingSyncing…
Inventory
Customer records
Recent transactions
Loading products…24%
Running in production today.·Start with the Designer →
Koolbase Designer

Describe a screen. Get real Flutter.

The Designer writes Dart you can open in your editor, already wired to the collections in your project. Not a mockup, not a component library. Run it and the real app builds and opens in the frame. Real sign-in, real data, about three minutes.

Prompt

Start building
See another

Workflow

How Koolbase Works

From an empty project to an app your users are running — one SDK, one dashboard, four steps.

1

Create a project

Production
pk_live_8231...
Staging
pk_test_4190...
Development
pk_test_7714...

Sign up, create a project, and get your keys. Separate environments for production, staging, and development — isolated from day one.

2

Add the SDK

pubspec.yaml · main.dart
// Add dependency
dependencies:
koolbase_flutter: ^12.8.0
// Initialize once
await Koolbase.initialize(KoolbaseConfig(
publicKey: 'pk_live_...',
baseUrl: 'https://api.koolbase.com',
));

Flutter, React Native or the browser — koolbase_flutter, @koolbase/react-native or @koolbase/js. One call gives you auth, database, storage, realtime, functions and flags, with the same access rules behind all three.

3

Build your screens

orders_screen.dart
await Koolbase.auth.login(email, pwd);
KoolbaseCollectionList(
collection: 'orders',
itemBuilder: (ctx, r) =>
OrderTile(r),
)
final show = Koolbase.isEnabled('new_ui');

Write them yourself, or describe one and let the Designer generate the Flutter — wired to a collection in the same project. Press Run and the real app opens in the frame: real sign-in, real data. Either way it is Dart you own — Riverpod, typed routes, i18n, tests — and it runs on iOS, Android and the web.

4

Keep shipping

send-welcome-email
91ms
patch #1 → ios/stable
activated
process-payment
30s
1 failed → retrying with backoff

Deploy functions, set DB triggers, push real code fixes over the air, watch execution logs, and control rollouts — all from one dashboard.

Authentication

User auth that works out of the box.

Register, login, verify email, reset passwords — in your web or mobile app with a single SDK. Sessions are JWT-based and scoped per environment.

  • Email + password with verification
  • JWT sessions scoped per project environment
  • OAuth (Google + Apple) with server-side JWKS verification
  • Phone + OTP via Twilio, Africa's Talking, or Hubtel
  • Typed errors (account locked, rate limited, token revoked)
auth.dart
// Register a new user
final user = await Koolbase.auth.register(
email: '[email protected]',
password: 'securepassword',
);
// Get current session
final me = await Koolbase.auth.currentUser();
// Logout
await Koolbase.auth.logout();
database.dart
// Insert a record
await Koolbase.db.collection('posts').insert({
'title': 'Hello Koolbase',
'body': 'My first post',
});
// Query with filters
final posts = await Koolbase.db
.collection('posts')
.where({'author': userId})
.limit(10)
.get();

Database

Flexible JSONB collections. No schema migrations.

Store any shape of data in collections. Define read, write, and delete rules per collection — public, authenticated, or owner-only.

Access Rules

Control who can read, write, or delete records at the collection level.

Realtime Subscriptions

Stream live record updates to your app over WebSocket with zero extra setup.

GIN-Indexed JSONB

Fast queries on any JSON field without predefined schema.

Semantic Search

Search by meaning, not keywords.

Declare a vector field on any collection and Koolbase auto-embeds every record on insert and update — via your Gemini or OpenAI key, kept server-side. Query with plain text; HNSW indexing keeps lookups sub-millisecond.

  • Auto-embed on every insert and update — zero glue code
  • BYOK: Gemini or OpenAI; API key stays server-side
  • HNSW indexing across 384 / 768 / 1024 / 1536 dimensions
  • searchSemantic with queryText or pre-computed vectors
  • Dead-letter queue with replay for failed embeddings
semantic.dart
// Insert — auto-embeds question_embedding
await Koolbase.db.collection('faqs').insert({
'question': 'How do I cancel my subscription?',
'answer': 'Open settings → billing → cancel.',
});
// Search by meaning
final hits = await Koolbase.db
.collection('faqs')
.searchSemantic(
field: 'question_embedding',
queryText: 'stop paying',
limit: 5,
);

Storage

Upload, serve, and manage files from any client.

Backed by Cloudflare R2. Upload files directly from the device with presigned URLs — no server relay needed. Attach custom key-value metadata, enforce per-bucket size and MIME-type limits at presign time, and get typed errors when something is rejected.

  • Direct device-to-R2 upload with presigned URLs
  • Custom key-value metadata on every object
  • Per-bucket size and MIME-type limits enforced at presign
  • Safe-by-default uploads with typed conflict errors
storage.dart
// Upload with custom metadata
final result = await Koolbase.storage.upload(
file,
bucket: 'avatars',
path: 'user_abc.jpg',
metadata: {
'user_id': userId,
'orig_filename': 'IMG_0942.HEIC',
},
);
// Update metadata later (merge semantics)
await Koolbase.storage.updateMetadata(
bucket: 'avatars',
path: 'user_abc.jpg',
metadata: {'alt_text': 'Profile photo'},
);
send-welcome-email/index.ts
export async function handler(ctx) {
// Access your encrypted secrets
const apiKey = Deno.env.get('SENDGRID_KEY');
// Read from DB
const user = await ctx.db.find('users', {
id: ctx.request.payload.user_id
});
// Send email, call external API, etc.
return { ok: true };
}

Functions

Serverless logic that runs when your data changes.

Write TypeScript (Deno) or Dart functions and deploy them from the dashboard or CLI. Trigger via HTTP or bind to database events.

Deno + Dart Runtimes

Deploy TypeScript functions on Deno or Dart functions on the Dart runtime — your choice per function.

Event Triggers

Fire functions on database mutations, storage object lifecycle, or user signup — no polling, no glue code.

Retry + DLQ

5-retry exponential backoff with a Dead Letter Queue for permanently failed executions.

Code Push

Ship a fix in minutes. Pull it back just as fast.

Real Dart, delivered over the air to iOS and Android. Patches are Ed25519-signed with your own key and pinned to the exact binary they were built against, so a patch physically cannot land on the wrong release. Applied before the first frame — no restart, no reload flash, nothing the user sees.

  • VM-level Dart patching — real code, not a config bundle
  • Ed25519-signed and pinned to the binary build ID
  • Refuses to build patches containing constructs it cannot apply safely
  • Applied before the first frame, on iOS and Android
  • A patched boot that crashes rolls back on the next launch
  • Recall any patch in one click — devices fall back to the store build
Release 1.4.2 · stablelive
ptch_85278d03live
Fix order total label
100%
ptch_1a4fe920rolling
Null check on empty cart
25%
ptch_c07b3355recalled
Retry on timeout
0%

App Infrastructure

The control layer every app needs.

Flags, config, analytics and fiscalization on every client. Version gates, over-the-air bundles and push where they mean something — on mobile, where everyone else waits for store review and you ship.

Designer & Run

Describe a screen and get real Flutter, wired to your data. Press Run and the app builds and opens in a phone frame in about three minutes — then export code a team would keep.

Flags & Remote Config

One place for the values your app reads at launch. Gate a feature to a percentage of users, or change copy, pricing, endpoints and limits — without a release.

Over-the-Air Bundles

Ship assets, screen layouts (rfw), and JSON behaviour rules as one versioned bundle. Rolled out by percentage, recalled in one click, no store release.

Version Enforcement

Force or softly prompt users to update. Block legacy versions with a custom message and store link.

Fiscalization

Selling in a country that certifies invoices? Every sale gets a gapless fiscal number, a sealed immutable record, and the tax authority’s signature and QR on the receipt. Live for Ghana (GRA E-VAT).

Cloud Messaging

Send push notifications to your users via FCM — register tokens, broadcast to all devices, and track delivery from the dashboard.

Analytics

Track screen views, custom events, and user behaviour. View DAU, WAU, MAU, top events, and top screens — no third-party SDK needed.

Ship the fix today. Not after store review.

One command, and the app on your users' phones updates itself. No rebuild. No review queue.

orders_screen.dart
42@override
43Widget build(BuildContext context) {
44 return Column(
45 crossAxisAlignment: CrossAxisAlignment.start,
46 children: [
47 // summary row
48 Text('Order total', style: theme.caption),
49 PriceLine(total: order.total),
50 ],
51 );
52}
$
signed · ed25519 · ✓ applied before first frame
$
signed · ed25519 · ✓ applied before first frame
no rebuild · no store review
9:41
Orders
3 open
Sarah Mitchell$ 240.00
Order total
James Whitfield$ 85.50
Order total
Emily Carter$ 1,120.00
Order total
Updated in place
iOS · 1.4.2

SDKs

Flutter, React Native and the web.

One dependency for your whole backend, published on pub.dev and npm. VM-level code push and fiscalization are Flutter-only; everything else ships on all three.

koolbase_flutter
89 releases · pub.dev
v12.8.0
v1.8.0Offline-first with optimistic writes
v2.0.0Code push — runtime bundles
v8.0.0Auto-embedding semantic search (BYOK)
v9.1.0VM-level code push — real Dart over the air
v11.2.0Fiscal — authority-certified sales (Ghana GRA E-VAT)
v12.0.0Flutter Web — auth, database, storage, realtime and functions in the browser
pubspec.yaml
dependencies:
koolbase_flutter: ^12.8.0
@koolbase/react-native
15 releases · npm
v12.2.0
v1.0.0Auth, database, storage, realtime, functions, flags
v1.1.0Offline-first with optimistic writes
v8.0.0Hybrid search — semantic + BM25, RRF fusion
v9.2.0Offline chains replay whole — UUID ids from birth
v10.0.0Shared core with @koolbase/js — one codebase, two hosts
v12.0.0Account settings, session management and aggregate queries

Code push is Flutter-only — it patches the Dart VM, which has no React Native equivalent.

terminal
$ npm install @koolbase/react-native
@koolbase/js
12 releases · npm
v12.2.0
v10.0.0The same core as React Native, composed for the browser
v10.0.1Runs under server rendering without crashing
v10.1.0Uploads take a File; storage degrades by capability
v10.2.0Tabs coordinated — one replays the queue, not each
v12.0.0Account settings, session management and aggregate queries

TypeScript, ESM and CommonJS, 16 kB gzipped — offline queue and conflict resolution included.

terminal
$ npm install @koolbase/js
Building web and mobile? One backend serves both→
Every release since v1.0.0→

More platforms in development

Swift (iOS)Soon
Kotlin (Android)Soon

Agent-Native

The backend your AI agent already knows how to build against.

Koolbase exposes your backend over MCP, so the coding agent you already work in reads your real collections, access rules, and SDK surface instead of guessing at them. The server ships inside the Koolbase CLI — one entry in your agent's config and your backend is in the room.

It knows your schema

Your collections, storage buckets, deployed functions, and environments — read from the project itself. Generated code uses the names that exist, not names that sound plausible.

It respects your access rules

Rules arrive as data, not advice. An agent handed scoped(user_id → caller.id) writes the filter; an agent handed a paragraph forgets it. Secrets and function source never leave your project.

It knows the SDK's idioms

The query pattern, the offline write path, the conflict surface — for Flutter, React Native and the browser, each with its own real call shapes. No invented methods, no hallucinated parameters.

The same prompt — “list the signed-in user’s conversation members” — without and with Koolbase connected:

without MCPinvented
// guessed client, guessed method
final records = await client
    .collection('conversation_members')
    .list();

// no idea the read rule is scoped,
// so no filter — returns nothing
// and nobody knows why
with Koolbase MCPwriting

Real collection. Real access rule, honoured. Real SDK surface — including the widgets that handle cache-then-refresh and the signed-out state for you.

Works with any MCP-capable agent — Claude Code, Claude Desktop, Cursor.

Connect your agent →

AI Assistant

Change your backend by asking. Approve it before it happens.

Every project ships with an assistant that works on your actual infrastructure — flags, remote config, environments, even recalling a live code-push patch. It reads real state to answer, and it never changes anything without showing you the diff first.

why aren't new users seeing the referral banner?

The referral_banner flag is off in production.

environmentenabledrollout
developmenttrue100%
stagingtrue100%
productionfalse0%

turn it on for 10% of production

Review changefeature_flags · production
referral_banner
enabledfalse→true
rollout0%→10%
ConfirmCancelNothing changes until you confirm

Reads live state

No stale answers. It queries your real project on every question — your flags, your environments, your releases — and answers with tables, not guesses.

Every change is audited

An approved change lands in your audit log exactly like a dashboard edit — same record, same attribution. Nothing the assistant does is invisible afterwards.

Grounded in the docs

Answers about Koolbase itself come from the documentation — with citations — not from a model's imagination. Ask how anything works and get the real answer.

Included on every plan — 15 messages a day on Free, 200 on Pro.

Read how it works

Why Koolbase

Your app doesn't stop needing you after launch.

A backend is only part of what it takes to keep an app running. Users lose connectivity. Bugs make it into production. A mobile fix can sit waiting for store review. Koolbase brings the backend, offline sync and — on Flutter — code push together, so you can build, recover and keep improving after release.

Ship a real Dart fix to production today — iOS and Android, no store review. Signed with your own key, pinned to your exact binary, applied before the first frame, and recalled in one click if you change your mind.

Fix it the same day

Describe a screen and the Designer writes the Flutter for it — then wires it to collections in the same project. Designing a screen and having a backend for it stop being two separate jobs.

Design and backend, one act

Functions have a test mode with a mock database, so you can validate trigger logic without touching real data. Failed events retry five times and then land in a queue you can inspect and replay — nothing fails silently.

Production reliability built in
Ed25519
Every patch signed with your key
Daily
Encrypted off-site backups, restore-tested
Zero
Failed events dropped — every one is retried, then parked for replay
Never
Free projects paused

Pricing

One platform. One bill. Code push included.

Build your whole app on the free tier — it never pauses. Pay when your app becomes a business.

Free projects never pause. Not after a week, not ever.

Koolbase runs on shared multi-tenant infrastructure, so an idle project costs us almost nothing to keep awake. Platforms that give every project its own instance burn compute whether you're using it or not — which is why they have to put yours to sleep.

Free

Build and launch a real app, the whole platform, no card.

$0/mo
  • 10,000 monthly active users
  • 2 projects that never pause
  • Auth, Database, Storage, Realtime
  • Designer — no screen limit
  • Run — the real app in the frame, 20 runs a day
  • 250 functions (100k invocations/mo)
  • 3 environments (dev · staging · prod)
  • 1 GB storage
  • 20 feature flags · 20 remote configs
  • AI Assistant — 15 messages/day
  • Code Push — 5,000 patch installs/mo
  • Fiscalization — 1,000 certified transactions/mo
  • Community support
Get Started
Most Popular

Pro

For apps in production. Everything in Free, with room to grow.

$25/mo

Need more than the included amounts? Additional usage is available on request — we scale limits with you.

Spend caps on by default — no surprise invoices.

  • 100,000 monthly active users
  • Unlimited projects
  • Designer — no screen limit
  • Run — the real app in the frame, 20 runs a day
  • 100 GB storage
  • Functions (2M invocations/mo)
  • 10 environments
  • Unlimited flags, configs & secrets
  • AI Assistant — 200 messages/day
  • Code Push — 50,000 patch installs/mo
  • Fiscalization — 25,000 certified transactions/mo
  • 5 team members
  • Usage-based scaling beyond limits
  • Email support
Start building

Enterprise

For large-scale production infrastructure.

Custom
  • Custom MAU & usage limits
  • All Pro features
  • Fully dedicated infrastructure
  • Unlimited environments
  • SSO / SAML authentication
  • Role-based access control
  • SLA guarantee
  • Dedicated support engineer
Contact Sales

No credit card required. Upgrade only when your app grows.

FeatureFree
Pro		Enterprise
Core backend
Monthly Active Users10,000
100,000 included · more on request		Custom
Projects2 — never paused
Unlimited		Unlimited
Environments3
10		Unlimited
Authentication
DatabaseShared
Shared		Dedicated
Storage1 GB
100 GB included · more on request		Custom
Realtime connections200
500 included · more on request		Custom
Function invocations100k/mo
2M/mo		Custom
Functions250
Unlimited		Unlimited
Function secrets10
Unlimited		Unlimited
Design & AI
DesignerNo screen limit
No screen limit		Custom
AI Assistant15 messages/day
200 messages/day		Custom
Semantic Search (BYOK)
Shipping & control
Code Push (patch installs)5,000/mo
50,000/mo included · more on request		Custom
Over-the-air bundles
Feature flags20
Unlimited		Unlimited
Remote config20
Unlimited		Unlimited
Version enforcement
Analytics
Cloud Messaging
Fiscalization (certified transactions)1,000/mo
25,000/mo included · more on request		Custom
Team & support
Team members1
5, then per-seat		Unlimited
SSO / SAML—
—
Role-based access control—
—
SupportCommunity
Email		Dedicated engineer

Designer has no screen limit on any plan. Generations draw on the same daily AI allowance as the Assistant — 15 a day on Free, 200 on Pro.

Free and Pro run on shared database and bandwidth. We'll contact you before taking any action if your usage is significantly above normal — no throttling without a conversation.

Security & Trust

Built for teams that ask hard questions.

Your data is encrypted, backed up, and hosted in the EU. See exactly how we protect it — the same answers your security team needs before signing off.

View security overview
EU-hostedGDPR-alignedEncrypted in transit & at restEncrypted off-site backups

FAQ

Frequently Asked Questions

Everything you need to know before building with Koolbase.

Getting started

Which platforms does Koolbase support?
Three published SDKs — Flutter, React Native and the browser — over one backend: auth, database, semantic search, storage, realtime, functions, feature flags, remote config, analytics, and an offline write queue with conflict resolution on all three. Two things are Flutter-only, because they patch the Dart VM and have no equivalent elsewhere: code push and server-driven UI. Push notifications need a native module, so the browser uses Web Push. Swift and Kotlin are in development.
What do I get that I would otherwise build myself?
One backend under every client you ship — the same users, the same access rules, the same data, whether the request comes from a browser or a phone. An offline write queue with cached reads and explicit conflict resolution, in the SDK rather than in your code. Semantic and keyword search over your own records without running a vector database. On Flutter, a fix shipped to installed apps without a store review. And fiscalization: if you sell where invoices are certified, Koolbase records the sale, gets it certified by the tax authority, and puts the signature and QR on your receipt.
Do I have to change how I build my app?
You add the SDK and build through the Koolbase CLI instead of calling flutter build directly. The CLI runs the same build with the flags code push needs and registers the resulting binary as a release, so patches can be pinned to it later. Everything else about your project stays as it is.

Code push

What is Code Push?
A Flutter feature, in two tiers. Over-the-air bundles push config overrides, flag overrides, screen layouts and assets — versioned, signed, activated on the next cold launch. VM patches push fixes to your actual compiled Dart code on iOS and Android: signed with your own Ed25519 key, pinned to the exact binary they were built against, and applied before the app draws its first frame. Ship a real bug fix without waiting for store review. Neither exists for React Native or the browser: there is no Dart VM to patch, and the web already ships on deploy.
Is iOS code push allowed by Apple?
Yes, by construction. Apple permits downloaded interpreted code but not downloaded compiled code — so Koolbase delivers iOS patches as signed bytecode executed by the engine’s interpreter, never as downloaded machine code. App Store policy also narrows what you should ship this way: bug fixes that don’t change your app’s primary purpose, not feature delivery around review. The same policy space Shorebird and Expo Updates operate in.
What happens if a patch is bad?
Recall it. A recalled patch stops being served immediately, and devices fall back to the code compiled into the store build — the original binary is never modified, so there is always something correct to fall back to. Patches can also be rolled out to a percentage of devices first, so a mistake reaches a slice of your users rather than all of them.
Can a patch land on the wrong version of my app?
No. Every build gets a build ID derived from a hash of its compiled code, and every patch carries the ID of the binary it was built against. A device only applies a patch whose ID matches the binary it is running. A patch built for 1.4.2 is inert on 1.4.1 — it is not applied and then reverted, it is never applied at all.

Designer

What is Koolbase Designer?
Describe a screen in plain language and Designer produces a Flutter interface for it — then wires that interface to collections in your project, so the list you just designed reads real records instead of placeholder data. It is the same platform on both sides, which is the point: designing a screen and having a backend for it are one act rather than two.
Does Designer produce real Flutter code?
Yes — Dart you can open in your editor, not an export from a proprietary format and not a runtime that renders someone else’s widget tree. You own the output and you can keep editing it by hand afterwards.
What does Designer cost?
Nothing extra. There is no screen limit on Free or Pro — Designer generations draw on the same daily AI allowance as the Assistant, which is 15 a day on Free and 200 on Pro.

Backend

What is Semantic Search?
Declare a vector field on any collection (via dashboard or CLI) and Koolbase auto-embeds every record on insert and update — using your Gemini or OpenAI API key, which stays server-side. Then call searchSemantic with plain queryText and Koolbase embeds the query and returns ranked hits. HNSW indexing across 384, 768, 1024, and 1536 dimensions keeps lookups sub-millisecond. Failed embeddings land in a per-project Dead Letter Queue with one-click replay.
What are database access rules?
Each collection has three configurable rules — read, write, and delete. Rules can be set to public (anyone), authenticated (must have a valid session token), or owner (only the record creator). These are enforced server-side on every request.
What is the Functions runtime?
Functions run on Deno in an isolated subprocess, with full TypeScript support, access to ctx.db for database operations, and Deno.env.get() for encrypted secrets. You can also deploy Dart functions on the Dart runtime. Timeouts are configurable at 5s, 10s, or 30s. Max function size is 1MB.
What happens when a function fails?
Failed trigger executions are automatically retried up to 5 times with exponential backoff (1, 2, 4, 8, 16 minutes). If all retries fail, the event moves to the Dead Letter Queue. From the dashboard you can inspect the error, fix your function, and replay the event with one click.
How are secrets stored?
Secrets are encrypted with AES-256-GCM using a server-side key before being written to the database. Secret values are never returned by the API — only names are exposed. At function execution time, secrets are decrypted in memory and injected as environment variables.
What is version enforcement?
Version enforcement lets you set a minimum required app version per environment. If a user is below the minimum, the SDK returns a force_update flag along with a configurable message and store URL. Use it to block legacy versions after a breaking API change or a critical security patch.
What is fiscalization, and do I need it?
A growing number of countries require every sales invoice to be reported to the tax authority in real time, with the authority’s signature and QR code printed on the receipt. If you build a point-of-sale or invoicing app in one of them, you need it. Koolbase gives every transaction a gapless fiscal number, seals it as an immutable record, delivers it to the authority, and returns the certification your receipt must carry. Ghana (GRA E-VAT) is live; the same engine runs the full record-keeping machine anywhere an authority integration doesn’t exist yet. Merchants get their credentials from their own tax authority — Koolbase never sits between a taxpayer and their regulator.

Plans

Is there a free tier?
Yes, and it is a real one: 10,000 monthly active users, 2 projects, 3 environments, 1 GB storage, 100k function invocations a month, 20 feature flags, 20 remote configs, 5,000 code push patch installs, and Designer with no screen limit. No credit card required.
Will my free project be paused if I stop using it?
No. Koolbase runs on shared multi-tenant infrastructure, so an idle project costs almost nothing to keep awake. Platforms that give every project a dedicated instance burn compute whether you are using it or not, which is why they have to put yours to sleep. We do not, so we do not.

Design it. Build it. Ship the fix today.

One platform for your Flutter and React Native apps — from the first screen to the fix that lands on phones already in the field.

Free to start. No credit card. Free projects never pause.

Start buildingRead the docs→