Architecture

Overview
What are we covering today?

Architecture Principles Platform Architecture Application Architecture Runtime Architecture

• Subscription to Innovation • Studio Pro • Modules • Client Architecture

• Evolution of platform • Mendix Portal • Data Modelling • Server Architecture

• Architectural Principles • Team Server • Logic Modelling • Container Architecture

• Model Driven Development • Build Server • UI Modelling • Storage Architecture

• 12 Factor Apps • Catalog • Security

• Event Broker

• Marketplace

• Cloud Portal
01
Architectural
Principles
 Adopting Mendix is a
subscription to innovation
Mendix 9
☉☉☉☉☉☉☉☉☉☉☉
Mendix 10
☉☉☉☉☉☉☉☉☉☉☉☉
Mendix 11
☉☉☉☉☉☉☉☉☉☉☉☉
Mendix 12
☉☉☉☉☉☉☉☉☉☉☉

June 2023 June 2025 June 2027

Minimal breaking Smooth technology Monthly N-2 major release MTS & LTS versions
changes introductions releases support
Architecture Principles
Designed for today’s complex software development challenges

Mendix is guided by the following architectural principles to ensure customers can address today’s complex software development
challenges:

Model-driven Model Interpretation

Leverage visual models instead of Runtime interpretation of models over Microservices
textual code to build software code generation Scalable container-based architecture

Statelessness Open & Extensible Twelve-Factor principles

Clients are independent of underlying Ensure the platform is both extensible Adhere to best-practice guidelines
runtime provider and open. around building scalable apps
Model Driven Development and Execution

Most Low/No code vendors implement a concept known

as Model Driven Development (MDD).

MDD is a software development methodology that allows

users to build complex applications through simplified
abstractions of pre-built components.

MDD simplifies complexity through abstraction and

reduces human-process intervention through automation.
How does Model Driven Development work?

Styles

Code Generation Model Execution

(Compiled or Interpreted) (Interpreted)
12 Factor Low-Code Apps
Applying industry best-practices to Low-Code to ensure portability and scalability

Codebase Port Binding

1 One version-controlled codebase and deployments via packages
7 Can be configured to be self contained, enabling the platform to scale the number of
containers hosting your app.

2 Dependencies 8 Concurrency
All dependencies are part of the app model Mendix uses a combination of Java threads and processes to scale

3 Configuration 9 Disposability
Defined in the app model via environment variables In multi-instance environment, users will not be impacted when an instance is stopped.

4 Backing Services 10 Development / Production Parity

Configurable at deployment time All environments are provisioned in the same way; the only differences are in configuration

5 Build, Release, Run 11 Logs

Separate build, release and run processes Mendix uses industry standard I/O streams to collect log events

6 Processes 12 Admin Processes

The Mendix Runtime is designed to be completely stateless. Users are encouraged to ship both user and admin logic in one model
02
Platform
Architecture
The Mendix Platform offers a complete, integrated
experience for the entire software lifecycle

PRIORITIZE
DEPLOY

IDEATE Portfolio Cycle OPERATE Application Cycle DEVELOP

EVALUATE PLAN

GOVERN
 Governance & Quality Services
Standard Platform Architecture
Control SSO
APMs QSM Menditect
Center

Feedback
User Stories

Deploy
Package
Mendix Portal Runtime
Monitor/
Cloud Portal
Apps Status, Logs/
Users Links Backups

Android iOS
Studio Pro Model
Package
Runtime
Version Control Models

MX Cloud Web Mobile

Teamserver Build Private Cloud
(Git) Server Kubernetes
Apps &
Modules

Package References
Package
Marketplace Repository

Service
Service Definitions Definitions Event Messages

Event
Catalog Broker

Development Developer Portal Build Server/Cloud Portal Runtime(Cloud) Users

Mendix Studio Pro

• Local desktop installation

• Intuitive UI

• Extensible Application Logic

• AI Assisted Development

• Develop without connectivity

• Light and Dark mode Support

Mendix Portal
A single experience for all users involved in turning ideas to outcomes

• Central hub for delivery of projects

• Interacts with various other parts of the platform

• Tailored user onboarding experience

• Easily navigate to various parts of the platform

• Manage out project lifecycle and configurations

• Built on Mendix technology

Mendix Team Server
Centralised hosted version control

Hosted version control repository

Based on Git

Visible to all team members

Tie commits to stories

View history and branch lines

Mendix Build Server

• The build server connects to Teamserver to get the

correct version and retrieves files to build

