From Spec to Simulation: Solace Event Feeds Bring AsyncAPI to Life

Creating realistic test data for event-driven applications is notoriously difficult. Developers often spend hours scripting mock data or manually generating events, only to end up with oversimplified payloads that fail to capture the complexity of production systems. This slows down development, hinders testing, and makes stakeholder demos less compelling.

Solace Event Feeds change that. Delivered via the stm CLI and feeds.solace.dev, Event Feeds let you simulate rich, production-like event streams with zero custom code. Whether you’re building, testing, or demonstrating event-driven systems, they give you a fast, flexible way to work with realistic, domain-specific data — all based on open AsyncAPI specifications.

Understanding Solace Event Feeds

At its core, Solace Event Feeds are pre-configured definitions of event streams designed to simulate real-world data flows. Each feed is grounded in AsyncAPI specifications, which describe the structure of events, topic hierarchies, and payload formats. What makes Event Feeds powerful is how they extend these specifications with:

• Data generation rules that produce realistic and varied content
• Publishing patterns that reflect real-world frequency and burstiness
• Topic structures that align with actual business domains
• Flexible configuration options to adapt simulations to different scenarios

This blend of structured definitions and dynamic generation allows developers, architects, and field engineers to spin up production-like event streams — without writing a single line of code.

The concept is elegantly simple: define once, reuse everywhere. By capturing domain-specific event patterns in reusable definitions, Event Feeds make that expertise portable and shareable across the Solace community.

The Power of Community Contribution

One of the most valuable aspects of Solace Event Feeds is its community-driven foundation. The solace-event-feeds Github repository serves as a central hub where practitioners across industries contribute domain-specific feeds — accelerating collaboration and reuse.

This collaborative model brings several key advantages:

• Diversity of Domain Expertise: No single team can master every industry’s event patterns. By inviting contributions from experts in finance, retail, logistics, IoT, and beyond, the feed collection grows not just in volume — but in authenticity and relevance.
• Elimination of Redundant Effort: Without shared feeds, every team would need to recreate common event patterns from scratch. Community-contributed feeds prevent reinvention, letting teams build on existing work and focus on what’s unique to their solution.
• Continuous Improvement: As feeds are adopted and adapted in different environments, contributors often enhance them — adding edge cases, tweaking configurations, and improving realism. This cycle of use and refinement makes the ecosystem stronger over time.
• Accelerated Knowledge Transfer: For developers new to a domain, contributed feeds act as living documentation — illustrating real-world event structures, payloads, and topic hierarchies. This speeds up onboarding and promotes consistency in event-driven application design.

Exploring feeds.solace.dev

While the feeds repository provides the technical foundation, the feeds.solace.dev web application makes these feeds accessible to users.

Browsing Available Feeds

The web application presents a catalog of available feeds, organized by domain and use case. Each feed includes:

• A description of the business scenario it represents
• Details of the event types and structures
• Configuration options for customizing the simulation
• Information about the expected volume and frequency of events

This catalog makes it easy to find feeds relevant to specific needs without diving into repository code.

Connecting to a Solace Broker

Once a suitable feed is identified, the application allows users to connect it to a Solace Event Broker. This connection can be to a local broker, a cloud instance, or any accessible Solace broker endpoint. The application handles the details of establishing the connection based on the provided broker information, making it accessible even to those not familiar with the nuances of messaging protocols.

Configuring and Running Event Simulations

With the feed selected and the broker connection established, users can configure the simulation parameters:

• Event rate and volume
• Duration of the simulation
• Specific event types to include or exclude

These configuration options allow for fine-tuning the simulation to match specific testing or demonstration requirements. Once configured, the simulation can be started with a single click, instantly generating a stream of realistic events flowing through the Solace broker.

From AsyncAPI to Live Events

The technical foundation of Event Feeds lies in AsyncAPI specifications, which provide a standardized way to describe event-driven APIs. These specifications define:

• The topics or channels used for communication
• The message formats and payload schemas
• The protocol bindings and delivery guarantees
• Metadata about the API and its operations

Event Feeds extend these specifications by adding:

• Data generation rules that create valid, varied instance data
• Publishing logic that determines when and how often events occur
• Relationships between different event types
• Business rules that maintain consistency across the event stream

This extension transforms a static API definition into a dynamic simulation of a living event ecosystem. For example, an AsyncAPI document might define an order event with fields like customerId, orderItems, and totalAmount. By default, the Event Feed generates syntactically valid but dummy data for these fields — enough to simulate structure and flow.

However, the real power lies in configuring data generation rules. These rules let you produce semantically realistic content: valid customer IDs drawn from a specific range, calculated totals based on actual pricing logic/range, and more. With this setup, developers can simulate real-world variability and edge cases, all without connecting to production data sources.

The Event Feeds application processes these extended specifications to create a continuous stream of events that reflect real-world patterns and relationships, publishing them to the connected Solace broker with appropriate topic structures and payload formats. This enables developers to see how their applications would behave in a production environment, without the complexity of setting up actual production data sources.

Using Event Feeds in Practice

The practical applications of Event Feeds span the entire software development lifecycle and extend to sales, training, and operations activities.

Demonstrating Domain-Specific Applications

