Skip to content

Model driven system

In Minyu, the data model is not just a storage schema. It is the primary source from which system behavior, user interfaces, validation, and access control are derived.

Instead of implementing forms, lists, APIs, and permissions as separate layers, Minyu generates them directly from the data model, classifications, and rules. This keeps structure, behavior, and interaction aligned as the system evolves.

flowchart LR

    M[Data Model]
    C[Classifications]
    R[Rules]

    M --> C
    C --> R

    R --> F[Forms and Validation]
    R --> V[Views and Lists]
    R --> A[API]
    R --> S[Search]
    R --> E[Exports and Imports]
    R --> B[Events]

One model, many consequences

In many systems, the same concept is implemented multiple times:

  • once in the database
  • once in the UI
  • once in validation logic
  • once in APIs and integrations

These representations inevitably drift. Small changes in structure require coordinated updates across layers, which slows development and introduces inconsistencies.

Minyu avoids this entirely.

Tables, columns, relations, classifications, and rules are defined once. From that single definition, the system derives:

  • smart data entry forms
  • lists and navigation views
  • validation behavior
  • access control
  • APIs and integration surfaces

There is no secondary configuration to keep in sync.

Interfaces derived from structure

Forms and views in Minyu are generated based on the structure and metadata of the data model. Column order, relations, and linking rules define how information is presented and how users interact with it.

Because interfaces are derived rather than implemented:

  • adding a new field makes it immediately available everywhere it is relevant
  • changing a relation updates navigation and editing behavior automatically
  • validation rules apply consistently, regardless of how data is edited

Example

Adding a relation between Person and Address immediately:

- exposes the relation in forms  
- enables inline editing of addresses  
- applies linking rules that control reuse or uniqueness  
- makes the relation available in APIs, search, and charts

No UI code needs to be updated.

Screenshot: Inline editing of related data in a generated form

Validation and access enforced by rules

Model-driven delivery does not stop at layout.

Classifications and rules determine whether data is visible, editable, or restricted. The same rule logic applies consistently across all interactive and API-based entry points, including:

  • forms
  • inline editing
  • API mutations

This ensures that behavior is predictable and cannot be bypassed by choosing a different access path.

Screenshot: Generated form and list derived from the data model

Bulk imports are the exception. For performance and operational reasons, write rules are not evaluated during bulk import execution. Bulk imports validate only against the structural schema and data types, and are intended for controlled administrative operations rather than day-to-day interaction.

From a user’s perspective, this means that interactive behavior is consistent and explainable: if an action is blocked in the UI, it will also be blocked through the API, with clear feedback as to why. Only explicitly governed system-level operations—such as bulk import—operate outside the rule engine.

Faster evolution without rework

Because behavior is derived from the model, changes propagate automatically.

When the model evolves:

  • interfaces update immediately
  • APIs reflect the new structure
  • rules continue to apply without modification
  • access control remains consistent

There is no need to reimplement screens, update endpoint definitions, or duplicate logic in multiple places.

This significantly reduces time to market, not by cutting corners, but by eliminating entire categories of rework that traditionally slow systems down as they grow.

Why this matters long-term

Model-driven delivery has a cumulative effect.

Systems tend to degrade when structure and behavior drift apart. Over time, documentation becomes outdated, implementations diverge, and change becomes risky.

By keeping delivery tied directly to the data model and rules, Minyu produces systems that remain coherent. Structure stays visible. Logic stays centralized. Interfaces remain consistent with reality.

Instead of asking “Where is this implemented?”, teams can ask “What does the model say?” — and trust that the system follows it.

In Minyu, delivery is not something added on top of the model. It is what naturally emerges from it.

→ Read more: Smart forms, API schema