QCon London 2026: Managing Asynchronous APIs at Scale

At QCon London 2026, Ian Cooper, senior principal engineer at Just Eat Takeaway, delivered a compelling session on managing asynchronous APIs in production environments. His talk addressed a critical challenge facing organizations adopting event-driven architectures: how to maintain control and visibility as systems scale beyond what informal coordination can support.

Cooper began by acknowledging a familiar pattern in event-driven system evolution. Teams often start with informal approaches, relying on shared knowledge to understand which services publish events, which consume them, and how messages flow through the system. This works well initially, but as organizations grow, this ad-hoc approach becomes increasingly fragile. "At scale, ad-hoc breaks," Cooper argued, pointing to the fundamental problems that emerge: integration points become difficult to discover, producers don't know who their consumers are, and undocumented schema changes break downstream systems.

The core question he posed was practical and immediate: "As a producer, how do I find consumers? Do I search all the repos looking for my message name? Do I ask on Slack if anyone consumes my events?"

To address these challenges, Cooper outlined a set of emerging practices for managing asynchronous APIs in large organizations, organized around three pillars: discovery (finding and understanding the async API), governance (ensuring schemas are consistent and evolving safely), and provisioning (going from a specification to a deployment).

Central to this approach is the use of explicit specifications for messaging interfaces. Technologies such as AsyncAPI, designed specifically to build event-driven architectures, alongside alternatives such as xRegistry, provide machine-readable ways to describe event contracts. These specifications include topics, payload schemas, and message metadata, enabling teams to document ownership and improve discoverability across distributed systems.

Cooper then discussed the importance of standardized event metadata and schema governance. Formats such as CloudEvents can provide consistent metadata across messaging systems, while schema registries allow teams to validate event structures and manage compatibility as schemas evolve. He compared different compatibility modes and explained why developers cannot simply rely on human coordination among teams. These mechanisms support safer change management by ensuring producers and consumers remain compatible over time.

Beyond documentation and governance, Cooper emphasized the importance of automation and a change of mindset: "Tooling and adoption is still very hard: getting teams to write and maintain specifications requires cultural change, not just tooling."

In mature event-driven platforms, endpoint specifications can serve as the source of truth, and from these definitions, tooling like AsyncAPI can generate code artifacts, automatically register schemas, and provision messaging infrastructure. Cooper highlighted the benefits of tools such as EventCatalog in making asynchronous APIs and event-driven systems visible, discoverable, and governable at scale.

This new approach reduces manual coordination between teams—"Specifications, not tickets!"—and provides architects with greater visibility and control over complex event flows in production environments.

The speaker closed the session with a demo using Marmot as an open-source example, and reminded the audience of the importance of treating async APIs with the same rigour as sync APIs.

Cooper's message was clear: as organizations scale their event-driven architectures, they need to move beyond informal coordination to explicit specifications, automated tooling, and standardized governance. This shift isn't just about technology—it's about changing how teams collaborate and how systems are designed and maintained at scale.

The session resonated with attendees facing similar challenges in their own organizations, offering a practical roadmap for bringing order to the complexity of asynchronous APIs in production.