For sales engineers and professional services teams, Event Feeds provide a powerful tool for demonstrating solutions in specific domains. Rather than using generic, obviously fake data, they can showcase applications processing realistic order flows, financial transactions, IoT sensor readings, or logistics events. This realism helps prospective customers envision how the solution would work in their environment.

Testing Application Behavior with Realistic Data Flows

Development and QA teams benefit from the ability to test applications against event streams that mirror production patterns. This testing can reveal issues that might not be apparent with simplified test data:

• Edge cases in data processing
• Performance under varying event rates
• Handling of complex event relationships
• Response to unusual but valid data patterns

By using Event Feeds for testing, teams can have greater confidence that applications will perform correctly when deployed to production.

Building Compelling Demos for Stakeholders

When communicating with business stakeholders, technical details often fall flat. Event Feeds enable the creation of business-relevant demonstrations that show how systems respond to events that stakeholders recognize from their daily operations. This business-centric approach makes it easier to align technical capabilities with business requirements and obtain buy-in for event-driven initiatives.

Contributing to the Community

The value of the Event Feeds ecosystem grows with each new contribution. The process of creating and sharing feeds has been designed to be accessible to anyone with domain knowledge and basic familiarity with AsyncAPI concepts.

Creating Your Own Feeds

Creating a new feed involves defining:

• The AsyncAPI specification for the events
• Data generation rules using templates or code
• Publishing patterns and frequency rules
• Documentation explaining the business context

Templates and examples in the repository make this process more approachable, even for those new to AsyncAPI or event simulation.

Sharing Feeds with the Community

Once created, sharing a feed involves submitting it to the community repository through a pull request. The repository maintainers review submissions to ensure quality and consistency, after which the feed becomes available to the entire community through both the repository and the web application.

This contribution process creates a virtuous cycle where:

1. Users benefit from existing feeds
2. Some users create new feeds or enhance existing ones
3. These contributions benefit future users
4. The ecosystem grows in breadth and depth

About feeds.solace.dev

You can run generated Event Feeds directly from the command line using the stm feed run command. For a more interactive experience, append the –ui flag to launch a local web interface, allowing you to browse both community-contributed and locally defined feeds.

The feeds.solace.dev site hosts the official catalog of community feeds. Simply select a feed of interest, connect to a cloud or local Solace broker using your credentials, and start streaming events — all in just a few clicks. It’s a powerful way to leverage domain-specific feeds from the browser anytime, without writing a single line of code.

Technical Deep Dive

Behind the user-friendly interfaces lies a robust implementation powered by the Solace TryMe CLI (stm). The feed generation feature is built directly into the CLI, exposing a rich set of subcommands that let developers generate, configure, run, and contribute event feeds — all from the command line.

This design ensures that Event Feeds are not only easy to use via the web interface but also fully automatable and script-friendly for advanced use cases. Whether you’re building test harnesses, integrating into CI pipelines, or crafting domain-specific simulations, the stm feed run command give you complete control over the simulation workflow.

Command Reference and Syntax

The stm feed command follows a consistent pattern of subcommands:

stm 
├── -v, --version         /* output the version number              */  
├── -h, --help            /* display help for command               */  
└── feed                  /* manage event feeds                     */  
    ├── -h, --help        /* display help for command               */  
    ├── preview           /* Preview an AsyncAPI document           */ 
    ├── generate          /* Generate event feed from an AsyncAPI   */ 
                          /* document                               */ 
    ├── configure         /* Configure event feed rules             */  
    ├── run               /* Run event feed                         */  
    ├── list              /* List event feeds                       */  
    ├── import            /* Import an event feed from archive file */  
    ├── export            /* Export an event feed to Event Portal   */ 
    ├── archive           /* Archive an event feed                  */  
    └── contribute        /* Contribute to community event feeds.   */ 

Event Feeds Demo

To get started, download an AsyncAPI document for an application or event API product — for example, from Solace Event Portal. Then use the stm feed generate command to create a corresponding Event Feed. Once generated, you can configure the data generation rules to match your desired payload logic and event structure.

With your feed ready, you’re just one command away from running a fully simulated, production-like event stream — either from the command line using stm feed run, or through an interactive web UI with stm feed run --ui.

This quick demo shows how that works. You’ll want to watch it full screen to follow along.

Conclusion

Solace Event Feeds mark a leap forward in how developers, architects, and field engineers build and test event-driven systems. By delivering ready-to-use, production-like event streams — deployable in minutes and without custom code — they remove one of the most persistent bottlenecks in the event-driven development lifecycle.

Built on AsyncAPI specifications, enriched with data generation rules, and shaped by community contributions, Event Feeds form an ecosystem that grows in relevance and richness over time. As more domains are represented and existing feeds are enhanced, simulating real-world data flows becomes faster, easier, and more accessible to teams at any stage of their event-driven journey.

For organizations embracing EDA, Event Feeds accelerate development, enhance testing fidelity, and enable high-impact demos for both technical and business audiences. For the Solace community, they create a concrete way to share domain knowledge and promote best practices.

Whether you’re just getting started or already deep into event-driven systems, Solace Event Feeds offer a powerful way to work with meaningful, reusable, and realistic event data — without the friction of traditional simulation approaches.

👉 Explore the available feeds on feeds.solace.dev or dive into the Solace Event Feeds GitHub repository to start contributing your own.