• Leverage hosted or locally

• Responsible for building Mendix Deployment Archive

(MDA)

• Once built the achieve will be stored in the package

repository ready for deployment

• Once deployed the MDA will be unpacked and analysed

by the runtime
Mendix Catalog
Easily discover data and events in your ecosystem

Discover
Search and explore your data and connectors with the Mendix
Connect Catalog.

Understand
Gain insight into data context, ownership, and sensitivity with
curated metadata right in the Mendix Connect Catalog.

Use
Drag-and-drop data into the IDE, or use curated endpoints to pull
data into BI tools securely.

Govern
Secure and manage trusted data for safe reuse in a single-click via
automatic registration
Event Broker
Seamlessly build event driven architectures

Based on Kafka TAILORED EXPERIENCES

Subscribe and publish events

PROCESS ORCHESTRATION

Leverages CloudEvents & AsyncAPI SVC SVC SVC SVC DATA ANALYTICS

Event bridge for AWS SQS EVENT BROKER

Hosted or on-premises ERP

Product
Inventory
Customer
App
IoT Logistics
Production
Manager
Marketplace
Fast track development further with reusable components available on the Marketplace

• Rich repository of reusable components

• Full Apps, Modules, Connectors, Widgets and

themes

• Public and Private marketplaces

• Thousands of components available

• Integrated into Studio Pro

• Get informed of updates to components

• Curate which content your team can use

Cloud Portal
Simplify operations and maintain complete control

• Manage environments, configurations and

processes centrally

• Control both public and private cloud infrastructure

• Seamlessly scale applications

• Monitor health of environments

• Control how, where and when to deploy with

Mendix Pipelines

• Provision new environments

03
Application
Architecture
Full-Stack Visual Software Development
Abstracting and simplifying the process of building software

Data Logic User Experience Workflow

Manage what data is used Visually build function logic Build user experiences for any Create long lived task-based
and stored visually using using Microflows and modality whether it’s for processes enabling
Domain Models Nanoflows for server-side and Mobile, Tablet, or Responsive.
client-side.

Domain Models Microflow & Nanoflow Pages Workflow

Domain Model (Data) Domain Models

Low-code approach to data

Leverages Object Relational Mapping (ORM)

• Schema versioning
• Data binding
• Data consistency

Define your data using:

• Entities
• Attributes
• Associations

Rule based attribute validation

• Rules propagate to UI and logic

Create object-based event handlers:

• Create
• Delete
• Commit
• Rollback

Configure delete cascade/prevention rules

 Domain Model (Data) Domain Models

Abstracting data to ensure future proof

{
"guid" : "274790396018",
"objectType" : "Module.Department", Abstract Data Model
"attributes" : {
"DepartmentId" : { "value" : 4 },
"Name" : { "value" : "Oncology" }, • Technology & Protocol Agnostic
"Abbreviation" : { "value" : "ONC" }

}
}
• Queries translatable to any query
language (SQL, OData, REST)
{
"guid" : "224743818103", • Future proof
"objectType" : "Module.Employee",
"attributes" : { Previously XML based, currently everything is based on JSON
"EmployeeId": {"value" : 1 },
"Title": {"value" : "" },
"Firstname": {"value" : "Fien" },
"Lastname": {"value" : "de Strigter" },
"Gender": {"value" : "" },
"Phone": {"value" : "+31(0)50-5736473" },
"JobTitle": {"value" : "Nurse" },
"Specialty" : {"value" : null },
"Email" : { "value" : "fien.de_strigter@summerhouse.com" },
“Module.Department" : { "value" : "274790396018" }
}
}

Tables
Persistent / Non-Persistent / External Entities Domain Models

Manage a different types of data

Persistent Entities Non-Persistent Entities External Entities

Primary storage Database Memory Remote Service

Queries translated to SQL Memory Lookup OData / REST API call
Survive session Y N N
Supports validation Y N N
Supports indexes Y N N
Supports event handlers Y Y N
Microflow & Nanoflow (Logic) Microflow & Nanoflow

Low-code approach to logic

• Action based short lived function

• Visual coding language
• Client-side (Nanoflows)
• Server-side (Microflows)
• Contains: Parameters, Actions, Decisions,
Loops and Merges.
• Built-in Transaction handling
• In one click expose as an API
Anatomy of Mendix Logic Microflow & Nanoflow

Build complex logic using a powerful visual language

1. Parameter
6. End Event

5. Loop

4. Action
2. Start Event 6. End Event

3. Decision

