mall and medium-sized enterprises (SMEs) increasingly face a paradox: modern software, cloud, artificial intelligence, DevOps, eCommerce and Industrial IoT technologies provide unprecedented capabilities, yet the complexity of development environments can become a significant source of cost, delay and operational risk.

This white paper proposes a Lean Engineering Toolchain based on five complementary technologies:

1. RustDesk — remote access and operational support
2. Figma — visual product and interface design
3. Visual Studio Code (VS Code) — engineering workspace and project hub
4. Mermaid — architecture, workflow and system documentation
5. Docker — isolated, reproducible development and experimentation

The central proposition is that these tools should not be viewed merely as individual applications. Together they form a lightweight engineering system that supports the complete development lifecycle:

Think → Design → Model → Implement → Isolate → Test → Deploy → Operate

The methodology is deliberately non-AI-centric. AI can subsequently be introduced as an accelerator, but the underlying engineering process should remain understandable, reproducible and controllable without dependence on code-generating AI.

The approach is particularly applicable to SME environments where engineering teams must simultaneously manage software development, eCommerce, cloud infrastructure, Industrial IoT, embedded systems, data engineering and emerging AI workloads.

Lean Engineering Toolchains for SMEs -A Practical Non-AI Development Methodology for Software, eCommerce, Industrial IoT and AI Engineering

Research White Paper
August 2026

Abstract

Small and medium-sized enterprises (SMEs) increasingly face a paradox: modern software, cloud, artificial intelligence, DevOps, eCommerce and Industrial IoT technologies provide unprecedented capabilities, yet the complexity of development environments can become a significant source of cost, delay and operational risk.

This white paper proposes a Lean Engineering Toolchain based on five complementary technologies:

1. RustDesk — remote access and operational support
2. Figma — visual product and interface design
3. Visual Studio Code (VS Code) — engineering workspace and project hub
4. Mermaid — architecture, workflow and system documentation
5. Docker — isolated, reproducible development and experimentation

The central proposition is that these tools should not be viewed merely as individual applications. Together they form a lightweight engineering system that supports the complete development lifecycle:

Think → Design → Model → Implement → Isolate → Test → Deploy → Operate

The methodology is deliberately non-AI-centric. AI can subsequently be introduced as an accelerator, but the underlying engineering process should remain understandable, reproducible and controllable without dependence on code-generating AI.

The approach is particularly applicable to SME environments where engineering teams must simultaneously manage software development, eCommerce, cloud infrastructure, Industrial IoT, embedded systems, data engineering and emerging AI workloads.

1. Executive Summary

The modern software development environment has become increasingly fragmented.

A typical SME project may involve:

• requirements documents;
• UI/UX design;
• architecture diagrams;
• source code;
• Git repositories;
• Docker containers;
• databases;
• cloud infrastructure;
• APIs;
• testing environments;
• deployment systems;
• remote servers;
• monitoring;
• customer support.

The resulting problem is not necessarily a shortage of technology. It is technology friction.

Developers frequently lose time moving between tools, environments and machines rather than solving the actual business problem.

The proposed Lean Engineering Toolchain addresses this problem by assigning a clear responsibility to a small number of tools.

Engineering function	Primary tool
Remote operations	RustDesk
Product/UI design	Figma
Engineering workspace	VS Code
Architecture/documentation	Mermaid
Environment isolation	Docker
Version control	Git/GitHub/GitLab
Continuous improvement	DORA metrics

The five-tool concept should therefore be expanded into a broader methodology:

Design before implementation, model before complexity, isolate before experimentation, document before deployment, and measure before optimization.

DORA research provides an important supporting framework. Its current software delivery model emphasizes throughput and instability, including change lead time, deployment frequency, failed-deployment recovery time, change fail rate and deployment rework rate. DORA also emphasizes small batches and continuous improvement rather than treating speed and stability as opposing objectives. (Dora)

This is particularly important for SMEs because they typically cannot afford large dedicated DevOps, infrastructure, security and UX teams.

2. Research Problem

2.1 The SME Engineering Challenge

Large enterprises can distribute engineering responsibilities across specialized teams:

• UX teams;
• frontend teams;
• backend teams;
• DevOps;
• QA;
• infrastructure;
• cybersecurity;
• cloud engineering;
• database administration;
• technical documentation;
• operations.

