Design Microservices Architecture with Patterns & Principles

Learn when to use monolithic architecture for startups, highlighting its simple development, single codebase, and easy deployment, plus challenges like tight coupling and the big ball of mud.

Design the first version of the e-shop with a monolithic architecture, outlining functional requirements and non-functional targets like 24/7 availability and 2–3 second response times, emphasizing simplicity.

Explore a monolithic web app by examining code structure, running the app with dotnet aspire, and validating end-to-end product to checkout flows while observing logs on the aspire dashboard.

Explores how a monolithic, tightly coupled UI and backend logic hampers flexibility, creates development bottlenecks, and limits omnichannel reach, while introducing three tier architecture.

Explore the big ball of mud: a tangled, poorly structured codebase with no clear organization, where rapid development, lack of proper design, and inadequate refactoring accumulate technical debt.

Explore modular monolith architecture, a single deployed app built from loosely coupled modules with explicit interfaces, to boost maintainability, team autonomy, and a stepping stone toward microservices.

Design a modular monolith backend for the e-shop by organizing domain modules (catalog, basket, ordering, identity, payment, and shipment) into cohesive, loosely coupled components with clear interfaces.

Isolate each module's data in its own schema within a single PostgreSQL database to achieve logical data isolation in modular monoliths.

Explore how a dotnet modular monolith organizes the api service into catalog, basket, and ordering modules with per-module schemas in PostgreSQL, enabling clean separation and internal module communication.

Explore monolithic architecture vertical considerations: module communications through direct method calls, transaction management with a single relational database and ACID, and deployments as a single unit.

During peak traffic, product pages slow due to repetitive reads on PostgreSQL. Learn to reduce database load by caching catalog data and avoiding database hits for each request.

Learn how output caching speeds up product pages by storing rendered outputs in a cache and serving them on subsequent requests, with attention to duration, invalidation, and distributed caching.

Design a modular monolith for e-shop with Redis output caching to reduce database load and improve latency on product pages, using cache invalidation and key design.

Explore how a single API service instance becomes a bottleneck under increased traffic, causing latency, high cpu and memory usage, and http 503 errors, and learn capacity for scalability.

Design a horizontally scaled e-shop backend with a load balancer, implementing stateless api services and external state in Redis or PostgreSQL to ensure read-heavy scalability and high availability.

Use microservices when independent scalability, high agility, and technology diversity solve business problems; avoid microservices for small apps without strong DevOps and clear business drivers.

Learn the database-per-service pattern and polyglot persistence, where each microservice owns a private database and shares data via public APIs to maintain loose coupling and autonomy.

Design a microservices architecture for the Icap application by decomposing the backend into independent data-isolated services with database per service and polyglot persistence.

Decompose microservices by business capability and subdomain, emphasizing high cohesion, loose coupling, bounded contexts, domain-driven design, and an evaluative checklist for independent deployability and data ownership.

Identify and decompose microservices for an eShop domain using domain-driven design by extracting key nouns and verbs from user stories, mapping to services like product catalog, shopping cart, and order.

Apply the strangler fig pattern to gradually replace a modular monolith with microservices, starting with the identity module, a strangler facade, and independent services with dedicated databases while preserving operations.

Explore how microservices communicate across networks, including protocols, data formats, service discovery, and API versioning, and learn patterns for synchronous and asynchronous communications using HTTP RESTful APIs.

Explore microservices communication basics, comparing inter-service network calls with monoliths, and learn RESTful APIs, GraphQL, gRPC, HTTP, JSON, and concerns like latency, security, serialization, and service discovery.

Design stateless, restful microservices with resource oriented URIs, versioning and JSON, using HTTP methods to expose cohesive customer, product, cart, checkout, and ordering APIs for a Blazor frontend.

Identify the n+1 data fetching problem in restful calls across microservices, and learn to reduce round trips by designing a GraphQL API that fetches exactly the needed nested data.