1. Parameter 2. Start Event 3. Decisions 4. Action 5. Loop 6. End Event

Logic can be passed data using All Mendix logic will have one Logic direction is controlled via An action can have many These allow developers to Every logic has an end event. It
one or more parameters. start event, this indicates where Decisions. A decision is different types. They can perform a for each loop over a can either return data or not.
Parameters support objects and the logic begins. expressed through an retrieve, change or delete data list of data or a while loop based Multiple end events are possible
other data types such as strings, expression. The outcome can be as well as being able to call on a condition. to allow the passing back of
integers or Booleans. either true/false or a set of other flows and APIs. different decisions/data.
values.
Microflows & Nanoflows (Logic) Microflow & Nanoflow

Visual Code Textual Code

(Microflow & Nanoflow) (JavaScript)
Extensive and Extendable toolbox Microflow & Nanoflow

Leverage out of the box capabilities or create your own

• Extensive set of out of the box activities

• Drag and Drop experience

• Create your custom actions using Microflows, Java, or

JavaScript

• Fully open API for interacting with the platform

• Download or share capabilities via the Mendix Marketplace

Pages (User Experience) Pages

Build user experiences for any modality

• Visually build custom UIs for any User

Experience

• Full WYSIWG editor

• Leverage security models to provide

unique experiences for individual users
whilst reusing page components

• Extend with HTML & JS to enhance

experience
Workflows Workflows

Create long lived task-based processes

• Long-lived processes
• Visually express the business processes
• Dedicated workflow editor
• A visual approach to object state-based
workflow
• Drag & drop human tasks and automated
tasks
Modules
Low-code approach to packages

• Application functionality is broken into modules

• Modules are reusable across applications
• Modules contain: Data, Logic, Pages and Security
• Modules are independent and can be updated when desired.
• Modules are shareable via Mendix Marketplace (Public or
Private)
• Modules can be made Editable or Protected. Making a module
protected ensures that a module cannot be changed.
• Reusable security model across applications, ensuring secure
distribution
Mendix Application Development Modules
Marketplace
Administration
Sample Application Styling
Domain Model
Navigation Settings Styling Security

Styling

SSO Security
Repair Calls Returns Process

Domain Model Pages

Domain Model Domain Model
Logic
Styling Styling Security

Pages
Security Security

Logic
Logic Pages

Excel Export
Integration Logic
Styling
Integration Domain Model

Domain Model
Security

Styling
Pages

Security Logic

Pages
App Security Architecture
Layered security model for flexibility and control

Robust layered app security model allowing developers to setup

access controls Users Users Roles Module Roles
System Registrations Invoicing
• Each App can contain many users
Jimmy Director Director Super user
• Each user can have one or more user roles and a System roles.
Simone Teacher User Editor
• Module roles are a way of defining security access that is
Paul
reusable across projects.
John Trainee User Viewer
• Combine Module level roles into User Roles Barry

• Granular Security configuration on Documents within each Michelle Finance User Editor
Module with Module Roles.
Mendix App Security
The most secure low-code platform

Authorization Authentication
• Set security on all three layers • Secure OOTB authentication
• Leverage role-based access control (RBAC) and attribute- • Authentication can be customized and integrated
based access control (ABAC), allowing you to define user with external identity providers
permissions and access levels based on their roles or • Support for SSO via SAML and OIDC
attributes
• Mendix applies principle of least privilege granting no
access by default
Mendix App Security
The most secure low-code platform

Encryption Auditing & Logging

• Encrypt both at rest and in transit • OOTB detailed application and cloud logging
• Configure encryption on Application, Entity or Attribute • Auditing of user activities and events within the
level application
• Secure password management, including password • Capability to customise logging and auditing
hashing and salting • Bring your own Logging & Monitoring tooling
Component Based Architecture
Architect your business for real-time adaptability and future-proof resilience

Leverage our library Minimize Risk Deliver faster

Build and modify solutions with pre-built, Use built-in enterprise governance tools to Develop up to 10x faster with 70% fewer
reusable components available in the Mendix globally control component, applications, and resources using our pre-built, reusable
Marketplace. platform security. components.

Extend without limits Maintain consistency Adapt in real time

Adjust components and extend application Ensure that all components and solutions in Respond quickly to changing markets and
capabilities on our open and extensible your application portfolio are consistent and customer needs with low-code’s inherent speed
platform. secure. and agility.
04
Runtime
Architecture
Mendix Runtime at a glance

