🚧 v0 · early access — not for production🚧 FastCMS is under active development — not ready for production use. APIs and features may change without notice.
v0 · early access · open source

The backend you'd build,
shipped in Python.

The AI-native open-source BaaS on FastAPI. Auth, real-time, dynamic collections, file storage, and an admin dashboard ship in the core — RAG, vector search, and autonomous agents plug in on demand. One uv tool install away.

↓ install in 30 secondsuv tool install pyfastcms
~/projects/my-backend — fastcms
$uv tool install pyfastcms
$ Installed pyfastcms v0.1.4
$fastcms init my-backend
$created ./my-backend · initialized SQLite + admin
$fastcms dev
$ Server running on http://localhost:8000
$admin → /admin · docs → /docs · websocket → /realtime
01 / Foundation

A backend that disappears, so you can ship the product.

FastCMS handles the parts every app needs — auth, schemas, storage, real-time — so your codebase only contains the parts that make your app yours.

29
OAuth providers
Google, GitHub, Apple, +26
< 10m
Time to first API
install → CRUD endpoints
0
Database migrations
schemas auto-generate tables
Custom collections
define on the fly, no restart
02 / Capabilities

Every primitive your app needs. None it doesn't.

Explore the full feature set

Real-time, everywhere

WebSocket subscriptions and Server-Sent Events on every collection. Multi-instance broadcast through Redis pub/sub. Filter, authenticate, and rate-limit subscriptions with the same access rules as your REST API.

LIVE · 142 subscribers

Authentication

JWT, OAuth across 29 providers, 2FA/TOTP, API keys, magic links.

Dynamic Collections

Define schemas at runtime. FastCMS generates tables, REST endpoints, and admin UI.

Row-level access rules

Per-collection permission expressions. Read, create, update, delete — independently scoped per role.

Pluggable file storage

Local disk, AWS S3, or Azure Blob. Automatic image thumbnailing on upload.

Hooks & webhooks

React to every record event. Fire webhooks with signed payloads, retries, and per-collection filters.

03 / AI & Extensions

AI-native by plugin. Install what you need.

LLM providers, vector search, RAG, and autonomous agents — one command each: fastcms plugin install ai-core. The core wheel stays lightweight; AI capability scales with your needs, not your install size.

Run AI locally with Ollama — no API key, no cloud.
Same plugins, same endpoints. Bring your own provider — OpenAI, Anthropic, or self-hosted.
Browse all plugins on GitHub
Anatomy of a plugin

A folder, two functions, zero config.

FastCMS scans plugins/ on startup, validates each plugin's metadata, and calls register(ctx). If a plugin fails to load, the server starts anyway and logs the error. Settings live in the database — editable from the Admin UI.

  • Add API routes via FastAPI APIRouter
  • Subscribe to record events: create, update, delete
  • Inject pages into the admin sidebar
  • Persist settings in the plugin_settings table
Read the plugin SDK guide
plugins/hello/__init__.py
PLUGIN_META = {
    "id": "hello-world",
    "name": "Hello World",
    "version": "1.0.0",
}

def register(ctx) -> None:
    from fastapi import APIRouter
    router = APIRouter()

    @router.get("/hello")
    async def hello():
        return {"message": "Hello!"}

    ctx.include_router(router, prefix="/hello-world")
04 / Workflow

From uv tool install to a live API in three moves.

STEP / 0101

Install

One command. SQLite by default, swap to Postgres when you need it.

$ uv tool install pyfastcms
$ fastcms init my-backend
$ fastcms create-admin
STEP / 0202

Define a collection

Schemas live in the admin UI or a Python file. Tables are generated for you.

collection("posts",
  fields=[
    Text("title", required=True),
    Markdown("body"),
    Relation("author", → "users"),
  ],
  rules=auth.is_owner,
)
STEP / 0303

Use the API

REST endpoints, a typed SDK, real-time subscriptions, an admin UI — all generated.

# REST
GET /api/collections/posts
# Realtime
ws.subscribe("posts:*")
# Auth
POST /api/auth/oauth/github
05 / Dashboard

An admin you'd actually want to use.

Every collection, user, file, webhook, plugin, backup, and audit log — manageable from a single dashboard built into FastCMS. No separate service, no configuration.

localhost:8000/admin

Dashboard

System overview and statistics

Total Users

142

Admins: 3

New Users (7d)

18

View all users →

Collections

9

Manage collections →

Backups

12

Manage backups →

Files

384

Storage: 1.2 GB

Quick Actions

Manage Users

View, edit, and manage user accounts

Manage Collections

View and manage collections

API Documentation

View API docs and test endpoints

Recent Backups

backup_2026-03-04_09-00-00.db

4.2 MB

2 hours agoView

backup_2026-03-03_09-00-00.db

4.1 MB

1 day agoView
Schema editor
Define collections without writing SQL
Webhooks & hooks
React to every database event
Observability
Sessions, IP rules, metrics, audit log
06 / Stack

Built on technology you already trust.

FastAPI
0.115
Python
3.11+
SQLAlchemy
2.0 async
PostgreSQL
/ SQLite
Redis
pub/sub
JWT
python-jose
AWS S3
/ Azure Blob
Alembic
migrations
07 / Get started

Spin up your backend before your coffee gets cold.

Install pyfastcms, scaffold a project, and you have a running admin dashboard, REST API, and WebSocket server in under a minute. Move to Postgres + Redis when you need to scale — the API stays identical.

  • SQLite for development, PostgreSQL for production
  • JWT, OAuth, or API keys — pick one or use all three
  • Real-time built in: WebSocket and SSE
  • No vendor lock-in, MIT licensed
install.sh
# 1. Install
$ uv tool install pyfastcms
# 2. Create a project
$ fastcms init my-backend
$ cd my-backend
# 3. Migrate, create admin, run
$ fastcms migrate up
$ fastcms create-admin
$ fastcms dev

Build the backend, not the boilerplate.

FastCMS is open source and free forever. Read the docs, deploy in a few minutes, or contribute on GitHub.

MIT licensed · Open source · Self-hostable