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.

Discover how Kiss, Jugni (you ain't gonna need it), and dry guide simple, maintainable software design by avoiding unnecessary complexity and duplication in your app architecture.

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.

The monolithic app stores basket data in memory, so items vanish after a restart; move to durable storage, like a database, to persist carts across restarts.

Redesign a monolithic e-shop with a persistent relational database to ensure data persistence and durability for product catalog, user accounts, shopping cart, and orders across restarts.

Explore a monolithic app updated with PostgreSQL integration, run end-to-end data persistence tests, and observe how DbContext uses the PostgreSQL database in a distributed environment.

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

Discover how three-tier architecture separates presentation, application, and data tiers to enable independent scalability and technology choices, with APIs over http supporting an omnichannel, maintainable, secure system.

Design a three-tier e-shop architecture with a decoupled presentation layer as a single-page app that consumes restful APIs from a refactored ASP.NET Core backend, using PostgreSQL as the data tier.

Explain the three-tier architecture with a spa web app, an api service, and a PostgreSQL database, and show end-to-end flow with distributed tracing.

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.

Growing monolithic backend API creates complexity, slower development, and risk as teams expand; learn to organize the codebase into well-defined, loosely coupled internal modules using modular monolith architecture.

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 a modular monolith architecture and implement Redis-based output caching in a .NET web app, demonstrating cache miss and cache hit behavior via distributed traces.

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.

Learn vertical scaling (scale up) and horizontal scaling (scale out), including their advantages, limitations, and how load balancers, distributed caches, and stateless services enable scalable, fault-tolerant architectures.

Learn how a load balancer acts as a traffic manager for multiple api service instances, distributing requests to improve performance, availability, and fault tolerance.

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.

Explore the iCap application's horizontal scaling by running three API service replicas with dotnet aspire, observe service discovery, load balancing, and distributed requests via logs and traces.

Identify bottlenecks in a scaled monolith that blocks independent feature delivery and scaling, and adopt microservices architecture to empower teams to develop, deploy, and scale features independently.

Explore microservices architecture, featuring small autonomous services with dedicated databases and api communication, enabling agility, independent deployment, and technology diversity, while noting challenges like distributed data and complexity.

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.

Explore a polyglot microservices architecture where catalog, basket, and ordering services each use dedicated databases and api-based communications, with end-to-end tests validating inter-service flows via a web client.

Explore microservices decomposition strategies to break a monolith into independently deployable services aligned with business capabilities like catalog management and ordering, using the scale cube’s y axis guidance.

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.

Explore microservices communication types, synchronous request–response versus asynchronous event-driven patterns, using HTTP/REST/gRPC/GraphQL for synchronous calls and RabbitMQ or Kafka for decoupled, scalable messaging.

Design restful APIs for microservices by focusing on resource-based URLs, standard HTTP methods, and JSON representations; use clear versioning strategies to evolve without breaking clients.

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.

Explore the design of eShop microservices with RESTful API endpoints, focusing on catalog and basket microservices and their synchronous calls to fetch latest prices and details.

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.

Explore inter-service communication in microservices, contrasting public rest APIs with backend internal APIs, and learn how binary protocols like gRPC improve low-latency, high-throughput internal calls.

discover how gRPC delivers high-performance remote procedure calls for microservices, using protocol buffers and http/2 to generate client stubs and server skeletons across languages.

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.

Explore microservices communication patterns with api gateways as a single entry point; route requests, aggregate responses, and offload cross-cutting concerns to simplify client logic and decouple clients from backend services.

Explore three API gateway patterns—routing, aggregation, and offloading—which decouple clients from backend microservices, reduce chattiness, consolidate data, and centralize cross-cutting concerns like authentication, caching, and logging.

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.

Explore how internal microservices communicate via api gateways, how deep synchronous call chains across product, pricing, payment, inventory, and shipping affect latency and availability, and why reducing inter-service calls.

Consolidate data from multiple microservices using aggregate query operations and the service aggregator pattern to reduce latency and avoid tight coupling.

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.

Designs a microservices architecture using a service aggregator and registry/discovery. Aggregates data from ordering, customer, and product services via dynamic location resolution into a single optimized json for order details.

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 microservices data management by choosing relational and NoSQL databases, applying CAP theorem principles and data partitioning, and using patterns like database per service, API composition, and sagas.

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.

Identify when relational SQL databases excel with ACID consistency, structured schemas, and complex queries for reliable transactions. Contrast NoSQL options for flexible schemas and scalable, distributed data models.

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

Examine the bottleneck of a single database server in a microservice with database per service. Explore horizontal, vertical, and functional partitioning to distribute data, improve queries, and scale.

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.