You can use MDriven to model business data, rules, workflows, and user interactions, then execute and deploy the resulting application from that shared model. This page is for teams evaluating how MDriven supports model-driven development from an initial prototype through a deployed system.

What MDriven does

MDriven uses a visual model-driven development approach. You describe the business domain in a UML model: its concepts, relationships, rules, and the ways users work with the data. MDriven uses that model as the basis for the application rather than treating it as documentation that must be manually translated into code.

For example, a team can model Customer, Order, and OrderLine as related concepts. It can then define what an order contains, how users work with orders, and which actions are available. The same model can drive a runnable application, database schema evolution, and generated user interfaces.

You model	MDriven can use the model to provide
Business concepts and their relationships	Domain classes and database mapping information
Rules and calculations	Executable business behavior and validation
User tasks and data presentation	ViewModels and responsive web user interfaces
Changes to the domain over time	Updated code and database schema while preserving existing data through database evolution

Core capabilities

Visual, executable modeling

MDriven Designer is a Windows application for designing complete information systems with UML and OCL. UML (Unified Modeling Language) describes the structure of the domain visually. OCL (Object Constraint Language) expresses rules over that domain.

You can execute a model while developing it. This gives the team a working result to review instead of relying only on written requirements or diagrams.

For example, after adding the Order class and its relationship to Customer, run the model to inspect how the modeled data behaves. If the relationship or rule does not match the business process, change the model and run it again.

Business rules in the model

Business logic belongs with the domain model. You can define rules and validation with model features such as OCL, so the rules are part of the shared definition of the system.

For example, an order workflow can use a modeled rule to determine when an action is available. Reviewing that rule in the model lets business and technical stakeholders discuss the same system definition.

This approach keeps the model useful as the application evolves: the rule is not only described in a separate specification; it is part of what executes.

Generated application layers

MDriven derives application elements from the model, including domain classes, database mapping information, and user-interface behavior. MDriven Framework can derive database schema, code for domain classes, and mapping between classes and database tables.

A ViewModel is the model that defines a user-facing task or presentation of data. MDriven Turnkey can expose ViewModels as REST endpoints, and you can extend system logic with custom C# when needed.

For example, create a ViewModel for an order-processing task that presents an order and its lines together. That ViewModel can provide the basis for a browser user interface and can also be exposed as a REST endpoint where appropriate.

Read Documentation:MVC View Model constraints for constraints that apply when designing MVC ViewModels.

Database evolution

As the model changes, MDriven Framework can update the database schema and merge model changes into code while preserving data. This capability is called Database Evolution.

For example, if an existing Customer concept gains a new property, update the model and let the model-driven process evolve the corresponding information structure rather than rebuilding the database manually. Database changes still need to be planned and tested for the application's data and deployment environment.

Prototype, deploy, and run

MDriven supports modeling, prototyping, and execution as parts of one workflow. Models created in MDriven Designer can be executed with the built-in prototyper and uploaded to an MDriven Turnkey site for a functional information system.

MDriven Turnkey is the model-driven application front end that uses MDriven Designer and MDrivenServer. It supports web-based user interfaces; MDriven also supports rich-client application scenarios.

A typical path is:

1. Model the business concepts, relationships, and rules in MDriven Designer.
2. Execute the model to review a working prototype with stakeholders.
3. Define the ViewModels that users need for their tasks.
4. Deploy the model through the MDriven environment appropriate for the application, such as cloud, on-premises, or Docker deployment.
5. Change the model as requirements change, then test the updated behavior and database evolution before releasing it.

Workflows and integrations

You can define automated workflows in the model, including scheduled actions, email triggers, and data exchanges. This lets you place workflow behavior with the modeled business concepts rather than requiring a separate custom backend service for every automation.

For example, a modeled process can trigger a data exchange after a business action changes an order's status. The exact integration endpoint and any external-system contract remain part of the application's integration design.

