Clarc Message Bus Bundle Laravel Package

Product Decisions This Supports

• Adoption of Clean Architecture Principles: Enables strict separation of concerns by abstracting messaging logic into a dedicated event-driven layer, aligning with CLARC (Clean Architecture) principles. This supports long-term maintainability and testability.
• Event-Driven Microservices Roadmap: Facilitates transitioning to a distributed event-driven architecture by standardizing message formats and routing. Ideal for teams planning to decompose monoliths or build new microservices.
• Build vs. Buy Decision: Avoids reinventing a message bus layer from scratch, reducing technical debt while maintaining flexibility. The bundle’s dependency on Symfony Messenger and RabbitMQ allows for incremental adoption.
• Use Cases:
  • Asynchronous workflows (e.g., order processing, notifications).
  • Decoupled services where producers/consumers evolve independently.
  • Audit trails via event sourcing patterns.
  • Cross-cutting concerns (logging, retries, validation) handled via middleware.

When to Consider This Package

• Adopt if:
  • Your team follows Clean Architecture or aims to enforce domain-driven design (DDD).
  • You’re using Symfony 5+ and need a lightweight, opinionated message bus layer.
  • You require RabbitMQ integration with topic exchanges (for dynamic routing).
  • You need built-in retry logic (redelivery stamps) and middleware extensibility.
  • Your project involves event sourcing or CQRS patterns.
• Look elsewhere if:
  • You’re not using Symfony (package is tightly coupled to Symfony Messenger).
  • You need Kafka, Redis, or other transports (RabbitMQ-only by default).
  • Your team lacks experience with event-driven architectures (steep learning curve for message contracts).
  • You require enterprise-grade features (e.g., dead-letter queues, advanced monitoring) out of the box.
  • The package’s lack of stars/activity (last release in 2021) is a risk for long-term support.

How to Pitch It (Stakeholders)

For Executives: "This package lets us adopt a scalable, event-driven architecture without building a custom message bus from scratch. By standardizing how services communicate asynchronously (e.g., orders → notifications), we reduce coupling, improve fault tolerance, and pave the way for microservices. It’s a low-risk, high-reward investment—leveraging Symfony’s ecosystem while enforcing Clean Architecture principles. The upfront cost is minimal (RabbitMQ setup), but the long-term benefits for maintainability and extensibility are significant."

For Engineering: *"This bundle gives us a Symfony-compatible message bus that enforces Clean Architecture by abstracting messaging logic into reusable event contracts. Key perks:

• Middleware support: Add validation, retries, or logging without touching core logic.
• RabbitMQ topic exchanges: Dynamic routing for flexible event handling.
• Symfony Messenger integration: Works with existing transports (easy to swap later).
• Redelivery stamps: Built-in retry logic for resilience. Tradeoff: It’s RabbitMQ-only and requires upfront setup (event contracts, RabbitMQBundle), but it’s a solid foundation for event-driven workflows. Let’s prototype with a single use case (e.g., order events) to validate fit."*