Skip to content

Composable MES (cMES): Modular Manufacturing Architecture

Published Updated 25 min read

Learning path Step 3 of 4
Contents
  1. What Composable MES actually is and what it usually is not
  2. The MACH properties, precisely
  3. ISA-95 Level 3 and MESA-11: what cMES decomposes
  4. The shared canonical data model: the actually hard part
  5. The event-streaming backbone
  6. cMES vs. traditional MES: the comparison that matters
  7. Low-code / no-code: what it is actually doing
  8. The Composable-Washing problem: how to evaluate vendor claims
  9. Adoption paths: greenfield vs. brownfield
  10. How this fits into the SYMESTIC platform
  11. FAQ
By Mark Kobbert · Last updated: November 2026

What Composable MES actually is and what it usually is not

Composable MES (cMES) is a Manufacturing Execution System built as an orchestrated collection of independently deployable, API-addressable services rather than as a single monolithic application. A shared canonical data model binds the services into a coherent system. An event-streaming backbone carries state changes between them.

The specific architectural properties that make an MES genuinely composable, as opposed to modular, are usually summarised under the MACH acronym. Modular is a weaker and older concept. The acronym was coined by commercetools and institutionalised by the MACH Alliance in 2020: Microservices, API-first, Cloud-native, Headless.

A system that lacks any one of these four is not composable in the strong sense, however much its vendor's marketing insists otherwise.

The idea behind it is to treat enterprise software as a portfolio of interoperable capabilities rather than as a single seated system. Gartner analysts Yefim Natis and Gene Alvarez formalised it in their 2020 research note introducing the "Composable Enterprise". The note reframed the ERP/CRM/MES triad as an artefact of 1990s packaged-software economics rather than a feature of the work being automated.

The cMES concept is the manufacturing-domain application of that broader idea. It has converged with several concurrent architectural trends (cloud-native infrastructure, container orchestration, event-driven integration, the no-code movement) into the specific pattern that the industry is currently rallying around. Vendors differ in how honest they are about whether they really implement it.

The architecture is not the hard part. The MACH properties are engineering disciplines. They are important and well understood, and by 2026 they are effectively commodity patterns with mature tooling (Kubernetes, Kafka, OpenTelemetry, gRPC, REST, GraphQL, OAuth 2.1). A competent engineering team can build an API-first microservice architecture in months.

Two things take years: governing the shared data model, and operating a distributed system under the specific constraints of manufacturing. These constraints are real-time state, ISA-95 Level 3 semantics, event ordering, regulatory auditability, and the fact that downtime on the MES is downtime on the factory.

These two things separate working cMES implementations from the large population of systems that claim composability but produce chaos. This piece describes both dimensions.

The MACH properties, precisely

Each of the four MACH properties does different architectural work. To evaluate whether a specific system is actually composable or is a conventional monolith with better marketing, you need to understand what each property contributes and what architectural cost it imposes.

Property What it actually means What it costs
Microservices Each functional capability (order dispatching, downtime tracking, genealogy, quality, OEE calculation, alarm aggregation) runs as an independently deployable, independently scalable service with its own data store and its own release cadence. Distributed-system problems become first-class engineering work: eventual consistency, saga patterns for cross-service transactions, idempotency, deduplication, failure isolation, observability.
API-first Every capability is defined by its public contract (OpenAPI, AsyncAPI, gRPC IDL) before it has an implementation, and every internal component is accessible only through that contract: no backdoor database access, no shared in-memory state, no hidden coupling. API governance becomes a product-engineering discipline. Versioning, deprecation policies, backward compatibility guarantees, and API changelogs have to be owned by someone.
Cloud-native Designed from the start to run on cloud infrastructure using container orchestration (Kubernetes), managed services (databases, message brokers, observability), and horizontal scaling. This is distinct from "cloud-hosted", which is a monolith running in a VM in AWS. Operational complexity moves to the platform layer. Kubernetes expertise, SRE discipline, multi-region considerations, and cloud-cost-management become core competences.
Headless Business logic and data are decoupled from user interface. Any number of UIs (web dashboards, mobile, kiosks, AR headsets, voice interfaces, plain-text chat) can consume the same APIs without the backend caring. UI/UX has to be treated as a separate product with its own lifecycle, which is a different organisational muscle than traditional MES vendors have.

The single most common failure mode in the current cMES market is systems that claim three out of four properties and quietly fail on the fourth. Cloud-hosted monoliths that call themselves "cloud-native". Modular monoliths that call themselves "microservices" because their code is organised in directories. APIs that exist as secondary export layers rather than as the primary contract of the system.