An SME frequently cannot.

A small engineering team may be responsible for all of these functions simultaneously.

Consequently, the engineering environment must optimize for:

• simplicity;
• low cost;
• rapid learning;
• reproducibility;
• maintainability;
• documentation;
• portability;
• remote administration;
• low operational overhead.

The objective is therefore not to acquire the largest possible collection of tools.

The objective is to create a minimum effective engineering system.

3. The Lean Engineering Principle

The proposed methodology is based on five principles.

Principle 1 — Visualize Before Building

UI and system concepts should be made visible before significant implementation effort is committed.

Figma provides collaborative design, prototyping and design-to-development workflows. Its current platform supports design collaboration and developer handoff, making it suitable as the visual planning layer. (Figma)

For an SME, this can reduce expensive late-stage changes.

Principle 2 — Model Complexity Before Implementing It

Complex systems should be represented graphically before they are implemented.

Mermaid is particularly useful because diagrams can be represented as text and maintained alongside technical documentation and source code. Mermaid supports flowcharts, sequence diagrams, entity-relationship diagrams, Gantt charts and other diagram types. (Mermaid)

This enables architecture to become a version-controlled engineering artifact rather than an obsolete PowerPoint diagram.

Principle 3 — Make the Workspace the Command Center

VS Code can serve as the engineering command center rather than merely a text editor.

A project workspace can contain:

• source code;
• configuration;
• documentation;
• Docker Compose files;
• environment definitions;
• scripts;
• tests;
• Git repositories;
• Mermaid diagrams;
• terminal sessions.

The result is a reduction in context switching.

Principle 4 — Experiment in Disposable Environments

Docker provides the foundation for isolated experimentation.

Instead of modifying the host operating system every time a new dependency or service is evaluated, an engineering team can create an isolated containerized environment.

The conceptual workflow becomes:

Create → Experiment → Test → Keep or Destroy

This is especially valuable when evaluating:

• databases;
• caching systems;
• APIs;
• development services;
• AI frameworks;
• eCommerce extensions;
• message brokers;
• observability platforms.

Principle 5 — Operate Remotely Without Losing Control

RustDesk adds the operational layer.

RustDesk describes itself as an open-source remote desktop solution with self-hosting capabilities and support for Linux, Windows, macOS, iOS, Android and Web. Its documentation also describes an OSS server option for self-hosting. (RustDesk)

For SMEs, self-hosting can be particularly attractive when remote access to development laboratories, VPS infrastructure or specialized engineering systems is required.

Security policies, authentication, network segmentation and least-privilege access should nevertheless be implemented independently of the remote desktop software.

4. The Five-Tool Engineering Architecture

The five tools form a logical engineering chain.

flowchart LR A[Business Requirement] --> B[Figma] B --> C[Mermaid Architecture] C --> D[VS Code] D --> E[Git] E --> F[Docker] F --> G[Test Environment] G --> H[Deployment] H --> I[RustDesk / Remote Operations] I --> J[Monitoring & Feedback] J --> A

The important feature of this architecture is the feedback loop.

Engineering is not treated as a one-way process.

It becomes:

Plan → Build → Test → Operate → Learn → Improve

5. Tool 1 — RustDesk

5.1 Role

RustDesk represents the remote operations layer.

Typical applications include:

• remote Linux administration;
• development workstation support;
• VPS troubleshooting;
• laboratory systems;
• customer support;
• remote demonstrations;
• embedded development environments;
• geographically distributed engineering.

RustDesk supports self-hosting, giving organizations the option of maintaining their own remote-access infrastructure. (RustDesk)

5.2 SME Value

The SME benefit is not simply remote desktop access.

It is the ability to create a distributed engineering laboratory.

For example:

Developer Workstation | | RustDesk v Engineering Server | +-- Docker +-- Git +-- Databases +-- Test Systems +-- RAGFlow +-- Ollama +-- Monitoring

This can reduce the need for physical presence when diagnosing non-critical development and infrastructure problems.

6. Tool 2 — Figma

6.1 Role

Figma represents the visual product-definition layer.

It can be used before coding to answer questions such as:

• What should the user see?
• What should happen when the user clicks?
• How should navigation work?
• How should information be organized?
• What happens on mobile?
• What is the checkout workflow?
• What does an industrial dashboard look like?

