Model-driven delivery
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.
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.
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 applies regardless of whether a change is made through:
- a form
- inline editing
- bulk import
- API mutation
This ensures that behavior is consistent and predictable, and that validation cannot be bypassed by using a different entry path.
From the user’s perspective, this means fewer surprises. If an action is allowed in one place, it is allowed everywhere. If it is not allowed, it is blocked consistently and explained.
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.