Now in Public Beta

Define Your Schema. Get Your API.

Graph-based Backend-as-a-Service. Define entities and relationships with our visual Schema Editor, get auto-generated REST + GraphQL APIs instantly. No backend code required.

Visual Schema Editor
REST + GraphQL parity
MCP tool integration
Graph-powered data
Get Started Free
Read the Docs See How It Works
FLXBL Visual Schema Editor showing entities and relationships
No-Code Schema Design

Visual Schema Editor

Design your data model visually. Create entities, define fields, and connect relationships with drag-and-drop—no JSON required.

See the Schema Editor in action: creating entities and relationships

Visual Graph Editor

See your entire data model at a glance. Entity nodes show fields and connect via relationship edges on an interactive canvas.

Graph-based schema visualization with connected entities

Drag-and-Drop Relationships

Create relationships by dragging from one entity handle to another. Define cardinality (one-to-one, one-to-many, many-to-many) and add properties to relationship edges.

Schema editor showing relationship connections

Entity Editor Panel

12 field types with validations. Click any entity to edit fields, descriptions, and required settings in a dedicated side panel.

Entity panel showing fields with various types

Breaking Change Detection

When you delete fields or change types, FLXBL warns you about breaking changes and queues migrations automatically.

Breaking changes dialog showing migration options

Schema Editor Capabilities

12 field types including ENUM with custom values
Relationships with properties on edges
Automatic semantic versioning
Migration tracking with status monitoring
Real-time validation and error feedback
Schema templates for common use cases
Try the Schema Editor

How It Works

From schema to production-ready API in minutes. No backend code, no database management, no infrastructure hassle.

FLXBL workflow: from schema definition to querying data
1

Define Schema

Create entities with fields and relationships using our visual Schema Editor. Drag and drop to connect entities, define field types, and set up cardinality. Schema versioning with automatic migrations keeps your data safe.

FLXBL Visual Schema Editor with entity panel
2

APIs Generated

REST and GraphQL endpoints are created automatically from your schema. Full CRUD operations, relationship queries, and type-safe clients available instantly.

// Auto-generated endpoints
REST API:
  GET    /api/v1/dynamic/Product
  POST   /api/v1/dynamic/Product
  GET    /api/v1/dynamic/Product/:id
  PUT    /api/v1/dynamic/Product/:id
  PATCH  /api/v1/dynamic/Product/:id
  DELETE /api/v1/dynamic/Product/:id
  POST   /api/v1/dynamic/Product/query

GraphQL:
  POST   /api/v1/dynamic-gql/{tenantId}
  GET    /api/v1/dynamic-gql/{tenantId}/schema.graphql
3

Query Your Data

Use the powerful Query DSL for complex graph traversals, or generate type-safe clients in TypeScript, Python, or any language. Full GraphQL support included.

// Query with the powerful DSL
const products = await client.query('Product', {
  where: {
    price: { $gte: 10, $lte: 100 },
    tags: { $contains: 'featured' }
  },
  traverse: [{
    relationship: 'BELONGS_TO',
    direction: 'out',
    where: { name: { $eq: 'Electronics' } }
  }],
  orderBy: 'price',
  orderDirection: 'ASC',
  limit: 20
});
Start Building

Everything You Need to Build

Schema management, auto-generated APIs, AI-assisted development, and enterprise-grade security. All in one platform.

Schema-First Development

Schema Management

Define entities with typed fields and relationships. FLXBL handles versioning, migrations, and rollbacks automatically.

  • 12 field types: STRING, NUMBER, BOOLEAN, FLOAT, DATETIME, TEXT, JSON, ENUM, arrays
  • Relationships: ONE_TO_ONE, ONE_TO_MANY, MANY_TO_MANY with properties
  • Semantic versioning with automatic migration tracking
Schema Editor showing relationship creation between entities 
// REST API - Auto-generated from schema
GET    /api/v1/dynamic/Product          // List all
POST   /api/v1/dynamic/Product          // Create
GET    /api/v1/dynamic/Product/:id      // Read
PUT    /api/v1/dynamic/Product/:id      // Update
PATCH  /api/v1/dynamic/Product/:id      // Partial update
DELETE /api/v1/dynamic/Product/:id      // Delete
POST   /api/v1/dynamic/Product/query    // Query DSL

// Relationship operations
POST   /api/v1/dynamic/Product/:id/relationships/PURCHASED_BY
GET    /api/v1/dynamic/Product/:id/relationships/PURCHASED_BY
DELETE /api/v1/dynamic/Product/:id/relationships/PURCHASED_BY/:targetId
Zero Code Required

Auto-Generated APIs

Every schema change automatically generates REST and GraphQL endpoints. Full CRUD operations, relationship management, and query capabilities.

  • TRUE REST + GraphQL parity, not an afterthought
  • OpenAPI 3.0 spec and GraphQL SDL auto-generated
  • Relationship CRUD with bidirectional traversal
