Message Broker Patterns

Understands message broker patterns in Java/Spring: pub-sub with Spring Cloud Stream, JMS templates, and Kafka listeners. Follows team conventions for producing and consuming messages with Spring Boot auto-configuration.

Understands message broker patterns in Node.js: pub-sub with BullMQ, event-driven messaging with amqplib. Follows team conventions for async message processing using queues and event emitters in Express/Fastify services.

Understands message broker patterns in PHP: pub-sub with Symfony Messenger, queue workers with Laravel Queues. Follows team conventions for dispatching and consuming messages using Redis, RabbitMQ, or SQS drivers.

Understands basic message broker concepts: publish/subscribe, point-to-point, message queues. Can send and receive messages via RabbitMQ (pika) or Redis pub/sub. Knows why async communication between services is needed.

Understands message broker patterns in Rust: pub-sub with lapin (AMQP), async consumers with tokio channels. Follows team conventions for type-safe message serialization with serde and reliable delivery patterns.

Understands message broker patterns in Scala: pub-sub with Akka Streams/ZIO Streams, Kafka integration via Alpakka. Follows team conventions for functional message processing with effect systems and backpressure handling.

Works with messaging in Java ecosystem: uses Spring Kafka for Kafka integration, Spring Cloud Stream for broker abstraction, configures consumer groups and partition assignment. Applies @KafkaListener with concurrency for parallel processing and configures error handler with retry.

Works with message brokers in Node.js: uses KafkaJS for Kafka integration, configures NestJS microservices with RabbitMQ/Kafka transport, implements pub/sub via Redis Streams. Applies consumer groups and configures retry logic with exponential backoff.

Works with messaging in PHP: uses Symfony Messenger with RabbitMQ/Redis transport, configures Laravel Horizon for queue monitoring, applies routing by message type. Handles failed jobs through retry and dead letter queues, configures priority queues.

Works with message brokers in Python projects: uses Celery with RabbitMQ/Redis for background tasks, implements pub/sub via confluent-kafka or aiokafka, applies competing consumers and fan-out patterns. Configures dead letter queues for error handling.

Works with message brokers in Rust: implements consumer groups through rdkafka with offset management, uses NATS through async-nats for lightweight messaging, applies tokio channels for internal message passing. Handles backpressure through bounded channels and flow control.

Works with messaging in Scala ecosystem: uses Alpakka Kafka with Akka Streams for reactive processing, configures consumer groups with committable sources, implements at-least-once delivery through offset committing. Applies fs2-kafka for functional stream processing with cats-effect.

Designs messaging architecture for Java microservices: implements transactional outbox via Spring @Transactional + Debezium, configures exactly-once processing in Kafka with transactional producer, designs schema evolution via Confluent Schema Registry. Optimizes consumer throughput via batch listener.

Designs messaging architecture for Node.js services: implements transactional outbox with MongoDB change streams or PostgreSQL LISTEN/NOTIFY, configures Kafka with exactly-once semantics via idempotent producer. Designs event schema management and consumer idempotency via deduplication store.

Designs messaging architecture for PHP systems: implements event-driven communication between PHP services via RabbitMQ with exchange routing, integrates PHP with Kafka via php-rdkafka for event streaming. Designs idempotent consumers and transactional outbox for consistency.

Designs messaging architecture for Python services: chooses between RabbitMQ, Kafka, Redis Streams for different scenarios, implements transactional outbox for delivery guarantees, configures exactly-once semantics in Kafka. Designs schema registry for message format evolution.

Designs high-performance messaging systems in Rust: implements zero-copy deserialization for maximum throughput, designs custom message routing through tokio task scheduling, configures batch processing with configurable flush intervals. Optimizes memory allocation for sustained high-throughput processing.

Designs messaging architecture for Scala: implements exactly-once processing through Kafka transactions with Alpakka, designs event sourcing with Akka Persistence or EventStoreDB, configures stream processing with Flink/Kafka Streams through Scala API. Optimizes backpressure and parallelism.

Standardizes messaging in the company's Java ecosystem: chooses between Spring Cloud Stream, Axon Framework, Eventuate for event-driven architecture, designs saga orchestration with Temporal or Axon Saga. Implements event store for audit and replay, defines topic governance strategy.

Standardizes messaging in Node.js ecosystem: creates internal SDK for broker abstraction, designs event catalog with typed events via TypeScript, implements distributed tracing for message flows. Defines saga and choreography patterns for Node.js.

Standardizes messaging in the PHP ecosystem: defines async communication patterns considering PHP process model limitations, implements Ecotone Framework for CQRS/event sourcing, designs PHP monolith integration with event-driven microservices. Trains teams on messaging best practices.

Defines messaging strategy for the organization: standardizes patterns (saga, choreography vs orchestration, event sourcing), implements monitoring/alerting for message lag and consumer health. Designs Kafka topic partitioning for optimal parallelization and data locality.

Defines messaging architecture for Rust system: creates internal messaging framework with broker abstraction, designs event sourcing with custom Rust event store, standardizes serialization through Serde with schema evolution. Mentors on idiomatic message processing in async Rust.

Standardizes messaging in Scala ecosystem: chooses between Alpakka, fs2-kafka and ZIO Kafka for different teams, designs event-driven architecture with CQRS through Akka Projection, implements schema registry integration with Avro/Protobuf for type-safe evolution.

Shapes enterprise messaging strategy: designs multi-cluster Kafka platform with cross-datacenter replication, defines event-driven architecture standards at organizational level. Influences choice between Kafka, Pulsar, RabbitMQ for different use cases considering TCO and operational complexity.

Shapes event-driven strategy for Node.js platform: designs real-time event processing pipeline with Kafka Streams/ksqlDB, defines event sourcing patterns with event store. Influences streaming platform architecture considering Node.js event loop model and backpressure handling.

Shapes messaging strategy for the PHP platform: defines how PHP systems participate in enterprise event-driven architecture, designs async processing approaches considering FPM/Swoole/RoadRunner runtime. Influences architectural decisions for transitioning from synchronous to event-driven in PHP legacy.

Shapes platform async communication strategy: designs multi-region messaging with Active-Active Kafka replication, defines governance for schema evolution and topic naming conventions. Influences event-driven platform architecture considering compliance and data retention requirements.

Shapes strategy for Rust in critical messaging components: designs Rust-based message router/proxy for multi-protocol support, defines streaming platform architecture with sub-millisecond latency. Contributes to open-source messaging infrastructure (Fluvio, NATS).

Shapes streaming strategy for Scala platform: designs real-time processing pipeline with Apache Flink/Spark Structured Streaming on Scala, defines architecture decision records for event sourcing vs traditional messaging. Influences development of functional approach to messaging in Scala ecosystem.