The product
Everything under your product, built and running for you.
You define a data model. Fluidlee turns it into a validated, multi-tenant REST API with rules, computed fields and an audit trail, and gives your team a dashboard to run it.
01 · Data model
A schema you draw, live the moment you save.
Define entities, fields and relations in the dashboard, and the schema goes live the instant you save. The API reshapes itself to match, with migrations and deploys handled for you.
| Type | Stores |
|---|---|
text | UTF-8 string |
integer | 64-bit integer |
decimal | Arbitrary-precision number |
boolean | true / false |
date | ISO date (YYYY-MM-DD) |
datetime | ISO datetime with timezone |
uuid | UUID, optionally a relation to another entity |
json | Arbitrary JSON object or array |
| Behavior | Read | Write |
|---|---|---|
standard | ✓ | ✓ |
readonly | ✓ | — |
writeonce | ✓ | on create |
computed | ✓ | — |
stored_calc | ✓ | auto |
system | ✓ | — |
Relations, four ways
A uuid field can reference another entity: one-to-one, one-to-many, many-to-one or many-to-many. References are validated on write and drawn as edges on the canvas.
Versioned, and guarded
Every schema change is a new version. A change that would break a live rule is caught up front with 409 FIELDS_REFERENCED_BY_RULES, pointing you to the rules to update first.
Per-tenant fields
Any tenant can add fields all its own. Extensions live alongside your base schema and are only visible in requests scoped to that tenant.
02 · Formulas
Fields that derive themselves.
Some fields are best left to derive themselves from the values around them. Fluidlee gives you two kinds and tracks every dependency for you.
- Computed fields are evaluated fresh on every read and always current, perfect for display values and derived flags.
- Stored calculated fields are persisted and recalculated inside the same write whenever a field they depend on changes, so they can be filtered and sorted.
- Formulas support arithmetic, string, math and date functions, ternaries and null-coalescing, evaluated in a safe sandbox that’s fully isolated from the database and network.
# computed: evaluated on every read, always current full_name = "{{first_name}} {{last_name}}" age_years = datediff(today(), {{date_of_birth}}) / 365 is_overdue = {{due_date}} < today() && {{status}} != "paid" # stored_calc: persisted, recalculated when a dependency changes total_price = {{quantity}} * {{unit_price}} tier = {{score}} >= 90 ? "gold" : "standard"
03 · Generated REST API
Five endpoints per entity. Zero written by you.
For every entity, Fluidlee serves a full CRUD API derived live from the current schema: list, create, read, update and soft-delete, each scoped to the tenant on the request.
Validated on the way in
Types, required fields, and foreign-key references are checked before anything is written. Read-only and computed fields are stripped from the input automatically.
Filtered, sorted, paged
List endpoints take field filters with comparison operators, plus page, pageSize, orderBy and orderDir. Related records come back in one call with ?include=.
Documented for you
Each project publishes an OpenAPI spec that tracks its current schema, so your clients and tooling always match what the API actually accepts.
| Trigger | Runs | Mode |
|---|---|---|
before_create | Before insert | Can block |
after_create | After insert | Async |
before_update | Before update | Can block |
after_update | After update | Async |
before_delete | Before soft-delete | Can block |
after_delete | After soft-delete | Async |
scheduled | On a cron schedule | Async |
04 · Rule engine
Business logic that updates in a click.
Rules are trigger → condition → action automations you build on a canvas. They run in the request path or in the background, per project.
- Look things up first: count, sum, average, min, max, or pull records from other entities before deciding.
- Decide with a tree: nested AND/OR/NOT conditions with eleven operators, branching on true or false.
- Then act: block the operation, create or update or delete a record, call another rule, or run a multi-step webhook pipeline with per-step success and failure handling.
- Every run is logged, and you can dry-run a rule before enabling it.
05 · Dashboard & tenancy
One place to run all of it.
Built for your whole team
The dashboard is the one UI Fluidlee ships, and it’s built for everyone. Most days it’s your whole team using it, not just your engineers:
- A canvas for the data model, and another for rules
- An API explorer that sends real requests against a tenant
- Tenant management, usage metrics, and a searchable audit log with before/after diffs
Isolation that runs itself
Every request names a tenant, and every row is confined to it, enforced deep in the data layer so it’s handled for you on every request.
- Each project keeps its own separate data space
- Tenants that need it can move to a dedicated database. The copy and re-route happen for you, and your code stays exactly the same
- Per-tenant schema extensions, scoped to the tenant that owns them
See it against your own data model.
Tell us the entities you’re working with and we’ll help you stand the first project up.