Everything a business application needs, from the first build
These are not add-ons or premium modules. Every application CEDM Platform generates includes all of them, configured from your model.
State machines your users can see
Declare a lifecycle on an entity and every record shows its current state and the moves out of it as buttons. A move can be limited to roles, can run workflows on entry, and is recorded whether it succeeds, is refused or fails.
- The record's state is set only by moves, never by an ordinary save
- A failed workflow puts the record back where it was and says why
- Status machines can be drawn and changed in the running application
Business rules as decision tables, automations as sentences
Rules are GoRules decision graphs evaluated on every write: they can validate, set values, cascade to related records or start a workflow. Automations read like the policy they implement, and both can be tried against a sample record before they are saved.
- Decision tables and full rule graphs, edited visually
- Dry runs show the result and the trace of every node
- A refused update leaves nothing of itself behind
Change the screens without changing the code
Windows, tabs, fields and their order are rows in an Application Dictionary generated from the model. Administrators rearrange, hide and group fields in the running application, and the change takes effect on the next request.
- Child records appear as tabs on their parent, not as separate screens
- Every field carries help written for the people who use it
- Tables added at run time get their screens automatically
Correct data, even when two people are working on it
The rules that keep data right are enforced by the server in the same statement as the write, so they hold under load and through any client.
Optimistic locking
Every save names the version it started from. If someone else saved first, the screen shows what changed, who changed it and when, and lets the user refresh or overwrite deliberately.
Completed means closed
A record in a final state cannot be edited or deleted by anyone, because undoing a completed transaction should be a new transaction, not a quiet edit.
Values that mean something
A value-list field refuses a value the list does not hold, and a reference refuses an id that points at nothing, on the server and not just in the form.
Narrowed choices
Choose a country and only its states are offered; choose a state and only its cities. The backend holds a write to the same narrowed set.
An API with a contract
Every application serves a REST API that describes itself in OpenAPI, with Redoc and Scalar built in. One generic interface serves every entity in the dictionary, including ones added after deployment, and every response carries the version needed for a safe update.
- List, filter, search, sort and page any entity
- Lookups narrowed by the values on the record
- Action endpoints for lifecycle moves, with conflict and refusal codes
Every application arrives with its tests
The same model that generates the application generates the suites that check it, so the tests grow with every entity, rule and role you add.
Rust request suites
Hundreds of request tests per application exercise every entity, permission, lifecycle and conflict path over real HTTP against a real database.
API and browser suites
Bun API suites check the application against the model itself, not against what the generator wrote, and Playwright specs drive the real screens.
A smoke test of every screen
Each application can open every one of its screens in a browser and fail on a crash, a server error, a console error or a leaked internal table name.
Tests that are not the administrator
Dedicated suites sign in as an ordinary role and as nobody at all, because a test that runs as the administrator passes every permission check.
The details that make it feel finished
Reports
Reports declared in the model ship with the application. Queries are held to a single read, three times over: when written, when compiled and when run.
Accounts and roles
Each role the model declares gets a demonstration account. Administrators create, lock and deactivate accounts, and the last administrator cannot be removed.
A chat for every application
People ask for records and reports in plain language and the application's own screens open inside the conversation. The assistant never writes a record itself.
Seven themes
Every application includes seven visual themes, switchable at run time without a rebuild, in light and dark.
Logging you can turn up
Every refusal carries a catalogued error code and a request reference. Log levels change per channel at run time, without a restart.
Hooks for your own code
Thirteen lifecycle events around every create, update and delete call your Rust handlers. Regeneration adds new hooks and never touches your implementations.
Seven looks, one application
Pick the theme that suits your brand, or let each user choose. Every theme ships in every application.
See it build your application
Bring a process you run today. We will model it with you and generate the application in the same session.