Client-side (Front-end)
MENDIX CLIENT
• Multi-channel client (Responsive, PWA, Native)
• Built in JavaScript (ReactJS), HTML5, CSS3
• Widgets and Core layer leverage open-source JavaScript frameworks:
ReactJS and React Native
• Widget source available on GitHub for customers CSS3 Web & Mobile HTML5

Runtime Server (Back-end) MENDIX RUNTIME

• Built in Java & Scala; abstracts all core programming functions
• Has its own built-in application server (Jetty)
• Completely stateless architecture; built for scale
Logic Layer

Database Client
• Every app has its own database: PostgreSQL, MySQL, Oracle, SQL Server,
DB2, SAP Hana, other SQL databases. Data Layer
• PostgreSQL DB used for Mendix Cloud
Client-side Experience
One platform for delivering across multiple modalities

Responsive Web PWA Native Mobile

Access: Browser Access: Browser & Installable web app Access: Installable as true native app
Capability: Limited access to device sensors Capability: UI is Web-based, but can access Capability: UI is native and can access
via HTML5 camera, GPS, etc. camera, GPS, etc. (no limitations)
Connectivity: Online only Connectivity: Offline & Online Connectivity: Offline & Online
Client-side Architecture

Capabilities: Responsive Native

• Web applications + PWA leverage ReactJS & PWA mobile apps

• Native mobile applications leverages ReactJS + React Native

Web Native
• Support for both offline & online scenarios (ReactJS) (ReactNative)

CLIENT
• Provide best in class experience with native controls HTTPS

Client Core
(ReactJS)
Customer Benefits:
• Consumer-grade user experience HTTPS

• Cross platform

SERVER
Runtime
• Increased productivity (Java/Scala)

• React Native used and backed by large community:

https://reactnative.dev/showcase
Client-side Architecture
Web Mobile
Widgets Widgets

UI component layer – manages the widget lifecycle

and communication between widgets, and provides UI Layer
Widget Lifecyle
Management
Widget
Communications
out-of-the-box widgets

Logic layer – handles data validations and more

Logic Layer Validation Nanoflows
complex logic using Mendix nanoflows

Data layer – manages the data used in the front-end;

based on the React Flux pattern to handle state and push Data Layer
Offline
Storage
Caching

changes to UI components

Communications layer – exchanges metadata, session

managements, and data with the Mendix Runtime server Communications
Widget Lifecyle
Management
Widget
Communication
while using a secure JSON over HTTPS protocol
Client-side Architecture
Multiple modalities sharing core components

Responsive Web PWA Native Mobile

BROWSER APP SHELL REACT NATIVE

HTML5 HTML5 JavaScript (JSX) bundle

ReactJS ReactJS Native Modules

Web APIs Web APIs

Device capability Device capability Device capability

Local Database (WASM SQLite) Local Database (SQLite)

Mendix Runtime
Mendix Client
Client Core
JavaScript
Actions

HTTPS
Widgets UI Layer
Server
Client Config

Data Layer
Platform APIs

Data API Object Cache

Offline Storage
Logic

State/Sync
/Session

Key
Data flow Runtime
Server
Runtime

External
Client-side Extensibility
Create experience that fits your need at every level

• Look & Feel customizable through the Atlas UI

Framework, extensible using SASS & CSS
▪ Customize in real-time within the IDE with WYSIWG editor
and built-in SASS compiler

Look and feel

Custom
Atlas UI SASS/CSS

• Page experience extensible with Custom

Pluggable Components

Experience
Page
▪ JavaScript based
Custom
Pluggable Widget

▪ React (Native)

• Nanoflow logic extensible with JavaScript Client Logic

Logic
Custom

actions
JavaScript action

▪ Full access to all client functionality

Anatomy of a PWA app

APP MANIFEST APPLICATION SHELL SERVICE WORKER

App Icons Hosts pages Offline logic

App Settings Device Experience Cache

HTML5 APIs
Server Runtime built for scale
Run mission critical workloads with ease

Built on proven technology

• Utilizes Java Runtime Environment (JRE) 17 or 21
• Scala leveraged for increased performance

Scalable & Agnostic

• Runtime is stateless so can scale on-demand
• Mendix runtime can run on any infrastructure

Model Execution
• Runtime interprets model definitions not code
• Simplifies updates and shortens downtime
Based on Trigger, Listener, Action model
Generic event driven model enabling easy extensibility

An action: A listener:
• Executes logic • Listens to actions
• Is exposed by: HTTP, SOAP, API • Triggers actions
• Base object for standard actions • Catches (before, during, after)
events
 Key