These are not composable architectures. They are conventional architectures with composable vocabulary. The sector has a name for this practice: composable-washing.

ISA-95 Level 3 and MESA-11: what cMES decomposes

A legitimate cMES packages the functional frameworks that have defined MES for thirty years in a different way. The classical references remain the correct conceptual vocabulary for what an MES does: ISA-95 defines the activity model for Level 3, sitting between control systems at Level 2 and enterprise systems at Level 4, and MESA-11 is MESA International's original eleven-function model, updated over the years to the current "Strategic Initiatives Model".

cMES changes how the functions are deployed and integrated, not what they are. A useful mapping of the canonical MES functions to independently deployable microservices looks roughly as follows:

MESA/ISA-95 function Composable manifestation
Production operations management (dispatching, production tracking) Order-dispatching service; work-instruction service; SFC service. See SFC.
Quality operations management SPC service; inspection-plan service; hold/release service; deviation-management service. See predictive quality.
Maintenance operations management Asset-service; maintenance-order service; condition-monitoring service.
Inventory operations management WIP-location service; lot-tracking service; material-consumption posting service.
Performance analysis OEE-calculation service; downtime-classification service; analytics read-model service.
Genealogy & traceability Event-sourced genealogy service. See E2E traceability.
Document & change control Document-management service; change-control service; recipe-management service.

The mapping is not one-to-one. The art of composable architecture is deciding where the service boundaries actually run: which functions share a data store, which share only events, which must be strongly isolated because their update cadences are incompatible.

A useful heuristic when reviewing cMES designs: draw the data-ownership boundary first, then put the service boundary on the same line. Services that share a database are not really separate services; they are co-deployed modules in a shared monolith. Services that cross functional boundaries because "it's convenient" are accumulating the coupling that composability was supposed to eliminate.

The shared canonical data model: the actually hard part

The most important architectural decision in any cMES implementation is the shared canonical data model. Almost all composable-washing systems silently fail on it. The promise of composability, "add, replace, or remove modules without breaking the rest", is structurally impossible without a commitment to a canonical model. This model defines in precise terms what a work order, a material lot, a machine state event, a quality result, a personnel assignment, a tool, a shift, a plant, an operation, and a unit are. It needs versioned schemas, explicit semantic ownership, and governance over changes.

Without this canonical model, every new module added to the system produces its own local definitions of the same concepts, and the integration work between modules becomes point-to-point translation, exactly the N² integration problem that composability was supposed to solve.

The canonical data model has to live at a layer below the modules and above the individual service implementations. In the SYMESTIC architecture, the canonical model is expressed as a set of versioned JSON Schema definitions and AsyncAPI event contracts. It has explicit schema-evolution rules (additive changes are non-breaking and forward-compatible; removals and semantic changes require major version bumps and coexistence periods), ownership assigned to specific engineering teams for specific entity types, and an automated compatibility check that runs on every pull request against every service.

A plant's reality (orders branching into operations branching into lots branching into serials, with tools and operators and machines and quality and energy and maintenance weaving through) does not reduce to fewer concepts just because the implementation is composable.

Maintaining the canonical model over years is the single most expensive line item in running a cMES. This holds across teams, across acquisitions of vendor-built modules, and across changes in regulatory requirements. It is also the line item most consistently underinvested in by vendors that claim composability and by customers that buy it.

The symptom of underinvestment is always the same and always appears around the 18-month mark. Adding a new module has become more expensive than it was at launch rather than cheaper, integration work now dominates feature work, and the "composable" system has acquired all the rigidity of a monolith plus all the operational complexity of a distributed system.

This failure mode is an integration tax: the marginal cost of each new module grows superlinearly once the canonical model has drifted, because every integration now has to reconcile not just with the new module but with the accumulated inconsistencies of all prior modules.

The event-streaming backbone

Composable systems are integrated through events, not through direct service-to-service calls. A new quality result arrives as a QualityResultRecorded event on the event bus; whichever services care about quality results — the genealogy service to link the result to the unit, the SPC service to check control limits, the OEE service to update the quality factor, the alarm service to evaluate escalation rules — subscribe to the event stream and react. This pattern (event-driven architecture, event sourcing, CQRS — command/query responsibility segregation) is the standard distributed-systems answer to the coupling problem that direct request/response integration creates, and it is essentially mandatory for a genuine cMES at scale.

