Event Driven Architecture, Message Events and WASM on Kubernetes
EDA is the backbone
Event Driven Architecture (EDA) is increasingly the backbone of modern IT landscapes. Applications are no longer isolated systems that operate in silos. They need to react instantly to business events: a payment confirmation, a new sales order, a change in stock levels, or an HR update from AFAS. EDA is the design pattern that allows these events to flow across your application landscape in real time, making your business more responsive and agile.
At the center of EDA are message events. They represent “something happened” in a system and are published so that one or more subscribers can react. An order event from your e-commerce system may trigger your ERP to reserve inventory, your CRM to update customer activity, and your finance application to generate an invoice. This decoupling of systems creates flexibility because applications don’t directly call each other but instead respond to published events. Publishers and subscribers can evolve independently, which makes your integration landscape far more scalable and maintainable in the long run.
Why Solace is a strong foundation for EDA
To make this architecture work in practice, you need an event broker that guarantees reliable, fast, and structured event distribution. Solace is one of the leading technologies in this space, offering guaranteed delivery, extremely high throughput, and flexible routing through topics, queues, and an event mesh. It can handle millions of events per second without losing control or visibility.
With Solace, you can create an event mesh that spans your entire ecosystem, connecting on-premises systems, SaaS applications, cloud services, and even edge devices. Events can move seamlessly between environments without custom connectors or heavy middleware. This allows you to design an event-driven backbone where any application can publish an event once, and all interested consumers can subscribe without complex configuration.
The integration challenge
Although Solace and EDA solve the communication problem, integration itself remains a challenge. Every application still speaks its own data language and has its own view of the world. For example, your ERP may publish a “SalesOrderCreated” event, but your CRM requires additional customer data, different field names, or even a different data format. The raw event does not always match the consumer’s requirements.
Traditionally, you would solve this by creating microservices on Kubernetes or building transformations inside a central Integration Platform. While effective, these services often become too large, slow to deploy, and complex to maintain. Each small change requires redeployment of a container or a central flow, which slows down your ability to respond to business needs.
WASM as lightweight integration services
WebAssembly (WASM) changes the way you think about integration. With WASM you can compile code from languages like Rust, Go, or C# into secure, portable modules that run with near-native performance. These modules execute inside a runtime on Kubernetes, right next to your event broker or Integration Platform, and handle only the logic they are built for.
The power of WASM lies in its simplicity. A WASM module is small, isolated, and starts up in milliseconds. It is portable across environments, so the same logic runs on any cloud or on the edge. It doesn’t interfere with other workloads, making it safe to deploy even in shared environments. For integration tasks like transformations, validations, or enrichments, WASM modules provide a lightweight alternative to full-blown microservices.
Example: Solace, Kubernetes, and WASM working together
Imagine Solace running as your event broker on Kubernetes. Your ERP publishes a SalesOrderCreated event. Before this event can be processed by your CRM, it needs to be enriched and transformed. Field names must be aligned, currencies converted, and customer data pulled from a master data service.
Instead of building a containerized microservice for this, you deploy a WASM module that subscribes to the event from Solace, executes the necessary transformation, and republishes the enriched event back to the broker. The CRM then consumes the event in the correct format, without even knowing the ERP system’s original structure. This setup creates a lightweight integration flow that is easy to change and scale. Because WASM modules are independent, you can update or replace the transformation logic without touching your Integration Platform or other microservices.
Scaling and managing WASM services on Kubernetes
On Kubernetes, WASM workloads can be managed like containers but with much less overhead. Using runtimes like wasmtime, Spin, or Krustlet, you can run WASM modules natively as Kubernetes workloads. They benefit from Kubernetes features such as autoscaling, rolling updates, and centralized monitoring, but without the heavy startup times and large resource consumption of containers.
This means your WASM integration services scale instantly when event load increases and restart in milliseconds if they fail. Logs and metrics integrate into your existing observability stack, giving you the same insights you expect from other workloads. Security is built-in, since WASM modules run in isolation and cannot access the host system directly. For integration scenarios, this creates a highly resilient and low-risk runtime model.
Why this matters for integration landscapes
Traditional integration approaches, such as nightly ETL jobs, ESBs, or large iPaaS flows, are too heavy for modern real-time environments. They add latency, require complex orchestration, and struggle with the volume of events generated by today’s systems. EDA requires integration services that are lightweight, fast, and scalable.
With Solace providing the event mesh, Kubernetes orchestrating your workloads, and WASM running your micro-integration services, you get exactly that. You can react to events in real time, deploy highly focused services that are easy to update, and scale them horizontally across your cluster. Transformations and rules are applied close to the data, ensuring minimal latency and maximum flexibility. This approach doesn’t replace your Integration Platform but extends it, making it faster and more distributed.
Conclusion
Event Driven Architecture ensures your applications communicate in real time, while Solace provides the event mesh that distributes messages reliably and at scale. WASM adds agility to the equation by allowing you to run small, secure, and extremely fast services directly on Kubernetes. Together, these technologies create a modern integration approach that is distributed, lightweight, and ready to support future growth.
If you are designing your next-generation integration landscape, don’t only think in APIs or containerized microservices. Consider the power of WASM-powered event integration services alongside Solace and Kubernetes. It’s a flexible, scalable, and future-proof way to connect your application systems and unlock the full potential of an event-driven enterprise.
Interested in discussing this further? I’d be happy to connect.
