OpenTelemetery meets Event Driven Architecture

Picture this: you have an event that gets fired into the abyss of an event broker in your microservice architecture. The event broker routes the event according to multiple rules, distributes multiple copies to different consumers and persists the event until it’s acknowledged. You might be wondering: how can I observe this event through the organization from event creation to its ultimate destination(s)--including all the opaque hops it took in the event broker?

Event-driven architecture (EDA) is all around us, and we may interact with EDA-based systems daily without even knowing it. It is the architectural backbone of many retail banks, capital markets, e-commerce platforms, and airlines. With hundreds, and even thousands, of applications and microservices connected to an event broker, it can be challenging to retrofit tracing and answer questions like “Where are the events going in the event broker?”, “Are the expected events being published?”, and the infamous “Are consumers throwing away events?”

Attend this talk to learn more about:

- What Event-driven architecture is all about
- Where OpenTelemetry and true end-to-end observability fits in the EDA between applications, APIs and event brokers
- How to approach observability implementation in messaging protocols including MQTT, AMQP, Kafka and other industry used event brokers

The ABC’s of Cloud Agnostic With Event Driven Architecture

Event-driven architecture (EDA) is crucial in various business and applications, including bus schedules, ride ordering, and social media platforms - to name a few.

In simple terms, EDA is made up of event producers, consumers, and a message broker to route messages. However, implementing EDA poses challenges around scalability, latency, and geographical distribution.

Cloud deployments address these issues by handling traffic spikes and reducing hardware costs. Additionally, cloud agnostic approaches enable standardized communication between services on different cloud providers.

This introductory talk provides an introductory overview of EDA, emphasizes the importance of cloud deployments, and explores the benefits of cloud agnosticism, aiming to spark curiosity in EDA and cloud technologies.

Using OpenTelemetry to look into the event broker “black box”

Picture this: you have an event that gets fired into the abyss of an event broker in your microservice architecture. The event broker routes the event according to multiple rules, distributes multiple copies to different consumers and persists the event until it’s acknowledged. You might be wondering: how can I observe this event through the organization from event creation to its ultimate destination(s)--including all the opaque hops it took in the event broker?

Event-driven architecture (EDA) is all around us, and we may interact with EDA-based systems daily without even knowing it. It is the architectural backbone of many retail banks, capital markets, e-commerce platforms, and airlines. With hundreds, and even thousands, of applications and microservices connected to an event broker, it can be challenging to retrofit tracing and answer questions like “Where are the events going in the event broker?”, “Are the expected events being published?”, and the infamous “Are consumers throwing away events?”

Attend this talk to learn more about:

- What Event-driven architecture is all about

- Where OpenTelemetry and true end-to-end observability fits in the EDA between applications, APIs and event brokers

- Challenges with current observability implementation in messaging protocols including MQTT, AMQP, Kafka and other industry used event brokers

Using OpenTelemetry to Observe Real-Time Event Driven Architecture

Event-driven architecture (EDA) is widely used in industries like retail banking, capital markets, e-commerce, and airlines. However, integrating end-to-end tracing and observability into an EDA system is difficult due to the multitude of microservices connected to the event broker. Questions arise about event sources, destinations, failed messages, and message queues within the broker - to name a few. Effective troubleshooting requires distinct traces and span links between producers, consumers, and the broker itself

In their talk, developer advocates Tamimi and Henrik delve into EDA system development and the challenges and advantages of observability in EDA. They explore how advanced observability backends can trace all events in an EDA and highlight the impact of the OpenTelemetry community on improving messaging observability. Attendees will gain insights into achieving comprehensive observability in EDA systems, enabling enhanced understanding and troubleshooting capabilities.

Why Data Integration Defeats Model Selection: The 80/20 Reality of Agentic AI

The agentic AI landscape is saturated with PoCs and demos composed of sophisticated LLMs and, autonomous agents, and complex workflows that promise to change how enterprises work. Yet, organizations are confronted with an uncomfortable truth that reshapes their implementation strategy.

Thats where the 80/20 reality comes to surface: while 20% of the effort involves AI model selection and agent design, the remaining 80% is a data integration problem that determines whether your agentic system becomes business-critical infrastructure or remains an experimental lab test.

This session presents an architects guide to designing agentic systems that bridges technical architecture and business strategy. Rather than starting with agent capabilities and retrofitting integration afterward, successful deployments begin by treating agentic AI as fundamentally an integration challenge from day one. Attendees will walk away with
- A practical architectural pattern that establishes an event-driven architecture infrastructure before selecting your first agent framework
- How to treat orchestration as a first-class citizen where collective reasoning and coordinated decision-making become the primary value drivers.
- Non negotiable enterprise pillars: infrastructure, governance, compliance, observability, and security
- Practical examples of cross-system coordination