The concrete technology choices in 2026 are mature but not trivial. The event-streaming layer is typically Apache Kafka, Apache Pulsar, or a cloud-managed equivalent (AWS Kinesis, Azure Event Hubs, Google Pub/Sub). The schema layer is typically Confluent Schema Registry, AWS Glue Schema Registry, or an equivalent. This is where the AsyncAPI contracts live and where schema evolution is enforced.

The service layer runs on Kubernetes, either managed (EKS, AKS, GKE) or self-hosted. Containers are built from language-appropriate base images, deployed via GitOps pipelines (ArgoCD, Flux), and observed through the CNCF observability stack (OpenTelemetry for instrumentation, Prometheus for metrics, Jaeger or Tempo for distributed tracing, Grafana for visualisation).

The API gateway layer is typically Kong, Ambassador, Istio, or a cloud-native equivalent. It is the single enforced ingress to all services, where authentication, rate limiting, and API versioning are enforced.

None of this is exotic in 2026. The entire stack has been production-grade for five years. What is exotic is the specific application to manufacturing, because manufacturing imposes constraints that generic cloud-native patterns were not originally designed for.

The first is real-time ordering guarantees on events (a machine state change has to be sequenced correctly relative to the production-order events for the genealogy to be accurate). The second is millisecond-scale latency requirements (an SPC service that takes 500ms to evaluate a control limit will miss the response window for halting the line). The third is durable audit trails (regulated industries require proof that every event was processed and that the processing logic at the time of processing is reproducible). The fourth is failure semantics that have to map to physical plant behaviour (what happens to the production line if the OEE service is down for six hours is not the same question as what happens to a shopping-cart recommendation service being down).

The architectural patterns are commodity; the application of them to the manufacturing problem is still craft.

cMES vs. traditional MES: the comparison that matters

The comparison table that circulates in cMES marketing materials ("monolith vs. app toolkit, big bang vs. incremental, months vs. weeks") captures the vendor pitch but not the actual architectural distinction. The honest comparison is along three axes that matter to the people who have to operate the system for ten years:

Dimension Traditional MES Modular MES (intermediate) Composable MES (cMES)
Time to first value 6–18 months 3–9 months Days to weeks for first capability; incremental thereafter
Marginal cost of adding a capability (year 3+) High, requires platform-upgrade projects Medium, but grows over time as module-to-module integration debt accumulates Low and flat if the canonical data model is governed; explosive if not
Operational complexity at steady state Moderate: one big thing to run Moderate to high: several modules, each with its own operational profile High at the infrastructure layer; low at the feature layer if the platform is right
Upgrade risk Big-bang releases with high regression risk Module-level, but with cross-module compatibility concerns Per-service, continuous; compatibility enforced by contract
Vendor lock-in profile High and obvious High and hidden inside the module framework Theoretically low; practically depends on whether the APIs are genuinely open or vendor-framework-specific
Total cost of ownership (5-year) High and predictable Medium and variable depending on scope creep Lower if executed well; higher than traditional if executed badly. The variance is much wider

The comparison shows that cMES is a high-variance architectural choice. When it works, it works dramatically better than traditional MES: additions are cheap, evolution is continuous, individual plant customisations do not compromise the shared platform.

When it fails, it fails worse than traditional MES: operational complexity explodes, integration tax compounds, and the organisation ends up paying for the complexity of a distributed system without getting the benefits of composability.

The difference between the two outcomes is governance discipline, not technology choice, and the vendors that publish the most aggressive cMES marketing are frequently the ones least equipped to deliver the governance.

Low-code / no-code: what it is actually doing

Every modern cMES product ships with a low-code or no-code configuration layer that promises non-developer users (process engineers, quality managers, plant controllers) the ability to build and modify applications without writing code.

The promise is real and valuable, but the practice is more nuanced. Low-code moves the complexity of certain kinds of change from engineering teams to business users. This is beneficial for change velocity but dangerous without governance.

A typical failure mode in low-code-heavy cMES adoptions looks like this. Low-code builds accumulate in the system as a parallel track to engineered features. Nobody owns them at a platform level. They grow technical debt exactly like code does but without the same review and testing discipline. After 18–24 months the "low-code environment" becomes a tangle of interdependent configurations that nobody fully understands.

The low-code built by the quality team depends on a data structure defined by the operations team, which depends on a workflow configured by a consultant who has since left. When something breaks, and something always eventually breaks, the diagnosis is harder than it would have been with engineered code because the tooling for low-code debugging is immature.