Figma supports collaborative design and prototyping and is designed to connect design activities with development workflows. (Figma)

6.2 eCommerce Application

For a Magento/Hyvä project, Figma can be used to establish:

• homepage;
• category pages;
• product pages;
• navigation;
• search;
• filters;
• shopping cart;
• checkout;
• customer account;
• mobile layouts.

The principle is:

Do not discover the user interface while writing production code.

7. Tool 3 — VS Code

VS Code becomes the engineering command center.

The workspace can bring together:

Project ├── app/ ├── config/ ├── docker/ ├── docs/ ├── diagrams/ ├── scripts/ ├── tests/ ├── .env.example ├── compose.yaml └── README.md

The developer can simultaneously access:

• source files;
• Git;
• terminal;
• Docker;
• testing;
• documentation;
• Mermaid diagrams;
• configuration.

This makes VS Code less of a "code editor" and more of a project cockpit.

8. Tool 4 — Mermaid

Mermaid addresses one of the most neglected parts of SME engineering:

technical communication.

Architecture that exists only in someone's head is a business risk.

Mermaid diagrams can describe:

System architecture

flowchart TD User --> Web Web --> Application Application --> Database Application --> Cache Application --> ExternalAPI

Sequence diagrams

sequenceDiagram User->>Web: Request Web->>Application: API Call Application->>Database: Query Database-->>Application: Result Application-->>Web: Response Web-->>User: Page

Industrial IoT

flowchart LR Vehicle[Vehicle CAN Bus] --> OBD[OBD-II Interface] OBD --> Edge[ARM Edge Device] Edge --> Gateway[IoT Gateway] Gateway --> Database[Time-Series Database] Database --> RAG[RAG Pipeline] RAG --> LLM[LLM] LLM --> Dashboard[Diagnostic Dashboard]

Because diagrams can be represented as text, they can also become part of the software repository and evolve alongside the system. (Mermaid)

9. Tool 5 — Docker

Docker represents the environment isolation layer.

For SMEs, this is particularly important because multiple projects frequently require different:

• PHP versions;
• Node versions;
• databases;
• libraries;
• services;
• operating-system dependencies.

Instead of installing everything directly onto the host, Docker allows environments to be packaged and recreated.

The conceptual model is:

Host Operating System | +---------------------------+ | Docker | | | | Magento Environment | | RAG Environment | | IoT Environment | | Database Environment | | Testing Environment | +---------------------------+

This is especially compatible with Warden-based Magento development.

10. The Sixth Layer — Git

Although the original five-tool model does not necessarily identify Git as one of the five primary tools, a professional engineering methodology should treat version control as foundational.

Git provides:

• history;
• branching;
• rollback;
• collaboration;
• traceability;
• release management.

The complete model therefore becomes:

Figma + Mermaid + VS Code + Git + Docker + RustDesk

11. Lean Engineering Lifecycle

The proposed development lifecycle is:

flowchart LR A[Business Need] --> B[Requirements] B --> C[Figma] C --> D[Mermaid] D --> E[VS Code] E --> F[Git] F --> G[Docker] G --> H[Automated Tests] H --> I[Deployment] I --> J[Remote Operations] J --> K[Feedback] K --> B

Each stage has a distinct purpose.

Stage	Question
Requirements	What problem are we solving?
Figma	What should the user experience?
Mermaid	How will the system work?
VS Code	How will we implement it?
Git	How will we control changes?
Docker	How will we isolate the environment?
Testing	Does it work reliably?
Deployment	Can we release it safely?
RustDesk	Can we support it remotely?
Feedback	What should improve?

12. Case Study A — Magento 2.4.8 + Hyvä

A small eCommerce organization can apply the methodology as follows.

Design

Figma defines:

• storefront;
• navigation;
• product experience;
• checkout;
• customer account.

Architecture

Mermaid documents:

• Magento;
• Hyvä;
• PHP;
• MariaDB;
• Redis;
• OpenSearch;
• RabbitMQ;
• Varnish;
• payment gateways;
• shipping services.

Development

VS Code becomes the development center.

Isolation

Warden and Docker provide reproducible development environments.

Version Control

Git manages:

• theme changes;
• modules;
• configuration;
• deployment scripts.

Operations

RustDesk provides remote access where appropriate.

The methodology therefore reduces the temptation to modify production systems directly.

