[Paper] MoT: A Model-Driven Low-Code Approach for Simplifying Cloud-of-Things Application Development

Source: arXiv - 2512.14613v1

Overview

The paper presents MoT (Model of Things), a model‑driven, low‑code framework that aims to make the development of Cloud‑of‑Things (CoT) applications far less painful. By extending UML with a custom IoT‑centric profile, MoT lets engineers design, generate, and deploy end‑to‑end IoT solutions without deep expertise in cloud platforms or embedded programming.

Key Contributions

• Custom UML profile for IoT & cloud services – a domain‑specific extension that captures sensors, actuators, data streams, and cloud functions in a visual model.
• Low‑code code‑generation pipeline – automatically produces boilerplate code, configuration files, and deployment scripts for popular cloud providers (e.g., AWS, Azure).
• End‑to‑end toolchain – integrates modeling, validation, code generation, and one‑click deployment, closing the gap between design and production.
• Empirical evaluation – a case‑study plus a Technology Acceptance Model (TAM) questionnaire that measured perceived ease of use, usefulness, and adoption intent among developers with varying IoT experience.
• Open‑source prototype – the authors released a usable implementation that can be extended for other cloud/IoT stacks.

Methodology

1. Modeling Layer – The authors defined a UML profile (stereotypes, constraints, and diagrams) that represents typical CoT artifacts: devices, data topics, edge processing, and cloud services.
2. Transformation Engine – Using model‑to‑text (M2T) templates, the tool translates the visual model into source code (e.g., Node‑RED flows, AWS Lambda functions) and infrastructure‑as‑code descriptors (Terraform/CloudFormation).
3. Validation & Deployment – A lightweight validator checks model consistency (e.g., matching data types, required authentication). The generated artifacts are then deployed with a single CLI command.
4. Evaluation – A real‑world CoT scenario (environmental monitoring) was built with MoT by a mixed group of participants (students, junior developers, IoT hobbyists). Afterward, participants completed a TAM questionnaire and provided qualitative feedback.

Results & Findings

• Development time cut by ~60 % compared with a hand‑coded baseline.
• Perceived Ease of Use (PEOU) scored 4.3/5 and Perceived Usefulness (PU) 4.5/5, indicating strong acceptance even among users with limited IoT background.
• Error rate (compile‑time or deployment failures) dropped from 23 % in the manual approach to 4 % with MoT, thanks to model validation.
• Qualitative comments highlighted the visual model’s ability to “show the whole system at a glance” and the one‑click deployment as “a game changer for rapid prototyping.”

Practical Implications

• Faster MVPs for IoT startups – Teams can spin up a functional CoT stack in hours rather than weeks, accelerating market validation.
• Lower skill barrier – Organizations can involve product managers or domain experts in the design phase without requiring them to write cloud SDK code.
• Standardized artifacts – The UML profile encourages a common vocabulary across devices, edge, and cloud, improving interoperability and easing hand‑offs between teams.
• Infrastructure as code integration – Generated Terraform/CloudFormation scripts fit directly into CI/CD pipelines, enabling automated testing and continuous deployment of IoT services.
• Vendor‑agnostic scaffolding – While the prototype targets AWS and Azure, the model is extensible, allowing companies to plug in other platforms (Google Cloud, private edge clouds) with minimal effort.

Limitations & Future Work

• Scope of supported services – The current implementation covers a limited set of cloud functions and messaging patterns; extending to more exotic services (e.g., AI inference at the edge) is left for future versions.
• Performance benchmarking – The study focused on development productivity, not on runtime performance or scalability of the generated code.
• User study size – The TAM evaluation involved a relatively small, mostly academic cohort; larger industry‑scale studies are needed to confirm generalizability.
• Model evolution management – Handling versioning and migration of models as the underlying cloud APIs evolve remains an open challenge.

Bottom line: MoT demonstrates that a well‑crafted model‑driven, low‑code approach can dramatically simplify Cloud‑of‑Things development, opening the door for faster, more collaborative, and less error‑prone IoT projects. Developers looking to reduce boilerplate and accelerate deployment should keep an eye on this emerging methodology.

Authors

• Cristiano Welter
• Kleinner Farias

Paper Information

• arXiv ID: 2512.14613v1
• Categories: cs.SE, cs.ET, cs.HC
• Published: December 16, 2025
• PDF: Download PDF