The healthy pattern is harder to sell, but it is what actually works. Treat low-code as a product engineering discipline with its own lifecycle: version control for configurations, staging environments, code-review equivalents for significant changes, testing, documentation, ownership. Call it "citizen development" if that helps.

But the marketing promise of "no code means no governance" is false, and plants that believe it accumulate low-code governance debt: configuration complexity that grew without discipline and that eventually has to be paid down under worse conditions than it was accumulated.

Lift-and-shift means taking an existing monolith, putting it in a container and running it in the cloud. It is the faster path to saying "we're in the cloud", but it is operationally worse than the original on-premise product. It inherits all the monolithic constraints (coordinated releases, shared database bottlenecks, no horizontal scaling, brittle upgrade paths) while also paying the cloud tax (network latency, multi-tenancy isolation concerns, cost variability, dependency on cloud-vendor reliability).

The benefits of cloud (elastic scaling, per-service release cadences, resilience, managed-service leverage) require being cloud-native: microservices, event-driven integration, stateless service design, infrastructure-as-code, observability-first engineering and a shared canonical data model governed at platform level.

IaaS-hosted monoliths sold as "cloud-native" show a typical signature: customer onboarding takes months rather than days because every customer gets their own instance; features cannot be rolled out selectively; customer data is either shared across tenants (security problem) or duplicated (cost and complexity problem).

Three questions reveal which category a vendor is in before committing: how many microservices does the platform run in production, what is the event bus (an API alone points to a monolith; Kafka, Event Hubs or Pulsar with a schema registry points to the real thing), and how is cross-service consistency handled (distributed transactions point to a monolith in disguise; sagas and eventual consistency point to engineers who have built one). The answers are rarely in the marketing deck. They are in the technical deep-dive that a serious evaluation requires.

The Composable-Washing problem: how to evaluate vendor claims

Given the value the market is assigning to the word "composable" in 2026, the supply of composable-badged products has massively exceeded the supply of actually composable architectures. Evaluating vendor claims requires looking past the marketing vocabulary to the architectural facts. The three diagnostic questions from the amber above generalise into a broader evaluation framework:

Claim Composable-washing signal Genuine cMES signal
"Microservices architecture" Vendor counts modules, not services. Single shared database. Cannot deploy services independently. Dozens to hundreds of services in production, each with its own data store, each independently deployable, evidence of per-service release cadences.
"API-first" API is a secondary export layer on top of a monolithic data model. API documentation generated from the code. Published OpenAPI/AsyncAPI specifications, semantic versioning, public changelogs, evidence that APIs predate the implementation.
"Cloud-native" System runs in a VM in the cloud. Customer gets their own instance. Upgrades are scheduled maintenance windows. Multi-tenant by design, containerised, Kubernetes-orchestrated, auto-scaling, managed-service-heavy, continuous deployment.
"Event-driven" System emits "notifications" through webhooks. No durable event log, no event sourcing, no replayability. Named event-streaming technology (Kafka, Pulsar, Event Hubs), schema registry, event replay capabilities, audit-grade durability.
"Shared data model" Vendor can show you a database schema. No version history, no governance process. Versioned schemas with evolution rules, ownership assigned, breaking-change governance, automated compatibility checks in CI.

None of the "genuine" signals above require taking the vendor's word. They are all verifiable through a technical diligence conversation with the vendor's engineering team. Serious evaluation processes should include this conversation, and it consistently separates architectures that will work in production from those that will not.

A vendor that refuses or cannot accommodate a 45-minute technical architecture review with customer-side engineering is almost always a vendor whose architecture would not survive the review.

Adoption paths: greenfield vs. brownfield

Composable MES is adopted through two very different pathways, and choosing the wrong one for the situation is a frequent cause of failed programmes.

Greenfield adoption is available to organisations that are building a new plant from scratch or that have no meaningful existing MES footprint and are starting fresh. This is the easier pathway. A cMES platform is selected, configured, populated with the canonical model for the first production areas, connected to the ERP and to machines, and rolled out to additional areas incrementally.

The first capability typically goes live in days to weeks (performance metrics, OEE dashboard); the second and third in further weeks; full coverage in months. Greenfield cMES adoptions have the highest success rate because they avoid the hardest problem of all, which is legacy integration.

