CQRS

Understands CQRS in Java/Spring context: knows the concept of separating Command and Query models, distinguishes CommandHandler and QueryHandler. Can work with Axon Framework or Spring CQRS template projects at a basic change level.

Understands CQRS in Node.js context: knows how to separate read and write endpoints, understands command/query handlers pattern. Can work with NestJS CQRS module at simple command and query handler level.

Understands CQRS principles in PHP: knows the difference between command and query operations, can work with projects using command bus (Tactician, Symfony Messenger). Understands why read and write operations are separated.

Understands the concept of separating read and write models: knows why CQRS is needed, difference between command and query. Can work with codebases where read and write models are separated, make simple changes to existing handlers.

Understands CQRS in the Rust context: knows how the trait system enables clear separation of command and query interfaces. Can implement a simple command/query handler using enum dispatch and trait objects.

Understands CQRS in Scala ecosystem: knows Akka Persistence for event sourcing, distinguishes Command and Event in typed actor model. Can work with existing Akka-based CQRS code at the level of simple changes.

Implements CQRS in Java projects: uses Axon Framework for command/query separation, configures event handlers for read model updates, applies Spring Data for read-optimized repositories. Configures sagas for distributed command coordination.

Implements CQRS in Node.js projects: uses NestJS CQRS or custom implementation with TypeScript, creates separate read models via Prisma/TypeORM, configures event handlers for synchronization. Applies Repository pattern with different implementations for command and query sides.

Implements CQRS in PHP projects: uses Symfony Messenger or Ecotone for command/query bus, creates separate Doctrine read models (QueryBuilder + DTO) from write models (Entity + Repository). Configures event handlers for read model synchronization.

Implements CQRS in Python projects: separates command and query handlers via mediatr-like libraries, designs separate read models (denormalized view tables or materialized views). Ensures eventual consistency between write and read sides.

Implements CQRS in Rust projects: creates separate command and query modules with typed handlers, uses sqlx/SeaORM for different read/write models, applies tokio channels for event propagation. Ensures compile-time guarantees through generic constraints on command/query types.

Implements CQRS in Scala: uses Akka Typed Persistence for event sourced aggregates, configures Akka Projection for read models, applies ZIO + Tapir for typed command/query API. Implements domain events with sealed trait hierarchies for exhaustive matching.

Designs CQRS architecture for Java microservices: chooses between Axon Framework and Eventuate, implements event sourcing with snapshot optimization, configures parallel projections for different read stores (PostgreSQL, Elasticsearch, Redis). Ensures consistency via idempotent event handlers.

Designs CQRS architecture for Node.js: integrates with EventStoreDB or custom event store, implements projection rebuilds via event replay, configures multiple read stores for different query patterns. Ensures type safety via TypeScript generics for command/query/event types.

Designs CQRS for PHP systems: implements Ecotone Framework for full CQRS/ES, builds async projections via RabbitMQ, configures read stores (Elasticsearch, Redis) separate from write database. Ensures testability through in-memory event store for integration tests.

Designs CQRS architecture for Python services: defines pattern applicability boundaries, selects read model synchronization strategy (sync vs async projections), implements event-driven projections via Kafka/RabbitMQ. Integrates CQRS with event sourcing for full change auditability.

Designs CQRS for high-performance Rust systems: implements event sourcing with custom event store, optimizes projections through zero-copy deserialization and parallel processing. Designs snapshot strategy for aggregates and ensures idempotent event handling.

Designs CQRS architecture for Scala microservices: configures Akka Cluster Sharding for distributed aggregates, implements multiple projections (Slick, Elasticsearch, Cassandra), optimizes event journal through snapshot strategy and event deletion. Integrates with Kafka for cross-service event propagation.

Designs system architecture with CQRS. Makes architectural decisions (ADR). Evaluates non-functional requirements.

Standardizes CQRS in the company's Java ecosystem: defines when to apply full CQRS vs simplified read/write separation, designs event store infrastructure (Axon Server vs EventStoreDB vs custom), standardizes CQRS component testing strategy. Trains teams on DDD + CQRS.

Standardizes CQRS in Node.js ecosystem: creates internal library for CQRS with middleware support, designs event catalog with versioning, defines testing patterns for aggregates and projections. Implements distributed CQRS via message broker for cross-service consistency.

Standardizes CQRS in the PHP ecosystem: defines architectural decision records for CQRS adoption, designs migration strategy from existing CRUD code to CQRS, creates internal Composer packages for standardization. Trains PHP teams on DDD approaches with CQRS.

Defines CQRS adoption strategy for the organization: standardizes read/write separation approaches, designs infrastructure for projection rebuilds, implements consistency lag monitoring between models. Trains teams on when CQRS is justified and how to avoid over-engineering.

Defines CQRS architecture for Rust platform: creates CQRS framework with derive macros for automatic command/query handler generation, designs event schema management with serde and schema validation. Standardizes testing through property-based tests for aggregates.

Standardizes CQRS in Scala ecosystem: chooses between Akka Persistence and ZIO-based solutions (zio-entity), designs multi-bounded context architecture, creates abstractions for testable CQRS. Defines migration strategy from Akka Classic to Akka Typed for CQRS modules.

Defines product architectural strategy with CQRS. Establishes architecture guidelines. Conducts architecture reviews.

Shapes enterprise CQRS strategy: designs multi-bounded context CQRS with shared event bus, defines governance for event schema evolution, develops platform for self-service CQRS modules. Influences architectural decisions on CQRS adoption in legacy Java systems.

Shapes CQRS architectural vision for Node.js platform: designs event-driven architecture with CQRS as core pattern, defines strategy for real-time projections via WebSocket/SSE. Influences architectural decisions on CQRS adoption considering Node.js async nature.

Shapes CQRS architectural strategy for the PHP platform: determines where CQRS is justified in the PHP process model context, designs PHP CQRS module integration with event-driven microservices in other languages. Influences CQRS ecosystem development in PHP (Ecotone, Broadway).

Shapes CQRS architectural strategy at platform level: designs infrastructure for multi-tenant CQRS with isolated read stores, defines patterns for cross-service queries and data mesh integration. Influences architectural decisions on monolith decomposition using CQRS as a transitional pattern.

Shapes CQRS strategy for distributed Rust systems: designs multi-region event store with conflict resolution, defines architecture for cross-service CQRS with gRPC-based event propagation. Influences Rust CQRS/ES ecosystem development through open-source contributions.

Shapes CQRS strategy for Scala platform: designs event-driven architecture with CQRS as core pattern, defines event schema governance with Avro/Protobuf, develops platform for self-service aggregate creation. Influences Scala CQRS ecosystem development (Akka, ZIO).

Defines the organization's architectural strategy. Designs reference architectures. Establishes architecture governance.