Runtime Architecture Deeper dive Runtime Component

App Model Component

• Full-Stack Platform Client Architecture (Simplified)

Page Nanoflow
Pages Nanoflow Engine Definition Model
Configuration

• Models are Interpreted Client Runtime Event Handler Action Handler

Pluggable
Widgets

User Action
Local Storage Event Subscriptions

• Standardized database interaction

(JavaScript)

• Microflow Execution Engine Runtime Architecture (Simplified)

HTTP Server
▪ Fully Event (Trigger, Listener) driven
REST SOAP ODATA
Client Interface
(Request Handler) (Request Handler) (Request Handler) Custom

• Communication with Client system through standard Request

Handler
(Java)
Page
Core Runtime
interfaces (MxClient, REST, SOAP, ODATA) Configuration

Microflow Workflow
Security
Security Agent Microflow Engine Definition Workflow Engine Definition
• Interpretive Client based on same principles Model
Model Model
Java
Code &
Libraries
Domain Model Event Handler Action Handler

• Project Model drives Domain, Events, Actions, Logic, Domain Model Definition Event Subscriptions User Action
(Java)

Pages, Security Data Storage Component

Model Interpreter
Query Manager Database
• Full-Stack Extendible through Java(Script) OData
Listener
MsSQL
Listener
Oracle
Listener
Synchronization Project Model
Runtime Server
Runtime Core

Temporary Object
Project Model File Storage Manager File Storage
Storage

M2EE
Database Ext Service Calls External Service
Synchronization

License
Scheduler Server

Relational Query Executor Object Manager Microflow Engine

Database

Custom Java

Mendix Client Custom Request

Ext Service Requests
API Handler

Key HTTPS Server

Data flow

Runtime

Mendix Client
External
Runtime Server Extensibility
Integration options at every level

• Prebuilt & supported modules for common

configuration
integrations via Marketplace

Marketplace

SHAREPOINT
ORACLE

module
OFFICE
SFDC
SAP

SAP
• Build your own modules and connectors for re-
use using connector kit
Connector
• Extend with custom Java code leveraging Eclipse

visual mapping
Java action

OData
SOAP

REST

JMS
Java action

SQL
or InteliJ

Connector Kit
• REST, SOAP, OData support with with visual
mapper for consuming and publishing Mendix Runtime

code
java plugin

java plugin

java plugin

java plugin

java plugin

java plugin

java plugin
• Pluggable Runtime Server
Container Architecture
Ensuring portability and simple provisioning
• Standard Container image, built from
deployment Model http(s)

OS Kernel
• Opensource build packs provided via
GitHub:
▪ Kubernetes Web server

▪ Cloud Foundry
▪ Docker Java Virtual Machine
Runtime
• Container includes: Container

Mendix service console / M2EE

Mendix Runtime
▪ Linux OS; Debian

Application management
▪ Nginx web server; Serving static content
▪ JVM Project model and code

▪ M2EE – Administrative Interface

• Leverages best practices and relies on File Storage Database Monitoring
separate container services for DB, file
storage and monitoring.
Mendix Deployment Process
Commit

Local via Studio Pro Platform Cloud Environment

Model meta
Runtime Engine data (BSON) Mendix Studio
Pro Teamserver (git) Web Server Runtime
Requests

Runtime (JRE)
Build
Server
Machine code

Runtime (JRE)

Machine code

Package
Repository

Infrastructure

Infrastructure
The Mendix Database
Choose the data storage solution that meets your needs

• Every Mendix app requires a database.

• Runtime creates the necessary SQL for queries,
updates, Inserts and deletes
• Support for a wide range of database types:
▪ MySQL
▪ PostgreSQL (Standard for Mendix Cloud)
▪ Oracle DB
▪ Microsoft SQL Server
▪ Azure SQL
▪ MariaDB
▪ SAP HANA

• Additional data can be connected to using the

Database Connector.
File/Object Storage

For container-based deployments Mendix supports the For server-based installations, the following storage types
following storage services: mounted by the OS are supported:
• AWS S3 • NAS
• Azure Blob Storage • SAN
• IBM Cloud Object Storage • GFS
• SAP AWS S3 Object Storage • Local Storage
• SAP Azure Blob Storage
• MinIO
Thank You
Contato:
José Luis Motta
CEO dtcode

+55 11 98747 5662

jose.motta@dtcode.com.br Ideias que se
transformam em
resultados.