Skip to content
Awesome Software Architecture
Command Query Separation - CQS
Initializing search
mehdihadeli/awesome-software-architecture
Awesome Software Architecture
mehdihadeli/awesome-software-architecture
Abstraction
Actor Model Architecture
Actor Model Architecture
Actor Model Architecture
Akka .NET
Orleans
Protoactor
AI
Algorithms
Anti Patterns
Anti Patterns
Anti Patterns
Big Ball of Mud
Code Smells
God Object
Partial/Optional Object
Static Cling
Architectural Design Principles
Architectural Design Principles
Architectural Design Principles
CAP Theorem
Cohesion
Command Query Separation - CQS
Coupling
Crosscutting Concerns
Dependency Inversion
Donot Repeat Yourself - DRY
Encapsulation
Fail-Fast
Favor Composition over Inheritance
GRASP
Interface Segregation
Inversion of Control
Keep It Simple - KISS
Open/Closed Principle
Persistence Ignorance
Single Responsibility
SOLID
Strangler Fig Pattern
YAGNI
Architecture Decision Records (ADR)
Azure Cloud
Azure Cloud
Azure API Management
Azure App Configuration
Azure App Service
Azure App Service Plan
Azure Cloud
Azure Functions / Azure Serverless
Azure Kubernetes Service (AKS)
Azure Load Balancing
Azure Logic App
Azure Messaging
Azure Messaging
Azure Messaging
Azure Event Grid
Azure Event Hub
Azure Queue
Azure Service Bus
Azure Web Pub/Sub
Azure NoSQL
Azure NoSQL
Azure CosmosDB
Azure NoSQL
Azure Resource & Resource Group
Azure Resource Manager (ARM)
Azure Sequrity
Azure Sequrity
Azure Active Directory (Azure AD)
Azure Key Vault
Azure SQL
Azure Storage
Azure Storage
Azure Storage
Azure Blob
Azure Queue
Azure Table
Azure File
Azure Template
Back Pressure
Caching
Clean Architecture
Clean Code
Cloud Best Practices
Cloud Design Patterns
Cloud Design Patterns
Ambassador Pattern
Anti Corruption Layer Pattern
Backends for Frontends
Bulkhead Pattern
Circuit Breaker Pattern
Cloud Design Patterns
Exactly One Delivery
Gateway Aggregation
Gateway Pattern
Inbox Pattern
Outbox Pattern
Sidecar Pattern
Strangler Fig Pattern
Cloud Native
Code Review
Concurrency
CQRS
Data Driven Design
Design Best Practices
Design Best Practices
12 Factor
Design Best Practices
Ids
Thin Controllers
Design Patterns
Design Patterns
Adapter Pattern
AutoPilot Pattern
Builder Pattern
Chain Of Responsibility
Command Message Pattern
Decorator Pattern
Design Patterns
Factory Pattern
Observer Pattern
Query Object Pattern
Repository Pattern
REPR
Singleton
Specification Pattern
State Pattern
Strategy Pattern
Transaction Script Pattern
DevOps
DevOps
CI/CD
CI/CD
Azure DevOps
Github Actions
Jenkins
Containerd
Docker
Docker
Docker
Docker Compose
Kubernetes
Kubernetes
Kubernetes
Deployment Strategies
Deployment Tools
Deployment Tools
Argo-CD
Helm
Kustomize
Kubernetes Operator
Jenkins
Ingress Controller
Ingress Controller
Ingress Controller
Nginx Ingress
Traefik Ingress
Other Tools
Other Tools
K3s
Telepresence
Telepresence
Garden
Tilt
Terminal
Terminal
Bash
Powershell
Distributed Locking
Distributed Transactions & Saga
Domain Driven Design
Domain Driven Design
Aggregation
Anemic Domain Model
Application Service
Bounded Context
Domain
Domain Driven Design
Domain Events
Domain Service
Enums
Event Sourcing
Exception And Validation
Infrastructure
Integration Events
Mapping
ORMs
ORMs
Entity Framework
Persistence Ignorance
Primitive obsession
Rich Domain Model
Strategic Design Patterns
Tactical Design Patterns
Value Objects
Event Driven Architecture
Eventual Consistency
Eventual Consistency
Functional Programming
gRPC
Hexagonal Architecture
Infrastructure as a Service
Infrastructure as a Service
Ansible
Infrastructure as a Service
Nomad
Pulumi
Terraform
Interview
Messaging
Messaging
Async APIs Documentation
Azure Service Bus
Change Data Capture (CDC)
Kafka
Messaging
NATS
RabbitMQ
Micro-Frontend
Microservices
Microservices
Communication & Data Consistency
Composite UI
Microservices
Observibility
Observibility
CorrelationId
Observibility
Distributed Tracing
Diagnostics
Logging
Monitoring
Metrics
Tools
Tools
EFK
ELK
FluentBit
FluentD
Loki
Resiliency
Resiliency
Resiliency
High Availibility
Idempotency
Services Boundries
Testing
Tools
Tools
CAP
Dapr
Wolverine
SteelToe
Tye
MassTransit
Aspire
NServiceBus
CAP
Modeling
Modeling
Architecture Diagram
Class Diagram
Component Diagram
Conceptual Diagram
Conceptual Modeling
Data Modeling Notations
Domain Stroytelling
ER Diagrams
Event Modeling
Event Storming
Logical Modeling
Modeling
Physical Modeling
Relationship
Tools
Use Case Diagram
Modular Monolith
NoSQL
NoSQL
CosmosDB
DocumentDB
MongoDB
NoSQL
Postgresql
Object Oriented Design
Onion Architecture
Open Source
Others
Platform as a Service
Platform as a Service
Heroku
Netlify
OpenShift
Rancher
Refactoring
Relational Database
Relational Database
Postgresql
Relational Database
SQL
RESTful API Design
Reverse Proxy & Load Balancing
Reverse Proxy & Load Balancing
Envoy
Fabio
HAProxy
Load Balancing
MetalLB
Nginx
Reverse Proxy
Traefik
YARP
Scaling
Service Discovery & Registry
Service Discovery & Registry
Consul
Eureka
Service Discovery & Registry
Service Mesh
Service Mesh
Consul & Consul Connect
Istio
Linkerd
Maesh
Service Mesh
Service Oriented Architecture
Sharding
Software Architecture
Systems Design
Systems Design
Consistent Hashing
Systems Design
Type Driven Design
Vertical Slice Architecture
Command Query Separation
¶
Back to top