Explore GraphQL as a query language for APIs and a server-side runtime that uses a schema, queries, mutations, and resolvers to return exactly the requested data in JSON.

Design microservices with a GraphQL API layer that aggregates data, enables client-driven queries, decouples rest endpoints, solves n plus one, and delivers a single JSON response.

Design microservices with a hybrid rest and gRPC architecture to optimize internal communication for low latency and reduced overhead, while using rest for public APIs.

Direct client-to-service calls burden apps with multiple protocols and data aggregation. Use a unified entrypoint via API gateway or backend for frontend patterns to simplify communication and reduce coupling.

Learn how an API gateway serves as a single entry point for clients, routing and aggregating requests to microservices, handling authentication, rate limiting, logging, and protocol translation.

Explore a dotnet api gateway built with yarp to route web client requests to catalog, basket, and ordering microservices, utilizing service discovery, reverse proxy routing, and distributed traces.

Adopt backend for frontend design to deliver client-specific APIs and tailored data payloads, moving data shaping from clients to backend to meet diverse web and mobile UI requirements.

Design microservices with a backend for frontend pattern using separate web and mobile BFF layers to tailor optimized APIs for each client and enable independent evolution. Weigh benefits against complexity.

Master the service aggregator pattern to deliver a single composite response from multiple microservices via the API gateway, and explore service registry discovery for dynamic microservice locations.

Examine why long running operations fail with synchronous communication in multi-step workflows like placing an order, and embrace non-blocking, asynchronous message based architecture for resilient order fulfillment.

Learn how microservices use asynchronous communication and event driven architecture to decouple producers and consumers, leveraging message brokers for fanout pub/sub patterns and reliable delivery.

Explore asynchronous communication types: one-to-one point-to-point queues and one-to-many publish-subscribe topics. Learn how producers and consumers decouple, enable event-driven architectures, and replay historical events using technologies like RabbitMQ and Kafka.

Explore event-driven architecture and the publish/subscribe pattern, where publishers emit events to an event bus, subscribers consume asynchronously, enabling decoupling, scalability, resilience, and responsive systems.

Designs an eShop microservices architecture using event-driven design with a central event bus and publish-subscribe pattern, enabling decoupled services, price change and order events, scalability, and eventual consistency.

Explore a dotnet microservices architecture using event-driven design with RabbitMQ, as catalog and basket services publish and subscribe to product price change and basket checkout events to update orders asynchronously.

Explore the scale cube axes: horizontal, functional decomposition, and data partitioning, and learn how stateful databases complicate horizontal scaling, with stateless microservices scaling easily behind a load balancer.

Explore why databases become bottlenecks as microservices scale, despite stateless client and gateway scaling, and learn horizontal scaling approaches, including data partitioning, sharding, replication, and SQL and NoSQL options.

Learn how the database-per-service pattern gives each microservice its own private database, enabling polyglot persistence and independent scaling, while avoiding cross-service joins and relying on API calls for data.

Explore relational and NoSQL databases, comparing schemas, transactions, and access patterns, and identify document, keyValue, column, and graph models for microservice architectures.

Choose databases for microservices by matching data types and access patterns, balancing consistency, availability, and partition tolerance per the cap theorem, using polyglot persistence.

Explore data partitioning techniques horizontal sharding, vertical partitioning, and functional partitioning, and learn how partitioning boosts scalability, availability, performance, and manageability in microservice architectures.

Learn the database sharding pattern to horizontally partition data into shards using a shard key, with geo sharding illustrated by Tinder and supported by Cassandra NoSQL's masterless architecture.

Design a microservices architecture using database sharding to scale order data, improve performance, and ensure high availability, with shard keys and distributed NoSQL options like Cassandra and DynamoDB.

Analyze cross-service queries and write commands on distributed, sharded microservice databases; apply materialized view, design patterns, and event sourcing to enable separated reads and writes at scale and distributed transactions.