13. Case Study B — RAG-LLM Engineering

The same methodology can be applied to RAG systems.

flowchart LR A[Documents] --> B[Ingestion] B --> C[Chunking] C --> D[Embeddings] D --> E[Vector Store] Q[User Question] --> R[Retriever] E --> R R --> L[LLM] L --> A1[Answer]

Figma

Design:

• chat interface;
• document management;
• source citations;
• administration dashboard.

Mermaid

Document:

• ingestion;
• embeddings;
• retrieval;
• reranking;
• LLM;
• evaluation;
• monitoring.

VS Code

Implement:

• Python;
• APIs;
• configuration;
• testing;
• integration code.

Docker

Isolate:

• RAGFlow;
• Ollama;
• databases;
• vector stores;
• supporting services.

RustDesk

Support remote development and laboratory systems.

14. Case Study C — OBD-AI / Industrial IoT

The methodology becomes especially powerful when hardware and software are combined.

A conceptual architecture is:

flowchart TD Vehicle --> CAN[CAN Bus] CAN --> OBD[OBD-II] OBD --> Edge[ARM Edge Device] Edge --> Logger[Data Logger] Logger --> Gateway[IoT Gateway] Gateway --> TSDB[Time-Series Database] TSDB --> Analytics[Analytics] Analytics --> RAG[RAG] RAG --> LLM[LLM] LLM --> Diagnosis[Diagnostic Assistant] Diagnosis --> Dashboard

The five tools map naturally onto this architecture.

Tool	OBD-AI role
Figma	Diagnostic dashboard
Mermaid	CAN/data/AI architecture
VS Code	Firmware + Python + APIs
Docker	Cloud/RAG/test services
RustDesk	Remote edge-device support

This provides a common engineering methodology across hardware, software and AI.

15. Case Study D — SME Marketing Automation

The same model applies outside pure software engineering.

For an SME marketing system:

flowchart LR Lead[Lead] --> CRM[CRM] CRM --> Segment[Segmentation] Segment --> Campaign[Campaign] Campaign --> Email[Email] Email --> Website[Website] Website --> Analytics[Analytics] Analytics --> CRM

Figma can design campaign landing pages.

Mermaid documents the marketing automation.

VS Code manages website and automation configuration.

Docker provides isolated development environments.

RustDesk supports remote administration.

The methodology therefore extends beyond engineering into digital business operations.

16. Integration With AI

The methodology is intentionally AI-compatible but AI-independent.

This distinction is important.

AI can accelerate:

• code generation;
• documentation;
• test generation;
• diagram generation;
• troubleshooting;
• data analysis;
• search;
• knowledge retrieval.

However, the underlying system should remain understandable without AI.

A robust principle is:

AI should accelerate a disciplined engineering process, not replace the engineering process.

This provides resilience if:

• an AI service becomes unavailable;
• an API changes;
• model performance changes;
• costs increase;
• generated code is incorrect;
• confidential information cannot be sent to an external model.

17. DevOps and Continuous Improvement

The toolchain should be measured rather than adopted purely because individual tools appear convenient.

DORA recommends measuring software delivery through performance dimensions including change lead time, deployment frequency, failed deployment recovery time, change fail rate and deployment rework rate. Its research also emphasizes working in small batches and continuously improving the delivery system. (Dora)

An SME can begin with a small measurement set:

Metric	Question
Lead time	How long does a change take?
Deployment frequency	How often can we release?
Change failure	How often do releases cause problems?
Recovery time	How quickly can we recover?
Rework	How much work is caused by previous failures?

The objective is not bureaucracy.

The objective is feedback.

18. Security Considerations

A lean toolchain must not become a security shortcut.

RustDesk

Use:

• strong authentication;
• controlled server access;
• network segmentation;
• least privilege;
• logging;
• explicit authorization.

RustDesk's own documentation highlights self-hosting and security capabilities, but organizations remain responsible for securely configuring their infrastructure. (RustDesk)

Docker

Containers should not automatically be treated as complete security boundaries.

Organizations should consider:

• image provenance;
• vulnerability scanning;
• secrets management;
• minimal privileges;
• network isolation;
• update management.

Git

Repositories should protect:

• API keys;
• passwords;
• certificates;
• private keys;
• customer data.

.env files containing secrets should not be committed.