AI-Assisted Development

MCP Tool Integration

Use the FLXBL MCP server with Cursor, Windsurf, or any MCP-compatible IDE. Your AI assistant can design schemas, validate changes, and generate client code.

  • validate_schema - Catch errors before publishing
  • publish_schema_version - Deploy schema changes
  • generate_client_types - TypeScript, Zod, Python, more 
// ~/.cursor/mcp.json
{
  "mcpServers": {
    "flxbl": {
      "command": "npx",
      "args": ["@flxbl-dev/mcp"],
      "env": {
        "FLXBL_INSTANCE_URL": "https://api.flxbl.dev",
        "FLXBL_API_KEY": "flxbl_your_key_here"
      }
    }
  }
}

// Now ask your AI assistant:
// "Help me design a schema for an e-commerce platform"
// "Generate TypeScript types for my FLXBL schema"
// "Add a Reviews relationship to Product"
// Powerful JSON-based Query DSL
const results = await client.query('Product', {
  where: {
    price: { $gte: 10, $lte: 100 },
    $or: [
      { tags: { $contains: 'featured' } },
      { inStock: { $eq: true } }
    ]
  },
  // Graph traversal - follow relationships
  traverse: [{
    relationship: 'PURCHASED_BY',
    direction: 'out',
    where: { 
      purchaseDate: { $gte: '2024-01-01' } 
    }
  }],
  orderBy: 'createdAt',
  orderDirection: 'DESC',
  limit: 50
});
Powerful Queries

Query DSL

JSON-based query language with MongoDB-style operators and graph traversal. Complex queries without writing SQL or Cypher.

  • Operators: $eq, $neq, $gt, $gte, $lt, $lte, $in, $contains
  • Logical: $and, $or for complex conditions
  • Graph traversal: Follow relationships with traverse
Event-Driven Architecture

Webhooks

Real-time notifications when data changes. HMAC-SHA256 signatures for security. Automatic retries with exponential backoff.

  • Events: entity.created, entity.updated, entity.deleted
  • Schema version tracking for graceful evolution
  • Idempotency keys for reliable processing 
// Create a webhook for real-time events
POST /api/v1/webhooks
{
  "schemaName": "Product",
  "targetUrl": "https://your-app.com/webhooks/flxbl",
  "eventTypes": ["entity.created", "entity.updated", "entity.deleted"]
}

// Webhook payload (HMAC-SHA256 signed)
{
  "eventId": "evt_7f8a9b0c1d2e3f4g",
  "eventType": "entity.created",
  "timestamp": "2025-01-01T12:00:00.000Z",
  "entityName": "Product",
  "schemaVersion": "1.2.0",
  "data": { "id": "node_abc", "name": "Widget Pro", "price": 29.99 }
}
// API Key Authentication
curl -X GET https://api.flxbl.dev/api/v1/dynamic/Product \
  -H "Authorization: Bearer flxbl_ab12cd34_..."

// Multi-tenant isolation
// Each tenant has isolated:
// - Schema definitions
// - Data storage (Neo4j nodes)
// - API keys and permissions
// - Webhooks and rate limits
Enterprise-Ready

Security & Multi-Tenancy

Complete tenant isolation, role-based access control, and API key management. Enterprise-grade security out of the box.

  • Multi-tenant isolation at database level
  • API key authentication
  • Rate limiting: global, per-tenant, per-endpoint
AI-Powered Development

Build with AI Assistants

The FLXBL MCP server integrates with Cursor, Windsurf, and other AI-powered IDEs. Design schemas, generate code, and manage your backend through conversation.

Quick Setup

Add FLXBL to your IDE in under a minute. Works with Cursor, Windsurf, VS Code with Continue, and any MCP-compatible editor. 

// ~/.cursor/mcp.json (or windsurf, vscode)
{
  "mcpServers": {
    "flxbl": {
      "command": "npx",
      "args": ["@flxbl-dev/mcp"],
      "env": {
        "FLXBL_INSTANCE_URL": "https://api.flxbl.dev",
        "FLXBL_API_KEY": "flxbl_ab12cd34_..."
      }
    }
  }
}
Setup Guide npm package

Available Resources

Your AI assistant can access these resources to understand your schema and provide contextual help.

flxbl://schema/active

Current schema with entities, fields, relationships

flxbl://context

Formatted schema summary for LLM context

flxbl://api/graphql

GraphQL SDL schema with usage instructions

flxbl://templates

Available pre-built schema templates

Available Tools

validate_schema

Check schema for errors before publishing. Catches reserved names, invalid types, and breaking changes.

"Validate my schema before I publish it"

publish_schema_version

