Allows incompatible interfaces to work together by wrapping an object in an adapter to make it compatible with another class.

Provides a simplified interface to a complex subsystem, making it easier to use and understand.

Minimizes memory usage by sharing common data between multiple objects instead of storing it in each object.

Provides a surrogate or placeholder for another object to control access to it.

Provides an interface for creating objects without specifying their concrete classes, allowing for flexible object creation.

Groups related objects into a cluster with a root entity that ensures consistency and enforces invariants.

Command Query Responsibility Segregation - separates read and write operations into different models for better scalability.

Stores the state of an entity as a sequence of events rather than just the current state.

Manages changes to event schemas over time while maintaining backward compatibility.

Creates periodic snapshots of aggregate state to optimize event sourcing performance for long event streams.

Manages long-running transactions across multiple services using a sequence of local transactions with compensating actions.

JSON Web Token - a compact, self-contained way to securely transmit information between parties as a JSON object.

An authorization framework that enables applications to obtain limited access to user accounts on an HTTP service.

A single entry point for all clients that routes requests to appropriate microservices and handles cross-cutting concerns.

Decentralized approach where each service produces and listens to events without a central coordinator.

Centralized approach where a single service coordinates the interactions between multiple services.

Collects and centralizes logs from multiple services for easier monitoring and troubleshooting.

Distributes messages across multiple partitions or shards to enable parallel processing and improve throughput.

Implements sharding in RabbitMQ to distribute queue load across multiple nodes for better performance.

Comprehensive collection of patterns for designing, implementing, and operating microservices architectures.

Represents the balance between process, organization, and architecture required for successful microservices adoption.

Anti-pattern where two or more modules depend on each other directly or indirectly, creating tight coupling.

Anti-pattern where a class inherits from multiple parent classes, leading to complexity and the diamond problem.