Whether you're an engineer designing multi-agent systems or a technical leader planning enterprise AI adoption, you'll leave with a pragmatic framework for navigating the 80% problem that determines whether agentic AI delivers measurable business impact.

From Design to Postman Collections using AsyncAPI

Imagine a world where you can design your event-driven architecture in an event portal that catalogues and governs your system’s schemas, events, and applications; auto generates AsyncAPI spec files that defines every application; and automagically generates Postman collections that model the interactions between microservices in your overall EDA system. That would be living the dream. Well, Developer Advocate Tamimi is going to show you that your dream is now a reality with PubSub+ Event Portal.

In this talk, Tamimi will showcase how AsyncAPI spec files can be auto-generated from PubSub+ Event Portal, then using a converter, generate Postman Collections and how setting up a Postman mock server can show you the flow of events over a REST port on PubSub+ Event Broker.

Attendees will leave the talk with the knowledge of:

- The basics of Postman collections and Postman mock servers
- Generating Postman artifacts from an AsyncAPI spec file
- Solace PubSub+ Event Broker protocol translation

Event-Driven Architecture: Design to Code using Event Portal + AsyncAPI Code Generation

In this workshop, attendees will get exposure to what event-driven architectures are and the different challenges associated with designing and building EDA.

During the workshop, we will be using a real-world use case of streams of data from NYC Taxis and show how we can design, document, discover, catalog and visualize events using Solace PubSub+ Event Portal. Attendees will also learn about the AsyncAPI Initiative and the code generators associated with it to better enhance the developer experience when dealing with asynchronous APIs.

Key technologies and tools used in the workshop:
1. Solace PubSub+ Event Portal
2. AsyncAPI Specification
3. Spring Cloud Streams framework
4. Java
5. Python

Distributed Monolith - allthetalks.online

In this remote conference, I will be talking about the evolution of monolith to distributed monolith and how event-driven architectures are the new species of the future

Containers and distributed systems track/

Building the 80%: Architecting Agentic AI with Event-Driven Design and Solace Agent Mesh

In today’s enterprise AI landscape, the lion’s share of effort (≈ 80 %) is not in tweaking the latest large language model, but in integration, orchestration and real-time data movement across systems. Meanwhile, only about 20% of the challenge sits in the model itself. This shift means that as we move from monolithic AI tools to truly autonomous, multi-agent systems, the architecture behind agentic AI matters more than ever.

In this talk, we will explore how the evolution from classic workflow automation to agentic AI systems demands a foundation built on event-driven architecture. Drawing on the lessons of the microservices era — where synchronous, point-to-point calls created brittle systems — we’ll see how EDA decouples agents, enables asynchronous coordination, and builds resilience at scale.

By the end of this workshop you’ll have:

A clear framework for when traditional workflow automation makes sense vs. when you should move to agentic, event-driven orchestration.

Practical understanding of how Solace Agent Mesh implements this architecture: event mesh, orchestrator, agents, gateways, data management, and observability.

Insight into how to focus 80% of your time on integration, event-driven design and data flows — not just the 20% of model fine-tuning — to make agentic AI production ready.

Actionable take-aways on how to design, implement and scale event-driven agentic workflows in your own organisation.

Event-Driven Microservices made easy with AsyncAPI and Spring Cloud Stream

Event-driven architecture (EDA) is on the rise more than ever before. There are alot of considerations to be taken into account before building event-driven real-time applications such as documentation, code generation, governance, and API definitions to name a few. REST APIs has OpenAPI and tooling around it to better enhance using and adopting a synchronous RESTful architecture, but what about asynchronous Event APIs?

The AsyncAPI specification allows developers to define event-driven applications, while the Spring Cloud Stream framework allows for easier implementation of Event-Driven microservices. In this talk, we will show how these two technologies make a power couple helping developers go from Design to Code in a swift swing and how messaging APIs and protocols including but not limited to: RabbitMQ, Kafka, and Solace PubSub+, are abstracted using the Spring Cloud Stream Binders.

This talk will also include a live hands-on demo using Java, Spring Cloud Stream binder for Solace, and the AsyncAPI java-spring-cloud-stream-template.

Living the Cloud-Agnostic Dream with Event Driven Architecture

Event-driven architecture (EDA) is all around us, and we may interact with EDA-based systems daily without even knowing it. It is the architectural backbone of many retail banks, capital markets, e-commerce platforms, airlines, and large CPGs.