Create a new schema version with entities and relationships. Handles migrations automatically.

"Add a Reviews entity with a 5-star rating field"

generate_client_types

Generate TypeScript interfaces, Zod schemas, Python models, or API contracts from your schema.

"Generate Zod schemas for my FLXBL schema"

check_migration_status

Track the progress of running schema migrations.

"Check the status of my last migration"

list_schema_templates

Browse pre-built schema templates for common use cases like e-commerce, blog, CRM.

"Show me available schema templates"

Try These Prompts

"

Help me design a schema for a blog platform with posts, authors, and comments

"

Generate TypeScript interfaces for my FLXBL schema

"

Add a Reviews entity with a 5-star rating to my Product schema

"

Show me how to query products with their categories using the Query DSL

Built for Scale

FLXBL's architecture is designed for reliability and performance, with intelligent caching and optimized data handling.

FLXBL handles the complexity of backend development so you can focus on building your product. Define your data model once, and get production-ready APIs with authentication, rate limiting, and automatic documentation.

Schema versioning Auto-generated APIs Graph relationships Multi-tenant isolation

Schema Management

Define once, deploy everywhere. Your schema is the single source of truth.

  • Automatic versioning
  • Multi-tenant isolation
  • Secure authentication
  • Webhook integrations

Graph-Powered Data

Native graph storage for complex relationships that SQL can't handle efficiently.

  • Entities as nodes
  • Rich relationships
  • Multi-hop traversal
  • Complete data isolation

Smart Caching

Intelligent caching ensures fast responses for frequently accessed data.

  • Permission caching
  • Schema caching
  • Rate limiting
  • Background processing

Request Flow

1
API Request
2
Schema Validation
3
Data Operations
4
Cache & Response

Every request is validated against your schema, data is read/written to the graph database, and frequently accessed data is cached for fast response times.

Fast
Optimized Queries
0
Cold Starts

Works With Your Stack

FLXBL works with any technology stack that supports REST or GraphQL APIs. Use your favorite language, framework, or platform.

REST API
GraphQL
Webhooks
MCP Integration

Frequently Asked Questions

What is FLXBL?
FLXBL is a graph-based Backend-as-a-Service (BaaS). You define your data schema with entities and relationships, and FLXBL automatically generates REST and GraphQL APIs. Powered by Neo4j for data storage, it excels at complex relationships while abstracting away all database management.
The FLXBL MCP (Model Context Protocol) server integrates with AI-powered IDEs like Cursor, Windsurf, and VS Code. It enables your AI assistant to understand your schema, design new entities and relationships, validate changes, generate client code in TypeScript or Python, and publish schema versions—all through natural language conversation. Just ask 'Help me design a schema for an e-commerce platform' and the AI handles the rest.
FLXBL uses a graph-based storage engine optimized for complex relationships and fast traversals. Your data is stored securely with complete tenant isolation. You don't interact with databases directly—FLXBL abstracts everything behind clean REST and GraphQL APIs, with intelligent caching for fast responses.
Unlike Firebase (NoSQL) or Supabase (PostgreSQL), FLXBL uses a graph database for data storage. This makes relationship queries incredibly fast—finding friends-of-friends, recommendations, or complex hierarchies happens in milliseconds. You also get true REST + GraphQL parity (not just GraphQL), and an MCP tool for AI-assisted development.
FLXBL works with any technology that can make HTTP requests. We generate clients for TypeScript, JavaScript, Python, and Go. Use the MCP tool to generate Zod schemas, TypeScript interfaces, Python Pydantic models, or dataclasses. The GraphQL API works with any GraphQL client. REST works with any HTTP client.
Every schema change creates a new version with semantic versioning (e.g., 1.0.0 → 1.1.0). FLXBL tracks migrations automatically, detects breaking changes, and handles rollbacks. When you publish a schema version, it runs through validation (reserved names, invalid types, circular dependencies) before deployment. The MCP tool can validate schemas before publishing.
FLXBL is optimized for speed through connection pooling, multi-layer caching, and efficient query generation. GraphQL schemas are cached for fast responses. Rate limiting prevents abuse. For complex graph traversals, graph databases excel compared to traditional SQL JOINs. As we're in beta, we're continuously improving performance based on real-world usage.
FLXBL is currently in public beta with core features stable and being used by early adopters. The roadmap to v1.0 includes enhanced monitoring, additional SDK languages, and expanded self-hosting options. We recommend thorough testing for mission-critical applications and welcome feedback from beta users.

Still have questions?

Read the Docs Join Discord Email Us LinkedIn

Ready to Build with FLXBL?

Define your schema, get your API. Join developers building faster with graph-based backends and AI-assisted development.

Read the Docs Try FLXBL Now

Have questions? Get in touch:

Join our Discord marko@flxbl.dev Connect on LinkedIn