MDriven is built on .NET and standard protocols. You can connect existing systems through REST, expose ViewModels as REST endpoints, or extend logic with custom C#. This supports incremental modernization: a team can add a model-driven application capability alongside existing systems instead of replacing every system at once.

Access control

MDriven supports role-based access control (RBAC), where permissions are defined by roles. This allows the application model to express which users may access particular capabilities.

For example, an order-processing application can distinguish between users who enter orders and users who approve them. Define the roles and access requirements as part of the application design, then verify the resulting behavior in the running application.

Benefits for delivery and maintenance

The value of MDriven comes from keeping the model, running behavior, user experience, and data structure aligned.

Benefit	How the model-driven approach contributes	Example
Faster feedback	You can execute the model during design and review a working application earlier.	A stakeholder reviews an order-entry task after the first ViewModel is defined, then asks for a missing field before release.
Shared understanding	The visual model provides a common representation for business stakeholders and developers.	The team reviews the relationship between customer and order in the model instead of reconciling a diagram with separately written implementation code.
Safer evolution	Database Evolution updates the information structure as the model changes while preserving existing data.	The team adds a customer property through a model change and tests the database evolution as part of the release.
Less repeated implementation work	MDriven derives database, domain, mapping, and UI-related elements from the model.	A modeled business concept contributes to both the persisted data structure and the application behavior instead of being recreated independently in each layer.
Technology flexibility	The business model is separated from short-lived implementation choices, while the application can integrate through REST and custom C#.	An existing system continues to supply data while a new MDriven ViewModel provides a modern task-focused interface.
Transparent system behavior	Rules, processes, and data structures are represented in a model that can be reviewed and executed.	A new team member can inspect the modeled order process and run it rather than relying only on informal knowledge from previous developers.

Choose the right MDriven component

MDriven is a product line rather than a single editor. Select the component based on where you are in the delivery process.

Component	Use it when you need to
Mockotype	Start modeling and prototyping with a reduced set of advanced options.
MDriven Designer	Model and design a complete information system using UML and OCL, then execute the model.
MDrivenServer	Run the server-side part of an MDriven solution.
MDriven Turnkey	Deliver a model-driven web application front end using MDriven Designer and MDrivenServer.
MDriven Framework	Use model-driven runtime features, generated domain code, and database mapping and evolution in an application.

What to evaluate in your own application

Before committing to an implementation approach, use a small but representative model to test the parts that matter to your team:

1. Model a core business concept and its relationships.
2. Add a real business rule in OCL or the appropriate model behavior.
3. Build a ViewModel for one user task.
4. Execute the model and review the result with both business and technical stakeholders.
5. Test a model change that affects stored data, and verify the resulting database evolution with representative data.
6. Test required integrations through REST or custom C# extensions.
7. Confirm role-based access behavior for the application's intended user roles.

This evaluation produces evidence from your own domain: whether the model communicates the requirements, whether the generated application supports the user task, and whether the system can evolve in the way your organization requires.

See also

• Documentation:How does MDriven work
• Documentation:MDriven Product Line
• Documentation:Why You Should Choose MDriven
• Documentation:MDriven Framework – a Model driven framework
• Documentation:What is MDriven Server?
• Documentation:MVC View Model constraints

Published scale indicators

You can use these published indicators to assess whether MDriven fits enterprise-scale models and database workloads; they are intended for technical evaluators planning a deployment.

MDriven Framework is described as suitable for systems with complex multi-company logic and millions of database hits per hour. This is a published workload indicator, not a benchmark result for a particular configuration.

Customer-reported application scope

A published customer statement describes an application with the following scope:

Indicator	Reported value
Modeled classes	677
Classes with MDriven persistence	About 50% of the model
Versioned classes	25% of the model
Application code	About 850,000 lines of code
Assets managed in funds	About EUR 130 billion