19. Cost Optimization for SMEs

The methodology supports an important SME strategy:

Prefer capability over complexity.

Instead of purchasing enterprise platforms immediately, SMEs can begin with a small set of tools and expand only when justified.

Potential cost-saving mechanisms include:

• open-source software;
• self-hosting;
• containerized experimentation;
• shared development environments;
• remote support;
• reusable architecture;
• standardized documentation;
• automated testing;
• version-controlled infrastructure.

The objective is not necessarily "free software."

The objective is low total cost of ownership.

20. Organizational Benefits

The methodology can improve several dimensions of SME performance.

Reduced context switching

Developers work from a central engineering workspace.

Reduced rework

Design and architecture are considered before implementation.

Faster experimentation

Docker makes it easier to create disposable environments.

Better communication

Mermaid turns architecture into a shareable artifact.

Remote capability

RustDesk enables authorized remote operational support.

Improved onboarding

New engineers can understand a project from:

• README;
• architecture diagrams;
• source repository;
• Docker configuration;
• design files.

Better institutional knowledge

Knowledge becomes part of the project rather than remaining in individual employees' heads.

21. Recommended SME Standard

An SME engineering organization can establish the following standard:

Every project should contain

project/ ├── README.md ├── docs/ │ ├── architecture/ │ ├── requirements/ │ └── operations/ ├── diagrams/ ├── src/ ├── tests/ ├── scripts/ ├── docker/ ├── .env.example ├── compose.yaml └── CHANGELOG.md

Every major feature should have

1. a requirement;
2. a design;
3. an architecture diagram;
4. an implementation;
5. automated tests;
6. a Git commit;
7. a deployment procedure;
8. operational documentation.

This creates a lightweight engineering governance system without imposing enterprise bureaucracy.

22. Proposed SME Engineering Maturity Model

Level 1 — Ad Hoc

• manual development;
• undocumented environments;
• production modifications;
• limited testing.

Level 2 — Organized

• Git;
• VS Code;
• Docker;
• basic documentation.

Level 3 — Structured

• Figma;
• Mermaid;
• automated tests;
• CI/CD;
• reproducible environments.

Level 4 — Measured

• DORA metrics;
• observability;
• automated deployment;
• recovery procedures.

Level 5 — Intelligent

• AI-assisted engineering;
• RAG knowledge systems;
• automated diagnostics;
• predictive operations;
• agentic workflows.

The critical insight is that Level 5 should be built on Levels 1–4 rather than used as a substitute for them.

23. Recommended Architecture for KeenComputer / IAS-Research / KeenDirect

For an SME technology organization working across software, eCommerce, engineering research and Industrial IoT, the methodology can be organized into three complementary domains.

KeenComputer

The SME digital-transformation layer:

• websites;
• eCommerce;
• cloud;
• DevOps;
• cybersecurity;
• CRM;
• digital marketing;
• automation.

KeenDirect

The eCommerce engineering layer:

• Magento;
• Hyvä;
• payment integration;
• shipping;
• supply-chain integration;
• performance optimization;
• hosting and DevOps.

IAS-Research

The engineering research layer:

• embedded systems;
• VLSI;
• power electronics;
• Industrial IoT;
• OBD/CAN;
• edge computing;
• AI/RAG;
• engineering research.

The same Lean Engineering Toolchain can provide the common engineering foundation across all three domains.

24. Strategic Model

The overall model can be represented as:

flowchart TD Strategy[Business Strategy] Strategy --> Design[Figma] Strategy --> Architecture[Mermaid] Design --> Engineering[VS Code] Architecture --> Engineering Engineering --> Git[Git] Git --> Docker[Docker] Docker --> Testing[Testing] Testing --> Deployment[Deployment] Deployment --> Operations[RustDesk / Operations] Operations --> Metrics[DORA / Observability] Metrics --> Strategy

This transforms a collection of development tools into a continuous engineering system.

25. Conclusions

The central conclusion of this research is that SME engineering productivity does not require a massive technology stack.

A carefully designed collection of complementary tools can provide much of the functionality required to build, test, deploy and operate sophisticated systems.

The five tools examined in this paper have distinct responsibilities:

RustDesk provides remote operational access.

Figma provides visual product design.

VS Code provides the engineering workspace.

Mermaid provides executable-style technical documentation and system visualization.

