Event-Driven Architecture Guides and Examples

EquinoxProject is an ASP.NET 9 web application template and reference implementation for building enterprise software. It provides a structural boilerplate centered on clean architecture, domain-driven design, and the separation of read and write operations through a command query responsibility segregation framework. The project incorporates event sourcing to track the history of business entities as a sequence of events for auditing and state reconstruction. It utilizes a layered approach to decouple business logic from external dependencies and frameworks. The system includes capabilities

This project is a reference implementation and architectural blueprint for building distributed systems using the go-zero framework. It provides a complete microservices boilerplate and a standardized project layout to bootstrap API and RPC services with consistent folder structures. The implementation distinguishes itself by providing a comprehensive guide and codebase for service discovery, rate limiting, and circuit breaking. It demonstrates an observability stack integration that coordinates distributed tracing, metrics collection, and centralized logging across multiple microservices. T

This project is a reference implementation of Domain-Driven Design, Clean Architecture, and Command Query Responsibility Segregation (CQRS) patterns using the Go programming language. It serves as a sample application to demonstrate how to decouple core domain rules from infrastructure and delivery mechanisms. The system is built as a gRPC microservices architecture, utilizing type-safe communication and service contracts. It implements an event-driven architecture to manage eventual consistency and asynchronous processing, specifically employing the Outbox pattern to ensure reliable messagin

This project is a distributed systems design framework and architecture guide. It provides technical resources for designing, deploying, and coordinating independent network services. The framework establishes a structured methodology for migrating monolithic applications into decentralized services by separating frontend and backend concerns. It serves as a reference for event-driven architecture, focusing on maintaining data consistency across network boundaries using event sourcing and local transaction records. The project covers a broad range of capabilities including distributed servic

This project is a reference implementation of Domain-Driven Design patterns, functional domain modeling, and event-driven state coordination. It demonstrates the application of strategic and tactical design patterns to manage complex business requirements. The implementation utilizes a functional domain model with pure functions and immutable objects to manage state transitions and side effects. It features a Command Query Responsibility Segregation architecture to separate read and write models, alongside event-driven coordination to maintain consistency across autonomous business boundaries

This project is a comprehensive educational resource and technical guide for building enterprise backend applications and RESTful services using the Spring Boot framework. It serves as a step-by-step tutorial for developing server-side logic, API routing, and distributed systems within the Java ecosystem. The documentation provides specific implementation guides for microservices architecture, focusing on coordinating distributed services and event-driven communication. It includes a practical reference for the Spring ecosystem, with detailed sections on security implementation and data persi

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

This project is a framework for implementing event sourcing and command query responsibility segregation within containerized microservices. It provides a structured approach to managing business state as a sequence of immutable events, ensuring a reliable audit trail and the ability to reconstruct system state at any point in time. The framework distinguishes itself by enforcing a clear separation between data modification and data retrieval paths. By utilizing event-driven data synchronization, it allows for the asynchronous updating of materialized views and read models, ensuring that quer

This project is a reference implementation for building scalable applications in TypeScript using Domain-Driven Design. It provides a structured codebase template that organizes business logic through tactical design patterns and strategic modeling to ensure the software reflects specific business requirements. The architecture utilizes a hexagonal pattern to isolate core business logic from external infrastructure concerns such as databases and delivery mechanisms. It implements Command Query Responsibility Segregation to separate data modification operations from information retrieval tasks

Watermill is a Go library for building event-driven applications. It provides a framework for implementing event-driven architectures through a consistent interface for message publishing and subscribing, featuring a pub/sub message router and event stream processing pipelines. The library uses interface-based abstractions to decouple message producers and consumers from the underlying message broker. This allows different messaging technologies to be swapped via plugin-based broker integration. It employs a router-driven dispatch system and middleware-based pipelines to manage cross-cutting

NSQ is a distributed, brokerless messaging platform designed for high-throughput, fault-tolerant communication. By utilizing a decentralized topology, it eliminates single points of failure and allows for horizontal scaling across clusters. The system organizes message streams into topics and channels, effectively decoupling producers from consumers to support both streaming and job-oriented workloads. The platform distinguishes itself through a lookup-service-based discovery mechanism that enables clients to dynamically locate producers at runtime without requiring centralized coordination.

PubSubJS is a lightweight JavaScript library that implements the publish-subscribe pattern to manage decoupled communication between different parts of an application. It functions as a dependency-free message broker and event bus, allowing components to exchange data without requiring direct dependencies. The system enables the orchestration of events through named topics, allowing developers to register subscriber callbacks and broadcast messages to all interested listeners. It specifically supports the decoupling of component communication and the notification of state changes across multi