Brownfield adoption is what most plants actually face. They have a pre-existing MES (typically monolithic, often built in the 2000s or 2010s, often deeply customised, often running on hardware that should have been retired years ago), integrations to ERPs and other enterprise systems that are working but fragile, operator workflows that have been built around the current system's specific behaviour, and regulatory or customer-compliance dependencies on the current system's output formats.

Moving from this state to cMES is a multi-year architectural migration rather than a deployment project, and the strategy matters enormously. The two viable patterns are:

  1. Strangler-fig migration. New capabilities are built on the cMES platform, with bidirectional integration back to the legacy MES for the functions that have not yet migrated. Over 18–36 months, functions are moved from legacy to cMES one at a time. The legacy MES shrinks at each step until it can be retired. This is the lower-risk path but requires strong integration engineering.
  2. Parallel-run cutover. The cMES is implemented in parallel to the legacy MES for a single plant or production area, both systems run simultaneously for a validation period (typically 2–6 months), results are reconciled, and the legacy MES is retired when the cMES is proven. This is the higher-risk path but can be faster for well-defined scopes.

The pattern that consistently fails is the "forklift upgrade", which means turning off the legacy MES on a scheduled weekend and turning on the cMES. It has the same failure dynamics as any big-bang system replacement and is the reason so many MES modernisations end badly.

How this fits into the SYMESTIC platform

SYMESTIC is a genuinely cloud-native, microservice-architected, API-first, event-driven MES platform, built from the ground up around the patterns described in this piece. It is not retrofit from a monolith, not module-organised, not cloud-hosted in the degraded sense. The platform is cloud-native on Microsoft Azure, multi-tenant, with EU data residency.

Customer onboarding typically completes in days because new tenants are provisioned into the existing multi-tenant infrastructure rather than instantiated as new systems; new capabilities arrive continuously rather than on quarterly release trains; and per-customer customisations are handled through a governed low-code layer that shares the canonical data model rather than forking it.

The service catalogue maps directly onto the MESA-11 and ISA-95 functional models described above: production metrics, production control, production planning, alarms, and process data are each bundle presentations of clusters of underlying services, not distinct modules.

For customers starting greenfield, the platform is typically productive on the first capability in under two weeks. For customers with existing MES footprints, SYMESTIC supports both strangler-fig and parallel-run migration patterns through its API and event-streaming integration surfaces.

See also process documentation for the ISA-95 modelling baseline, industrial data historian for the time-series backbone that complements the event-streaming layer, E2E traceability and change control for two of the capability domains that most benefit from a composable architecture, alarm management for the event-subscription patterns applied to plant-floor signals, and A3 problem solving for the discipline that makes use of all the data the platform surfaces.

FAQ

What is Composable MES?

A Manufacturing Execution System built as an orchestrated collection of independently deployable, API-addressable services rather than as a monolithic application, with a shared canonical data model binding the services together and an event-streaming backbone carrying state changes between them. The architectural properties are usually summarised under the MACH acronym: Microservices, API-first, Cloud-native, Headless.

What is MACH architecture?

MACH stands for Microservices, API-first, Cloud-native, Headless. These are four architectural properties that together define composable systems. The term was coined by commercetools in 2020 and institutionalised by the MACH Alliance. A system that lacks any one of the four properties is not composable in the strong sense, regardless of marketing claims. MACH names the architectural properties of cMES, the manufacturing-domain application of Gartner's 2020 "Composable Enterprise" concept.

How does Composable MES differ from modular MES?

Modular MES refers to a monolithic system organised into logically separated modules that share a database and a deployment lifecycle. Composable MES refers to genuinely independent services with separate data stores, separate deployment lifecycles, and integration through APIs and events rather than through shared state. The difference is architectural. Most systems marketed as "composable" in 2026 are actually modular. This failure mode is called composable-washing.

What is the shared canonical data model and why does it matter?

The canonical data model is the versioned set of entity and event definitions that all services in a composable MES agree on: what a work order is, what a unit is, what a quality result is, in precise terms with explicit ownership and evolution rules. It is the single most consequential architectural element in cMES because without it, each new service develops its own local definitions of shared concepts and the system degenerates into the same point-to-point integration nightmare that composability was supposed to eliminate. The canonical model is also the most expensive and most consistently underinvested part of cMES operation.

What is The Integration Tax?

The pattern in which the marginal cost of adding each new module to a composable system grows superlinearly over time because the canonical data model has drifted and every new integration has to reconcile not just with the new module but with the accumulated inconsistencies of all prior modules. Plants that do not invest in canonical-model governance typically hit this failure around the 18-month mark after initial rollout, at which point adding capabilities becomes more expensive than it was at launch rather than cheaper.

