Skip to content

Features

Minyu is a complete operational platform for organizations that need more than simple forms, basic validation, and flat data exchange. It is designed for environments where data is relational, rules are real, scheduling has constraints, integrations must be trusted, and compliance is not optional.

At its core, Minyu removes the need to build and maintain large amounts of custom infrastructure for data integrity, business logic, synchronization, access control, and traceability.

Platform reliability you don’t have to engineer yourself

Minyu runs as a fully managed, container-orchestrated service with automated recovery, continuous updates, encrypted storage and transport, tenant isolation, and monitored backups with verified restore.

This removes the need to design your own redundancy strategies, health monitoring, or disaster recovery workflows.

Example

If a container crashes during an active operation, it is automatically recreated and Minyu restores the last consistent state without administrator intervention.

A data model that actually represents your domain

Minyu is built on a fully configurable relational data model that mirrors real-world structure.

Tables, columns, and relationships are defined directly in the system. From this single schema definition, Minyu automatically generates:

  • User interfaces
  • Search and navigation
  • API schemas
  • Import and export formats
  • Structural validation and integrity

The schema is always the authoritative source.

Example

Adding a ServiceMission table with a relation to Technician instantly updates:

  • the mission form with a technician selector
  • search relevance based on relationships
  • the GraphQL schema
  • all import and export structures

Real business rules, enforced everywhere

Rules in Minyu are not limited to single fields. They can traverse multiple relations and evaluate real operational conditions.

The same rule engine is applied consistently across:

  • User interface
  • API
  • Imports
  • Scheduling
  • Automation

No duplicate logic. No manual enforcement.

Example

Only technicians with all required certifications may be assigned to a service mission. The rule traverses serviceMission → requiredCertifications → technicianCertifications → technician and is enforced identically in:

  • the UI
  • API mutations
  • imports
  • scheduling suggestions

Declarative read rules and access control

Read access in Minyu is controlled by declarative rules defined directly on the data model. Access is not hardcoded in application logic and does not rely on static role checks alone.

Read rules can evaluate:

  • The current user
  • The current row
  • Related rows across multiple tables

The same read logic is enforced consistently across:

  • User interface
  • Global search
  • API access
  • Exports

There is no separate permission system to keep in sync.

Example

A rule states that a user may only see service missions if they:

  • belong to the same department as the assigned technician
  • and the mission is not in a restricted state

This rule automatically applies in:

  • the UI
  • global search
  • API queries
  • exports

Rows that fail the rule are invisible everywhere, without special casing.

Scheduling based on logic, not just calendars

Scheduling in Minyu is built on the same rule and relation engine as the rest of the system. Time is not treated as a separate subsystem.

You can define:

  • Time sequences (for example weekdays 08:00–16:00)
  • Multi-resource dependencies
  • Overlap and ordering constraints
  • Combined relational and temporal conditions

Example

A technician bound to the sequence Mon–Fri 08:00–16:00 will only appear as a booking candidate if:

  • the time range fits the sequence
  • all relational requirements (certifications, availability, constraints) are satisfied

A user interface that follows the model automatically

You do not design screens manually in Minyu. Forms, lists, explorers, calendars, and charts are generated directly from the schema and rules.

When structure or logic changes, the interface updates automatically.

Example

Adding a new column immediately adds:

  • a new field in forms
  • a new column in grids
  • new grouping and sorting options
  • updated API type definitions

Search and navigation that understands relationships

Search in Minyu is relationally informed, not just full-text based. Relevance is computed using both values and relationships.

Relational navigation allows traversing connections directly across tables without losing context.

Example

Searching for “certification pump technician” prioritizes technicians whose related certifications contain “pump”, even if the words exist in different tables.

Imports that preserve structure, not just rows

Imports in Minyu support full structural mutation:

  • Inserts, updates, and deletes
  • Relation creation and removal
  • Foreign-key integrity
  • Mandatory dry-run validation before commit

Example

An import file can create technicians, update service missions, and modify mission–equipment relations in one operation while preserving referential integrity.

Exports with real relational context

Exports are permission-aware and include fully resolved relational context in CSV or Excel format.

Example

Exporting service missions can include linked technicians, required certifications, and assigned equipment flattened into one relationally consistent structure.

A real, rule-aware GraphQL API

The API is auto-generated directly from the schema and fully respects:

  • Rules
  • Permissions
  • Relationships
  • Structural constraints

Clients can traverse relationships deeply without over-fetching or custom resolver development.

Example

A client requests a mission together with its technician, certifications, and required equipment in one GraphQL query. If the same operation is forbidden in the UI, it is also rejected through the API.

Event notifications based on meaning, not just rows

Minyu supports authenticated webhooks for mutation and classification changes, including deep relational triggers.

Example

A webhook is triggered whenever a person’s phone numbers change by watching the sub-relation person → phoneNumbers. Events fire when:

  • a phone number is added
  • a phone number is removed
  • a phone number is updated

Built-in compliance and traceability

GDPR handling and auditing are part of the core system, not external add-ons.

This includes configurable anonymization and deletion, personal-data export, controlled privilege elevation, and immutable audit logs.

Example

A GDPR erasure anonymizes all historical service missions for a technician while preserving structural integrity and auditability.

Example

When a technician is reassigned on a mission, both the previous and new technician IDs, the actor, and timestamp are logged immutably.

Power-user efficiency at scale

Minyu is built for high-volume operational use with:

  • Multi-view layouts
  • Keyboard shortcuts
  • Inline editing
  • Context-aware actions

Example

A dispatcher views today’s missions, technician availability sequences, and open tasks side-by-side and updates assignments inline without switching screens.

One system, one logic layer

The defining difference is not any single feature—it is that structure, rules, scheduling, imports, API, UI, notifications, and audit all execute against the same underlying model.

There are no parallel implementations, no duplicated business logic, and no fragile synchronization layers. This is what allows Minyu to remain reliable as real-world operations grow from simple use cases into deeply interconnected systems.