Skip to content

A detailed guide on Model-Based Development

Model Based Development - Blog Post

A traditional development workflow that teams were following was something like this:

Write requirements in a Microsoft Word file -> Design system and UI in PPT -> Code manually -> Test system.

The main problem with this approach was that teams could only confirm whether the system works after fully implementing it. If the logic was misunderstood, issues arose, and fixing them became expensive.

For example, when implementing a car cruise control system, if the control logic is coded directly from raw requirements, teams might detect issues such as sudden acceleration, slow response, or wrong braking behavior during road testing. After this, fixing these issues takes weeks.

To overcome these challenges, Model-Based Development (MBD) was introduced around 1960 in the aerospace industry. It builds and tests system logic using executable models before writing final code.

Let’s understand more about what MBD is, how it works step-by-step, how it compares with traditional development, and the best practices to implement it successfully.

What is Model-Based Development (MBD)?

Model-Based Development or Design is a system development approach in engineering where digital models are used to design, simulate, and test systems before writing a single line of code. Digital models are created using different types of requirements diagrams, including block diagrams, state diagrams, activity diagrams, etc., which contain information about system behavior, control logic, inputs, outputs, and timing.

The main benefit of MBD is real-time simulation. Instead of developing full systems and testing, teams can run the model like a working prototype and test how it responds under real conditions. This helps validate the design early, reduces late-stage surprises, and saves development costs significantly.

MBD is mainly used in industries, such as aerospace, defense, automotive, robotics, etc., where teams need to build complex software, hardware, or physical parts.

In short, MDB helps teams to validate how the whole system behaves in the design phase and improve the system’s accuracy.

How Does Model-Based Development Work?

MBD follows a structured workflow where the model is considered the main working artifact instead of just a drawing. Here is a quick overview of the Model-Based Development life cycle:

1) Build a system model first

The first step is to create requirements diagrams (digital models) based on defined requirements. It represents the system behavior and shows how it responds to various inputs and conditions in different scenarios. These models can be built using state machines, equations, or an architecture-level diagram. Teams need to ensure that the diagram clearly represents inputs, outputs, logic, control behavior, timing, etc.

2) Run simulations to validate behavior

Next, use any simulation tools like Modern Requirements4DevOps to simulate the system’s behavior in a virtual environment. It allows teams to test how the system behaves in real-world scenarios and find potential issues without developing system prototypes.

3) Verification and Validation

Once the simulation output is obtained, verification and validation of the system should be performed. Verification helps in ensuring the system meets all documented requirements, and validation ensures that the system meets its intended purpose.

In mature MBD projects, teams also check:

  • requirement coverage (did we test every requirement?)
  • scenario coverage (did we test all conditions?)
  • model coverage (did all logic paths execute?)

This real-time traceability gives stronger confidence to teams working in regulated industries.

5) Code generation

If the system is perfect and works properly, automatically generate the code in the required programming language (commonly C/C++ for embedded systems) based on the model. There is a very small chance of errors when code is generated automatically using an AI tool.

6) Refine the model in short cycles

In case the system fails or needs to update any conditions, update the design and retest the system. This repeated cycle allows to improve the system continuously in a short cycle. 

Furthermore, teams can refine systems based on real-world test run data, helping improve the system’s accuracy over time.

7) Integrate with the target platform

Generated code is then connected with the rest of the system, like:

  • drivers
  • communication layers (CAN, LIN, Ethernet, etc.)
  • hardware interfaces
  • OS/RTOS scheduling logic

This step confirms that the modeled logic works correctly in the real environment.

Model-Based Development vs. Traditional Development

Aspect
Traditional Development
Model-Based Development (MBD)
Starting point
Teams write requirements and then implement with code.
Teams first develop the digital model, test the system, and if everything looks good, they write the code.
Early validation
Validation can only be done after implementing the full system.
Logic validation is done by simulating digital models before development starts.
Handling complex behavior
It is hard to handle complex timing and model-based behavior before implementing the system.
By simulating block diagrams and state machines, teams can easily review the complexity of systems.
Changes and rework
Requirement changes often cause large rework because changes happen late.
Changes are applied to the model first, then re-simulated to confirm the impact quickly.
Code quality and consistency
The code quality depends on the developer’s style and interpretation.
Model-driven workflows reduce interpretation gaps and support consistent implementation.
Speed of iteration
Iterations takes longer time, as teams need to write code and debug in every iteration.
Iterations are quick, as simulations provide quick feedback on behavior.
Traceability
Traceability is mostly manual and document-heavy.
Requirements-to-model and model-to-test linking is easier and more structured.

Best Practices for Successful Model-Based Development

  • Start with solid requirements: Properly define input, output, control conditions, limits, timing rules, non-functional aspects, etc., before creating the model.
  • Keep models clean and modular: Break logic into smaller subsystems so teams can review, reuse, and test parts independently.
  • Use consistent naming and units: Unclear naming or mixed units (°C vs °F, ms vs sec) creates costly errors later.
  • Simulate frequently: During model development, run simulations multiple times and frequently to validate requirements before writing code.
  • Maintain version control: Ensure to maintain the versions of each model with proper branching. When any fault occurs, teams should be able to restore the previous version.
  • Ensure traceability: Link requirements to model elements and test results so teams can have visibility across all changes.
  • Encourage cross-team reviews: Multiple relevant teams, including software, test, and hardware, must review system components together early to prevent late surprises.

Why Requirements Management is important for Model-Based Development

One thing is clear: In MDB, the model is developed to match requirements. So, if requirements are unclear, incomplete, non-traceable, or scattered across documents and emails, the model will also be incomplete, which can lead to wrong assumptions and rework.

A proper requirements management brings structure to this by ensuring all requirements are stored in one place and written in a testable way. Furthermore, during the collaborative review or audit, teams can see how requirements were evolved and who made changes through the version history.

This is where teams need to start using the requirements management software, such as Modern Requirements4DevOps, that provides comprehensive support for MBD. It offers traceability tools to connect updated requirements with requirements models, diagramming tools to prepare different types of diagrams, and simulation tools to validate models against different use cases. 

Furthermore, Modern Requirements4DevOps also offers a review management feature to collaboratively review requirements with an e-signature. By using the change impact assessment features and simulating with models, teams can know how the change will affect the system before implementing it.

Want to experience the power of model-based development with proper requirements management?

Table of Contents

Start using Modern Requirements today

✅ Define, manage, and trace requirements within Azure DevOps
✅ Collaborate seamlessly across regulated teams
✅ Get started for FREE—no credit card required

Start Free Trial

Recent Articles