Docker provides environmental isolation and reproducibility.

Together with Git, automated testing and continuous-improvement measurement, they establish a practical foundation for modern SME engineering.

The methodology is particularly relevant to organizations working simultaneously with:

• Magento and Hyvä;
• eCommerce;
• Docker and DevOps;
• Industrial IoT;
• embedded systems;
• OBD-II/CAN;
• RAG-LLM;
• cloud infrastructure;
• CRM and marketing automation.

The most important strategic lesson is therefore not which individual tool should be selected.

It is the discipline of assigning every engineering activity an appropriate, lightweight and reproducible mechanism.

A mature SME engineering organization should strive for:

Simple tools, explicit architecture, disposable environments, version-controlled knowledge, measurable delivery and continuous improvement.

AI can subsequently accelerate this system, but the system should remain robust even when AI is unavailable.

That is the foundation of a sustainable Lean Engineering Operating Model for SMEs.

26. Implementation Roadmap

Phase 1 — Foundation

• Standardize VS Code workspaces.
• Establish Git repositories.
• Establish Docker development standards.
• Create README and documentation standards.

Phase 2 — Design

• Introduce Figma for customer-facing products.
• Establish reusable design systems.
• Define UX review before implementation.

Phase 3 — Architecture

• Standardize Mermaid diagrams.
• Store diagrams with source code.
• Create architecture templates.

Phase 4 — DevOps

• Implement automated testing.
• Establish CI/CD.
• Introduce reproducible deployment.
• Measure delivery performance.

Phase 5 — Remote Operations

• Deploy controlled RustDesk infrastructure where appropriate.
• Establish access policies.
• Document remote-support procedures.

Phase 6 — AI Integration

• Introduce RAG.
• Introduce local LLMs where appropriate.
• Add AI-assisted development.
• Develop domain-specific AI assistants.

Phase 7 — Continuous Improvement

• Establish DORA metrics.
• Analyze bottlenecks.
• Reduce batch size.
• Automate repetitive processes.
• Review architecture periodically.

27. Final Strategic Recommendation

For SMEs, the recommended strategy is not "buy more tools."

It is:

Standardize fewer tools and use them better.

A practical baseline is:

Figma → Mermaid → VS Code → Git → Docker → RustDesk → Testing → CI/CD → Measurement

This toolchain can support a surprisingly broad range of engineering activities while maintaining a low barrier to entry.

For a technology-oriented SME, it provides a bridge between traditional software development and more advanced disciplines such as DevOps, Industrial IoT, edge computing, RAG-LLM and AI-assisted engineering.

The result is a development environment that is:

• lean;
• reproducible;
• documented;
• remotely manageable;
• scalable;
• measurable;
• AI-ready;
• and suitable for resource-constrained organizations.

References

1. DORA, Software Delivery Performance Metrics, Google Cloud/DORA, 2026. (Dora)
2. DORA, DORA Core Model and Research, Google Cloud/DORA. (Dora)
3. Mermaid, Official Mermaid Documentation and Diagramming Platform. (Mermaid)
4. Mermaid, Creating Your First Diagram. (Mermaid)
5. Figma, Figma — Collaborative Design and Product Development Platform. (Figma)
6. Figma, What is Figma?, Figma Help Center. (Figma Help Center)
7. Figma, Figma Design — Collaborative UI/UX Design. (Figma)
8. RustDesk, Open Source Remote Desktop Documentation. (RustDesk)
9. RustDesk, RustDesk Open Source Project. (GitHub)
10. RustDesk, Self-Hosted Remote Access Platform. (RustDesk)

Suggested Further Research

Future versions of this white paper should examine the integration of:

• Docker Compose and Kubernetes;
• GitHub/GitLab;
• Warden and Magento 2.4.x;
• Hyvä Themes;
• automated testing;
• CI/CD;
• OpenTelemetry;
• Prometheus and Grafana;
• RAGFlow;
• Ollama;
• local LLM deployment;
• MCP;
• n8n;
• Vtiger CRM;
• Mautic;
• Industrial IoT;
• CAN/OBD-II;
• TinyML;
• edge AI;
• time-series databases;
• cybersecurity and zero-trust remote operations.

This creates a broader research program for developing a Lean Digital Engineering Architecture for SMEs spanning eCommerce, software, AI, Industrial IoT and engineering research.