This example demonstrates model and business-domain scope. It does not state concurrent-user counts, response times, transactions per second, database size, hardware, or a load-test method. Do not use it to predict the performance of a specific deployment.

Deployment capabilities relevant to growth

For deployments that need additional infrastructure capacity, MDriven Server is described as supporting cloud and on-premises deployments, load balancing, and multi-tenant applications. Enterprise deployment options are described as including unlimited cores, global replication and global cache servers, multi-database environments, and load-balancing and failover setup.

For example, a team that needs separate customer installations can deploy separate server instances; a team operating a shared, multi-tenant database must evaluate its own data volumes and queries before choosing its architecture.

See also

• Documentation:Why You Should Choose MDriven

Value and cost outcomes

MDriven's model-driven approach is intended to reduce effort across the development lifecycle by automating parts of application delivery and keeping business rules, workflows, and models central to development.

Outcome	How MDriven contributes
Faster delivery	MDriven automates large parts of development, including database generation, UI creation, and business-logic enforcement.
Earlier feedback and less rework	Live execution of models supports immediate feedback and iteration before later changes become more costly.
Better business and IT alignment	Business rules, workflows, and models are central to development, and visual models allow domain experts to contribute directly.
More maintainable systems	Executable models keep documentation connected to code and functionality, improving transparency and reducing reliance on knowledge held by individual developers.
Easier adaptation to changing requirements	A modeled system can be adapted to new requirements without redesigning its core structure.
Lower-risk modernization	MDriven can work alongside legacy systems, with integration features and reverse-engineering capabilities intended to support modernization without an all-at-once replacement.

Evaluating value for a project

For a financial evaluation, compare the effort required to build and maintain a representative application using existing practices with the effort required when its data model, user interface, business rules, and workflows are modeled in MDriven. Consider the likely effect of automated generation, earlier feedback, stakeholder participation, documentation that remains connected to the system, and future changes to business rules.

See also

• Documentation:MDriven features and benefits
• Evaluation Guide

MDriven features and benefits

You can use MDriven to model business logic, generate application parts from that model, test the result, and evolve the application as requirements change; this page is for teams evaluating what MDriven supports and why it matters.

Features

Feature	What you can do	Example
Model-driven development	Use UML models as the primary blueprint for an application and turn them into executable software without extensive manual coding.	Model a customer, its orders, and the rules that connect them as one application model.
Executable models	Run and test an application directly from its UML diagrams.	Test a modeled order workflow while you refine its states and transitions.
Automatic UI and database generation	Generate user interfaces and database structures from your model.	Add a modeled customer attribute and use the model to create the corresponding UI screen and database table structure.
State machine modeling	Represent business workflows as state transitions and apply rules and timelines to those processes.	Model an order moving from New to Approved to Delivered.
Business logic and rule automation	Put business logic and validation rules in the model so that they are enforced when the system executes.	Define a validation rule that an order must have a customer before it can proceed.
Data management	Generate schemas and synchronize the database as the model evolves.	Update the model when a new business field is required and synchronize the database structure with that change.
Prototyping and live execution	Prototype and test models through MDriven Designer and MDriven Turnkey Core, then iterate from feedback.	Run a model during design to review an order process before deployment.
Full-stack development	Build, test, and deploy front-end and back-end parts from one model-driven integrated environment.	Use one model to define the data, business logic, and user interface for an internal business application.
Cloud integration and hosting	Deploy and scale systems in cloud environments such as Azure or AWS.	Deploy a modeled application to a cloud environment as demand grows.
Collaboration and version control	Let team members work on different model parts and manage changes with version control.	Let a business analyst update workflow requirements while a developer works on another part of the model.

Benefits

