Common challenges in Model Based Development

Model-Based Development (MBD) is changing embedded systems engineering, from automotive to aerospace, industrial automation to medical devices. It promises faster design, early validation and automatic code generation, so it is easy to see why organizations are adopting it.

Like any powerful methodology, though, MBD comes with its own challenges, from toolchain complexity and simulation delays to integration headaches and traceability gaps. This post covers the most common pain points in Model-Based Development and offers practical, field-tested solutions for each.

What is Model-Based Development?

Model-Based Development uses graphical models (for example in Simulink or SCADE) to design, simulate, verify and automatically generate embedded software. Instead of writing code from scratch, engineers build logic using blocks, simulate performance and generate production-quality code.

Think of MBD as designing software the way an architect draws blueprints, before a single line of code is written or tested on hardware.

Why understanding MBD challenges matters

As projects grow in size, safety-criticality and cross-team collaboration, hidden inefficiencies in the MBD workflow can result in:

• Unmaintainable models
• Failing code generation
• Costly late-stage bugs
• Certification delays

Addressing these challenges early means smoother projects, faster time-to-market and higher product reliability.

1. Modeling for simulation, not deployment

The challenge

Many engineers build models focused only on simulation results. But blocks or settings that work in simulation may be incompatible with embedded code generation. An example is using variable-step solvers or floating-point math on a low-end microcontroller.

The solution

• Design with code generation in mind.
• Use discrete-time blocks and fixed-step solvers.
• Choose data types compatible with the target hardware (for example int16, uint8).

Use tools like Simulink's Embedded Coder Advisor to validate your model for embedded readiness.

2. Poor model architecture and scalability

The challenge

As models grow, a lack of modularity and structure leads to bloated block diagrams, hard-to-debug subsystems and reuse limitations.

The solution

• Follow hierarchical modeling practices.
• Use Model References and Libraries for reuse.
• Apply naming conventions and consistent signal labeling.

Treat models like software architecture: modular, well-named and reusable components are key to long-term scalability.

3. Misconfigured sample times and solvers

The challenge

Incorrect or mismatched sample times cause undetected timing issues, task overruns in real-time systems and inconsistent behavior between simulation and hardware.

The solution

• Define clear sample time specifications for each block.
• Use Rate Transition blocks for multi-rate systems.
• Stick to fixed-step solvers for embedded workflows.

Timing is everything, so treat sample times as contracts between system components.

4. Lack of requirement traceability

The challenge

Without linking requirements to models and tests, compliance becomes painful, especially for ISO 26262 or DO-178C certification.

The solution

• Use tools like Simulink Requirements, IBM DOORS or Polarion.
• Link model blocks, test cases and simulation results to high-level specs.
• Automate traceability report generation.

Traceability turns engineering guesswork into audit-ready transparency.

5. Incomplete simulation and testing coverage

The challenge

Relying only on nominal-case simulation means critical bugs can slip through to production.

The solution

• Perform Model-in-the-Loop (MiL) testing for early validation.
• Use Software-in-the-Loop (SiL) and Hardware-in-the-Loop (HiL) for system-level testing.
• Use Simulink Test or custom harnesses.
• Include fault injection and edge case simulations.

A well-tested model behaves like a well-tested system, across normal and abnormal conditions.

6. Large model load and simulation times

The challenge

Large models can slow down simulations, increasing iteration times and frustrating developers.

The solution

• Use Model Referencing to load parts of the model only when needed.
• Profile and optimize bottleneck blocks.
• Simplify overly detailed parts of the model for early-stage testing.

Simulation performance is just as important as model accuracy, so optimize for iteration speed.

7. Integration with DevOps and Agile pipelines

The challenge

MBD tools often operate outside the version-controlled, CI/CD workflows of modern software teams.

The solution

Use MATLAB scripts or Python wrappers to automate simulation and testing. Integrate with Jenkins, GitLab CI or Azure DevOps for:

• Regression testing
• Code generation validation
• Coverage reporting

Treat models like source code: version-controlled, testable and deployable.

8. Over-reliance on auto-generated code

The challenge

Blindly trusting auto-generated code can lead to performance bottlenecks, memory inefficiencies and platform-specific issues.

The solution

• Review generated code for size and complexity.
• Use MISRA C guidelines or Polyspace to verify safety and correctness.
• Tune code generation settings for speed, memory or readability.

Code generation is powerful, but only when paired with review and optimization.

9. Toolchain complexity and licensing constraints

The challenge

MBD ecosystems involve multiple tools (for example Simulink, Stateflow, Embedded Coder, SCADE and dSPACE), each with its own licensing and learning curve.

The solution

• Define a toolchain baseline and maintain a version matrix.
• Use tool automation scripts to abstract complexity.
• Centralize licensing management and offer training resources for your teams.

The tools should work for your team, not the other way around.

Summary: MBD challenges are solvable with the right strategy

Challenge	Solution
Simulation-only mindset	Design for deployment using fixed-step, discrete models
Poor model structure	Modularize using subsystems and references
Sample time errors	Define clear timing architecture
No traceability	Use integrated requirement linking tools
Limited testing	Include MiL, SiL, HiL, and fault cases
Slow simulations	Optimize model performance and structure
DevOps disconnect	Automate MBD with scripts and CI tools
Code generation risks	Validate, review, and configure generation settings
Toolchain complexity	Standardize tool usage and train teams

Watch our workshop videos on the Reynlab YouTube Channel, or explore our automotive training programs at www.reynlab.com/our-courses.