Event-Driven Architecture

Understands event-driven architecture in the Java/Spring ecosystem context. Knows the purpose of Spring Events, ApplicationEventPublisher, difference between synchronous and asynchronous events in Spring Framework.

Understands Node.js event loop as the foundation of event-driven model. Knows EventEmitter, distinguishes internal application events from external ones via message brokers. Understands why Redis Pub/Sub and BullMQ are used in Node.js projects.

Understands event-driven architecture concepts and PHP limitations as a request-response language. Knows Laravel Events/Listeners, Symfony EventDispatcher, understands why PHP applications need queues (Laravel Queue, Symfony Messenger).

Understands event-driven architecture concept and its difference from synchronous request-response. Knows what an event bus is and why pub/sub pattern is needed in Python applications.

Understands event-driven architecture concepts and the role of Rust ownership model for safe event processing. Knows tokio channels, distinguishes between mpsc and broadcast channels, understands why Rust services need message brokers.

Understands event-driven architecture in Scala/Akka ecosystem context. Knows Actor Model, Akka actors as message processing method, distinguishes tell and ask patterns. Understands Kafka's role in Scala projects.

Develops event-driven Java services using Spring Kafka, Spring AMQP, or Spring Cloud Stream. Implements producer/consumer with error handling, configures retry-template, dead letter topic. Applies @KafkaListener with manual offset commit.

Develops event-driven Node.js services with BullMQ, RabbitMQ (amqplib) or kafkajs. Handles events asynchronously with retry logic, configures dead letter queues. Uses NestJS CQRS module or custom pub/sub pattern implementations.

Implements event-driven processing in PHP via Laravel Queue / Symfony Messenger with RabbitMQ or Redis. Configures workers, retry policies, dead letter queues. Applies domain events for business logic decoupling in Laravel/Symfony applications.

Designs async event handlers in Python using Celery, RabbitMQ, or Redis Streams. Implements producer-consumer pattern, handles errors in event chains, and configures retry policies.

Implements event-driven Rust services with rdkafka, lapin (RabbitMQ) or async-nats. Uses tokio for async event processing, implements graceful shutdown with CancellationToken. Handles event deserialization errors through serde with proper error types.

Develops event-driven Scala services with Akka Streams, Alpakka Kafka or FS2/Cats Effect. Implements reactive streams with backpressure, processes events through Akka Persistence for event sourcing. Applies Scala type system for type-safe event contracts.

Designs event sourcing and CQRS on Java using Axon Framework or custom solutions on Spring. Implements saga pattern for distributed transactions, transactional outbox via Debezium CDC. Ensures ordering guarantees and exactly-once processing in Kafka Streams.

Designs event sourcing and CQRS on Node.js considering single-threaded model. Implements saga orchestration via message broker, applies transactional outbox. Ensures handler idempotency, manages backpressure in event streams under high load.

Designs event-driven PHP systems with Symfony Messenger or Laravel Horizon. Implements event sourcing via Prooph or Ecotone framework, saga pattern for distributed transactions. Ensures reliable message processing in stateless PHP conditions (long-running workers, Swoole/RoadRunner).

Designs event-driven Python systems with delivery guarantees (at-least-once, exactly-once). Applies event sourcing for critical domains, implements saga pattern for distributed transactions via Celery/Kafka. Ensures handler idempotency.

Designs high-performance event-driven systems in Rust using zero-copy deserialization, lock-free queues. Implements event sourcing with type-safe aggregates through Rust enum/trait system. Ensures exactly-once processing, transactional outbox with sqlx.

Designs event sourcing and CQRS on Scala with Akka Persistence / Akka Projection or pure FP approaches (FS2 + Doobie). Implements saga through Akka FSM, ensures exactly-once through Kafka Streams DSL on Scala. Uses ADT (sealed traits) for type-safe domain events.

Defines event-driven Java system architecture for the company: choosing between Kafka, RabbitMQ, Pulsar, partitioning strategy, schema registry (Confluent/Apicurio). Develops corporate starters for standardizing event handling in Spring Boot microservices.

Defines event-driven Node.js system architecture: chooses between BullMQ, Kafka, NATS. Designs schema validation for events (JSON Schema, Avro), consumer lag monitoring. Creates internal NPM packages for standardizing event handling in Node.js microservices.

Defines event-driven PHP system architecture: choosing between Symfony Messenger, Laravel Queue, Ecotone. Designs PHP service integration with Kafka/RabbitMQ, event schema validation. Solves PHP-specific problems: memory leaks in long-running workers, restart on deploy.

Defines event-driven system architecture at company level: choosing between Kafka, RabbitMQ, Redis Streams for Python services. Designs schema registry for events, contract versioning, event flow monitoring. Trains the team on working with eventually consistent systems.

Defines Rust event-driven system architecture: transport selection, designing type-safe event schemas through Rust macros and proc macros. Develops internal crates for standardizing event handling, ensures compile-time guarantees for correct event processing.

Defines architecture for event-driven Scala systems: choosing between Akka/Pekko, ZIO, Cats Effect ecosystems for event processing. Designs schema evolution for Avro/Protobuf events, actor systems monitoring. Develops libraries for standardizing event-driven communication.

Shapes event-driven strategy for enterprise-scale Java platform. Defines event governance, schema versioning, migration strategies. Leads transition from monolithic Spring application to event-driven microservices, designs event mesh for multi-cluster deployments.

Shapes event-driven architecture strategy for Node.js platform. Addresses event consumer scaling considering Node.js specifics (single-threaded), defines CloudEvents standards, designs event catalog and governance. Leads migration from monolithic Express/NestJS to event-driven microservices.

Shapes event-driven architecture strategy for the PHP platform. Defines approaches to scaling PHP workers (Kubernetes + Horizon/Supervisor), event standards, governance. Leads migration from monolithic Laravel/Symfony to event-driven microservices considering PHP ecosystem specifics.

Shapes event-driven architecture strategy for the entire platform. Defines CloudEvents standards, event schema governance, migration from monolithic Python applications to event-driven microservices. Conducts architectural reviews of event systems and builds event flow observability.

Shapes event-driven architecture strategy for Rust platform. Defines balance between compile-time safety and runtime flexibility for event schemas. Designs event mesh considering Rust specifics (ownership, lifetimes in async context), leads migration of critical services to event-driven Rust.

Shapes event-driven strategy for Scala platform: FP-first approach (ZIO/CE) vs Actor Model (Akka/Pekko), event standards, governance. Designs migration path for framework changes, ensures observability for actor systems and stream processing. Leads architectural decisions for reactive event-driven systems.