Many organizations are leaning towards cloud-based solutions to keep up with the high volume of data movement, to combat siloed application interactions and deployments, and to achieve the desired system scalability. However, many companies are faced with common challenges that come with a multi-cloud deployment of event-driven architecture systems.

In this talk, Solace Developer Advocate Tamimi will give a high-level overview of event-driven architecture, review some real-world use cases, and delve into the importance of taking a cloud-agnostic approach to EDA. To wrap up, Tamimi will demonstrate how events can dynamically flow in a multi-cloud EDA solution that values cloud-agnostic data flow as a first-class citizen.

Attendees will leave this session with an understanding of:

- What an advanced event broker is and how it makes up the central nervous system for real-time data movement.

- Cloud-native solutions to EDA deployment and the vendor lock-in challenges associated with them.

- The power of an event mesh, an architecture layer that allows events to flow freely between applications no matter where they are deployed (on-premise, private cloud, public cloud).

Living the Cloud-Agnostic Dream with Event Driven Architecture

Event-driven architecture (EDA) is all around us, and we may interact with EDA-based systems daily without even knowing it. It is the architectural backbone of many retail banks, capital markets, e-commerce platforms, airlines, and large CPGs.

Many organizations are leaning towards cloud-based solutions to keep up with the high volume of data movement, to combat siloed application interactions and deployments, and to achieve the desired system scalability. However, many companies are faced with common challenges that come with a multi-cloud deployment of event-driven architecture systems.

In this talk, Solace Developer Advocate Tamimi will give a high-level overview of event-driven architecture, review some real-world use cases, and delve into the importance of taking a cloud-agnostic approach to EDA. To wrap up, Tamimi will demonstrate how events can dynamically flow in a multi-cloud EDA solution that values cloud-agnostic data flow as a first-class citizen.

Attendees will leave this session with an understanding of:

What an advanced event broker is and how it makes up the central nervous system for real-time data movement.

Cloud-native solutions to EDA deployment and the vendor lock-in challenges associated with them.

The power of an event mesh, an architecture layer that allows events to flow freely between applications no matter where they are deployed (on-premise, private cloud, public cloud).

Liberating Asynchronous APIs as Event API Products

Synchronous application interactions are easily defined and shared via REST APIs. These APIs have access to standards (OpenAPI specifications to define REST APIs) and tooling (Swagger for code generation or mocking) that facilitate better usage, consumption, and sharing.

The tooling around asynchronous interactions continues to improve with the AsyncAPI specification and the new concept of event API products. Event API products are like regular API products, but use real-time data instead of data at rest to provide value to both internal and external developers.

This talk will focus on how events – any “change of state” – can provide greater value out of existing information by taking advantage of standards and tooling that make it easier to manage, catalog, visualize, and share between teams. Other benefits of exposing events as event API products include secured access and easier governance.

Join us to learn the importance of event API products and how tools and standards like PubSub+ Event Portal and AsyncAPI can facilitate the adoption of event-driven architecture in any enterprise

Design, Document, Discover, and Develop Event-Driven APIs

More and more organizations are adopting event-driven architecture (EDA) in their operations. In this workshop, we'll build and expand your toolbox by learning how PubSub+ Event Portal, paired with industry standard specifications and frameworks, enables a smooth journey to bring your EDA from initial architecture and design to code running in production. We will also cover AsyncAPI, an open initiative for defining asynchronous APIs and all the tooling around this specification, including code generation

Developing Asynchronous APIs for the Event-Driven World Using Spring Cloud Stream, AsyncAPI, and an

Are you passionate about building modern, real-time applications? Is your organization adopting an event-driven architecture (EDA) to compete in our event-driven world? Build and expand your developer toolbox by learning how to define asynchronous APIs, implement them using Spring Cloud Stream microservices, and globally distribute them across multi-cloud and on-premises environments using an event mesh.

Spring Cloud Stream is a framework for building highly scalable, event-driven microservices connected with shared messaging systems. AsyncAPI is the industry standard for defining asynchronous APIs, providing a specification and tooling such as code generation. An event mesh is a configurable and dynamic infrastructure layer for distributing events among decoupled applications, cloud services, and devices.

In this hands-on workshop, attendees will be guided through a step-by-step tutorial where they’ll do the following:

- Learn how to define asynchronous APIs.
- Use the AsyncAPI Generator template for Spring Cloud Stream.
- Develop event-driven microservices using Spring Cloud Stream and Java.
- Connect your microservices to an event mesh made of PubSub+ Event Brokers and stream events across the globe!