Benefit	How the features contribute	Example
Rapid time to market	Automation of database generation, UI creation, and business-logic enforcement reduces the work between an idea and deployment.	Prototype an order workflow, test it, and refine it before moving it into use.
Business-driven development	The model keeps business rules, workflows, and data at the center of development.	Review the same order-state model with business stakeholders and developers.
Cost efficiency and resource optimization	Automation covers core tasks such as data modeling, data management, UI generation, and logic orchestration.	A team focuses on modeling the order process rather than manually creating each database structure and UI screen.
Scalability without redesign	A modeled system can be adapted to new requirements without redesigning its core structure, with deployment support for scalable cloud environments.	Add a new order state when the business process changes instead of rebuilding the full workflow.
Documentation and transparency	Executable models keep documentation aligned with system code and functionality.	Use the model of the order workflow to show how an order moves through the system.
Rapid prototyping and feedback	Live execution lets you test and iterate on the model immediately.	Run the modeled order process and collect feedback before further changes are made.
Flexibility for future changes	You can modify the model as business needs evolve without overhauling the entire application.	Change an approval rule in the model when approval requirements change.
Participation by non-developers	Business analysts can participate in system development through the model-first approach.	A business analyst helps define the states and rules for an order process.
Reduced technical debt	Well-structured models generate code and logic from the same source, supporting long-term maintenance.	Keep database structure, UI, and business rules connected to the same application model as the system changes.

Explore related topics

• Documentation:Why You Should Choose MDriven
• Documentation:Searching
• Documentation:Search result pages
• Documentation:MDriven Stylesheet

MDriven features and benefits

You can use MDriven to create, run, and deploy applications from UML models when you want the model to define your data, user interface, and business logic.

MDriven supports model-driven development: you create a UML model as the blueprint for an application and execute that model instead of relying on extensive manual coding. For example, a model can define an application's data structure, validation rules, and user interface, and MDriven can generate database structures and UI screens from it.

Features

Feature	What you can do	Example
Model-driven development	Use UML models as the primary blueprint for an application.	Model the data and rules for an order process before running the application.
Executable models	Run and test an application directly from its UML diagrams.	Test a modeled workflow while you refine the model.
Automatic UI and database generation	Generate user interfaces and database structures from your model.	Add a modeled data structure and generate the corresponding database tables and UI screens.
State machine modeling	Represent business workflows as state transitions with rules and timelines.	Define the allowed transitions for an object as it moves through a workflow.
Business logic and rule automation	Put business logic and validation rules in the model so they are enforced when the system executes.	Define a validation rule in MDriven Designer and have it apply during execution.
Data management	Generate and synchronize database schemas as models evolve.	Update a model and synchronize the database structure with the change.
Prototyping and live execution	Test and iterate on a model through MDriven Designer and MDriven Turnkey Core.	Run a prototype, collect feedback, and adjust the model before deployment.
Full-stack development	Build, test, and deploy an application from one model-driven environment.	Use one model for the application's UI, database structure, and business logic.
Collaboration and version control	Let team members work on different parts of a model and manage changes.	A team can divide work across model areas while tracking model changes.

Benefits

• Faster delivery: Automating database generation, UI creation, and business-logic enforcement reduces the time from an idea to deployment.
• Business-driven development: Business rules, workflows, and models stay at the center of development. For example, stakeholders can review a model that represents business operations rather than relying only on code.
• Cost and resource efficiency: Automating data modeling, data management, UI generation, and logic orchestration reduces the work required for core development tasks.
• Change without core redesign: You can adapt a modeled system to new requirements without redesigning its core structure. For example, change a workflow in the model as business needs evolve.
• Current documentation and transparency: Executable models keep documentation aligned with code and functionality, helping developers, analysts, and other stakeholders work from the same system description.
• Rapid feedback: Live model execution lets you test an application and iterate before costly rework accumulates.
• Participation by non-developers: Business analysts and other non-technical users can participate in system development through the model-first approach.
• Reduced technical debt: MDriven generates code and logic from structured models, supporting long-term maintainability as the application changes.

See also

• Documentation:How does MDriven work
• Documentation:MDriven Product Line
• Documentation:Why You Should Choose MDriven