What is Composable-Washing?

The practice of marketing modular-monolithic or cloud-hosted systems as "composable MES" without delivering the underlying architectural properties (genuine microservices, API-first contracts, cloud-native deployment, event-driven integration, governed canonical data model). Common in the 2025–2026 MES market as the term "composable" acquires premium pricing power. Diagnosable through specific technical-diligence questions: how many services are in production, what is the event bus, how is cross-service consistency handled.

What technology stack does a real cMES use?

In 2026, the mainstream stack is: Kubernetes (managed via AKS, EKS, or GKE) for container orchestration; Apache Kafka, Apache Pulsar, or a cloud-managed equivalent (Azure Event Hubs, AWS Kinesis) for event streaming; a schema registry (Confluent, AWS Glue, or equivalent) for canonical-model governance; OpenTelemetry + Prometheus + Grafana + Jaeger for observability; OpenAPI and AsyncAPI for contract definition; an API gateway (Kong, Ambassador, Istio) for ingress control; and GitOps pipelines (ArgoCD, Flux) for deployment. None of this is exotic in 2026. The complexity is in applying the technology correctly to the manufacturing problem, not in the technology choices.

How is cMES adopted in brownfield plants?

Two viable patterns: strangler-fig migration (new capabilities are built on the cMES platform with bidirectional integration to the legacy MES, and functions are moved one at a time over 18–36 months until the legacy can be retired) and parallel-run cutover (cMES is implemented in parallel for a single plant or area, both systems run simultaneously for a validation period, and the legacy is retired once cMES is proven).

Forklift replacement (turning off legacy and turning on cMES on a scheduled weekend) fails with the same dynamics as any big-bang system replacement and should be avoided.

What role does low-code play in cMES?

Low-code/no-code configuration layers let non-developer users build and modify applications without writing code, which is valuable for change velocity but dangerous without governance. The healthy pattern treats low-code as a product engineering discipline, with version control, staging, code-review equivalents, testing, and ownership, rather than as an unmanaged "citizen development" playground. Plants that treat low-code as ungoverned accumulate Low-Code Governance Debt that eventually has to be paid down under worse conditions.

Does cMES replace ISA-95 or MESA-11?

No. cMES changes how the MES functions are packaged, deployed, and integrated, not what they are. The classical ISA-95 Level 3 activity model and the MESA-11 (now MESA Strategic Initiatives) functional model remain the correct conceptual vocabulary for MES capabilities. cMES is the architectural answer to the question "how should these functions be implemented in 2026?" rather than a rejection of the question itself.


Related: MES: definition, functions & benefits · OEE: definition, calculation & practice · MES software compared · OEE software · Process documentation (ISA-95 baseline) · Alarm management · Shop floor control (SFC) · Predictive quality · Schedule adherence · On-Time Delivery · Rolled Throughput Yield · Scrap rate vs. rework rate · Industrial data historian · Recipe management · Change control · A3 problem solving · E2E traceability · MDE (machine data acquisition) · BDE (production data acquisition) · Production metrics module · Production control module · Production planning module · Alarms module · Process data module · Automotive · Metal processing · Food & beverage · For COOs & plant managers · For operational excellence. External references: MACH Alliance (industry body for MACH architecture, founded 2020) · Gartner Composable Business research (origin of the Composable Enterprise concept) · ISA-95 standard committee (Level 3 activity model for MES functions) · MESA International (MESA-11 / Strategic Initiatives functional framework) · Cloud Native Computing Foundation (stewards of Kubernetes, Prometheus, OpenTelemetry, Jaeger and most of the cloud-native stack referenced in this piece).

Live demo30 minutes · free

See a cloud MES you can extend step by step

In a live demo we show how you start with machine connection and add process data, alarms and workflows when you need them.

In use in over 20 countriesYanfengNidecCarcoustics

Potential analysis30 minutes · free

Your losses in euros, calculated with your figures

In a free 30-minute potential analysis we go through downtime, changeovers and scrap with you and turn the losses into euros using your own figures. No software demo.

In use in over 20 countriesYanfengNidecCarcoustics

About the author

CTO · SYMESTIC

Responsible since 2014 for the architecture of the cloud MES platform on Microsoft Azure, from machine connectivity to real-time data processing. B.Sc. in business informatics.

  • Cloud-native MES Architecture
  • Microsoft Azure
  • Microservice Architecture
  • OPC UA

Updated