Early Access · Source-Available · FastAPI + PostgreSQL

Backend manufacturer.
DSL in. Production FastAPI out.

Declare entities, modules and access policies in a YAML manifest. QiloBack compiles them into a complete FastAPI service — SQLAlchemy models, routers, services, tests, Alembic migrations, RLS policies, audit log, billing, realtime CDC and typed SDKs. Eject any time and keep the source under Apache 2.0.

Source-available (FSL-1.1-ALv2) Self-host or SaaS — your call Eject = Apache 2.0

DSL → FastAPI

One YAML manifest produces the entire backend: models, schemas, routers, services, repositories, tests, migrations, RLS, audit log and SDKs. Deterministic output, every regeneration identical.

The output is yours

Hit Eject and we hand you the FastAPI source under Apache 2.0. No QiloBack runtime in your code, no hidden dependency. Your backend keeps running long after you stop using us.

Self-host or SaaS

Run the entire control plane on your infrastructure or use the hosted offering. Same generator, same output. No telemetry by default, no vendor lock-in.

The Workflow

From manifest to running backend in five commands.

No dashboards required. The CLI is the interface. Everything works against your local Postgres.

01

qiloback init my-backend

Scaffold a new project from a template (CRM, marketplace, SaaS starter, helpdesk, LMS, real-estate — 14 verticals).

$ qiloback init acme-crm --template crm scaffolded acme-crm/ wrote qiloback.yml 12 entities · 4 modules
02

qiloback validate qiloback.yml

Type-check the DSL manifest. Catches every entity, relation, policy and module mismatch before you generate a single file.

$ qiloback validate qiloback.yml manifest valid v1 schema · 0 errors · 0 warnings
03

qiloback generate

Compile to FastAPI source: SQLAlchemy models, Pydantic v2 schemas, routers, services, repositories, pytest suites, Alembic migrations, RLS policies, OpenAPI doc and typed SDKs.

$ qiloback generate models 12 routers 84 endpoints rls 18 policies tests 312 specs sdks ts · py · dart
04

qiloback up

docker compose up — Postgres 16, Redis 7 and your API on localhost. Hot-reload on manifest changes.

$ qiloback up postgres localhost:5432 redis localhost:6379 api http://localhost:8000
05

qiloback eject

Hand off the generated source under Apache 2.0. Drop QiloBack from your toolchain whenever you want — the backend keeps running.

$ qiloback eject license rewritten to Apache-2.0 backend handed off acme-crm/ is yours
Features

Production-grade by default.

No SaaS lock-in unless you want it. Single CLI. One YAML file. First-party modules for everything a real backend needs.

auth

Auth out of the box

Email + magic-link, OAuth (Google, GitHub, Apple), passkeys, JWT with rotation, anonymous identities. No per-MAU charge.

rls

Row-level security

PostgreSQL RLS policies generated from the manifest. Tenant isolation, role-based access, per-row ownership — enforced at the database, not the app.

billing

Stripe + Orb wired

Subscriptions, metered billing, usage events, webhooks, customer portal. Hard-cap defaults to protect against runaway bills.

realtime

Realtime CDC

Change-data-capture over WebSocket with replay tokens. Subscribe to any table, any filter — driven by Postgres logical replication.

sdks

Typed SDKs generated

TypeScript, Python and Dart clients generated from the OpenAPI document on every regeneration. Always in sync.

audit

Audit log + soft-delete

Every mutation logged with actor, before/after diff and request_id. Soft-delete and optimistic locking baked in.

modules

20 first-party modules

Auth, billing, search, files, email, push, AI agents, RAG, feature flags, A/B tests, marketplace payments, i18n — all manifest-driven.

templates

14 vertical templates

Start from CRM, marketplace, helpdesk, LMS, healthcare, real-estate, ecommerce, social-network, delivery, booking, CMS, inventory, project-management or analytics.

Under the hood

YAML in. FastAPI out.

The DSL is the contract. The generated source is the implementation. Everything is reproducible, everything is reviewable, nothing is magic.

qiloback.ymlyaml
# A slice of the manifest — entities, RLS, billing, audit log
version: 1
name: acme-crm

entities:
  - name: Customer
    soft_delete: true
    audit: true
    fields:
      id:        { type: uuid, primary: true }
      org_id:    { type: uuid, tenant: true }
      email:     { type: email, unique: true }
      created_at:{ type: timestamp, auto: now }
    policies:
      - org_isolation           # RLS: tenant by org_id
      - role:admin can delete

modules:
  - auth.email_link
  - auth.passkey
  - billing.stripe
  - realtime.cdc
generated/customers/router.pypython
# Auto-generated from the manifest above. Apache 2.0 on eject.
from fastapi import APIRouter, Depends
from .schemas import CustomerCreate, CustomerRead
from .service import CustomerService
from qiloback_runtime.auth import require_role
from qiloback_runtime.audit import audit_log

router = APIRouter(prefix="/customers", tags=["customers"])


@router.post("/", response_model=CustomerRead, status_code=201)
@audit_log("customer.create")
async def create_customer(
    payload: CustomerCreate,
    svc: CustomerService = Depends(),
    actor = Depends(require_role(["member", "admin"])),
) -> CustomerRead:
    # RLS enforces org_isolation at the DB layer.
    return await svc.create(payload, actor=actor)
Who it is for

Built for teams who ship backends, not boilerplate.

Solo founders

Need a backend that scales without a backend team

Skip three weeks of FastAPI plumbing. Start with auth, billing and RLS already wired — the parts you would copy from your last project anyway.

Platform teams

Maintaining 5+ services that all need the same primitives

One DSL, many backends. Auth, audit log, RLS and observability stay consistent across services because they are generated, not handwritten.

Agencies & consultants

Shipping client backends fast without lock-in

Generate, ship, eject. The client owns the FastAPI source under Apache 2.0. You charge for the manifest and the deployment, not for a runtime that holds them hostage.

Early access

Join the waitlist.

QiloBack is in active development. We are onboarding teams in waves. Leave your email and we will reach out when early access opens for you.

No spam. No newsletter. We email once when early access opens for you.