How to Integrate Model‑Based Development (MBD) into Agile and DevOps Workflows

In today’s era of fast-paced development, engineering teams are under pressure to deliver smarter systems faster—without compromising on quality or safety. This is especially true in industries like automotive, aerospace, and industrial automation, where embedded systems grow increasingly complex.

So how do you integrate Model‑Based Development (MBD)—a traditionally sequential engineering approach—into Agile and DevOps workflows designed for speed and iteration?

This blog post explores exactly that: how to bring models, simulations, and auto-generated code into the modern CI/CD pipeline, making your embedded systems development as lean and adaptive as your software team.

🧠 Quick Recap: What is Model‑Based Development (MBD)?

Model‑Based Development uses graphical models (e.g., Simulink, SCADE) to design, simulate, and generate embedded software. Instead of writing code line-by-line, engineers build models that are:

Simulated for correctness
Automatically translated into code
Tested against requirements

🧩 Think of MBD as the “Lego Technic” of software design: you build logic from functional blocks, test it virtually, and deploy it directly.

🤝 The Challenge: MBD Meets Agile & DevOps

Traditionally, MBD has been associated with waterfall-like workflows:

Model first → test → generate code → integrate → verify

Agile and DevOps, by contrast, focus on:

Rapid iterations
Continuous integration
Incremental deliveries
Cross-functional collaboration

At first glance, these paradigms seem at odds. But integrating MBD into Agile/DevOps workflows isn’t just possible—it’s transformative.

🚀 Why Integrate MBD with Agile & DevOps?

Faster Feedback: Catch issues in model logic and simulations early
Traceability: Link requirements, models, and tests in one CI pipeline
Automation: Auto-generate and test embedded code in every sprint
Scalability: Coordinate large teams across control, software, and systems engineering

🎯 Your control algorithm isn’t “done” when the model works—it’s done when it runs on hardware and passes tests. DevOps closes that loop.

🛠️ How to Integrate MBD into Agile/DevOps: A Step-by-Step Blueprint

✅ 1. Modularize Your Models for Iterative Development

Break large Simulink or SCADE models into logical subsystems:

Control loops
Diagnostic modules
Interface layers

Benefits:

Enables incremental testing
Allows parallel development across teams
Simplifies version control

🧩 Like microservices in software, modular models make updates safer and faster.

✅ 2. Use Version Control (Git, SVN) for Models

Even though MBD tools use graphical UIs, their underlying files are text-based or XML.

Best practices:

Use .SLX, .MDL or .SCADE formats with version control
Use model differencing tools (e.g., Simulink Compare)
Store test harnesses, data files, and simulation configs with your model

🔁 Version control makes model evolution transparent—and recoverable.

✅ 3. Automate Testing with CI Tools

Set up Continuous Integration (CI) pipelines using:

Jenkins
GitLab CI
Azure DevOps
Bamboo

In each commit or merge:

Run Model-in-the-Loop (MiL) simulations
Execute Software-in-the-Loop (SiL) validation
Compare outputs with baselines
Generate code coverage and test reports

🧪 Treat your model like code: test it every time it changes.

✅ 4. Use Scripting for Automation (MATLAB, Python)

MBD tools support scripting interfaces:

MATLAB scripts for Simulink automation
Python wrappers for simulation runs
Batch code generation and model validation

Use them to:

Run batch simulations
Check for model guideline compliance
Trigger code generation and deploy artifacts

📜 Scripts are your glue between MBD tools and CI pipelines.

✅ 5. Deploy Auto-Generated Code to Real Hardware

Don’t stop at simulation. Use:

Simulink Real-Time, Speedgoat, dSPACE, or custom boards
Processor-in-the-Loop (PiL) and Hardware-in-the-Loop (HiL) frameworks

Benefits:

Validate timing constraints
Test real sensor feedback and actuation
Measure execution time and memory

💡 Shift-left testing meets physical validation—no surprises at integration time.

✅ 6. Integrate Requirements and Traceability

Use tools like:

Simulink Requirements
IBM DOORS Next
Polarion ALM

To:

Link model blocks to textual requirements
Track test results against specifications
Generate audit-ready compliance reports for ISO 26262, DO-178C

📋 In safety-critical systems, traceability is not optional—it’s mandatory.

✅ 7. Involve Cross-Functional Teams Early

Agile is all about collaboration.

Tips:

Invite controls, software, test, and hardware engineers into model reviews
Use Simulink Review Manager or equivalent to comment on model versions
Share simulations as video clips, plots, or web interfaces

👥 Don’t keep your models siloed—make them a living part of the product backlog.

🔄 DevOps Pipeline Example with MBD

Here’s what a modern DevOps pipeline for model-based embedded development might look like:

Code Commit (Git): Model or requirement is updated
Build Triggered (Jenkins/GitLab)
Model Checks: Guidelines, data types, solver settings
Simulation (MiL, SiL): Run tests and compare outputs
Code Generation: Generate embedded C code (via Embedded Coder or TargetLink)
Unit Testing & Code Analysis: Run Polyspace, static analysis
PiL/HiL Deployment: Test generated code on target hardware
Feedback & Reports: Push results to dashboards, notify engineers

📈 From model edit to real-time testing in minutes—not months.

🔧 Tools That Support Agile + MBD

⚠️ Pitfalls to Avoid

❌ Modeling in Isolation

Failing to consider integration early leads to rework. Fix: Involve software/hardware teams in model design.

❌ Manual Code Generation & Deployment

Manual steps break automation. Fix: Use scripts and CI tools to automate everything.

❌ Monolithic Models

Hard to test or integrate iteratively. Fix: Design modular, testable model components.

🎯 Final Takeaway: MBD and DevOps Are Not Mutually Exclusive

Model-Based Design may look like an old-school, top-down method—but when combined with Agile practices and DevOps automation, it becomes a powerful enabler for: