Questions 101-125: Microservices, API Gateway, Service Communication & Event-Driven Architecture.
Open a question for the full answer, code and interview guidance.
A monolithic architecture deploys the application's major capabilities as one application unit. Modules may be logically separated in code, but they are normally built and deployed together and often run in the same process.
A modular monolith is a single deployable application divided into well-defined business modules with controlled dependencies and explicit contracts.
Microservices architecture divides a system into independently deployable services aligned with business capabilities. Each service owns its behavior and typically controls its own data boundary.
A monolith has fewer deployment and network boundaries, which usually makes development and operations simpler. Microservices provide stronger deployment independence and can scale business capabilities separately.
Consider microservices when specific parts of a system need independent scaling, release cadence, fault isolation, technology choices, or team ownership and the monolith's current boundaries prevent those goals.
Service decomposition is the process of deciding how a larger system should be divided into independently owned capabilities or services.
A bounded context is a Domain-Driven Design boundary within which a domain model and its terminology have a specific meaning. The same real-world concept may be modeled differently in another context.
Independent data ownership prevents services from becoming tightly coupled through a shared database schema. A service can change its internal schema without requiring every other service to coordinate.
A shared database allows services to bypass each other's contracts and depend directly on internal tables. Schema changes then require cross-service coordination and can undermine independent deployment.
An API Gateway is an entry point that routes client requests to backend services and can centralize selected edge concerns such as authentication, TLS termination, rate limiting, routing, and response aggregation.
A Backend for Frontend provides a backend layer tailored to a specific client type such as web, mobile, or administration. Each BFF can aggregate or shape data according to that client's requirements.
Service discovery allows applications to locate service instances without hard-coding individual server addresses. It is important when instances are created, replaced, or scaled dynamically.
Synchronous communication requires the caller to wait for the downstream service to respond, commonly through HTTP or gRPC.
Asynchronous communication lets a producer publish a message or event without waiting for the consumer to complete its work. The consumer processes the message independently.
REST over HTTP is appropriate when services need request-response communication, broad interoperability, resource-oriented APIs, and standard web infrastructure.
gRPC is useful for strongly typed, high-performance remote procedure calls, especially for internal service-to-service communication. It uses Protocol Buffers and supports features such as streaming.
REST commonly uses HTTP with JSON and resource-oriented conventions, making it broadly interoperable and easy for web clients to consume. gRPC typically uses HTTP/2 with Protocol Buffers and strongly typed service contracts.
Event-driven architecture organizes communication around events representing facts that have occurred, such as OrderPlaced or PaymentCompleted. Producers publish events without needing to know all interested consumers.
A command expresses a request or intention for a specific action to occur, such as ChargePayment. An event describes a fact that has already occurred, such as PaymentCharged.
An integration event communicates a meaningful fact across service or bounded-context boundaries. It is part of an external contract and should be designed for consumers that do not share the producer's internal domain model.
Contracts should evolve in ways that minimize breaking existing consumers. Additive changes are generally easier to tolerate than removing or changing the meaning of existing fields.
An Anti-Corruption Layer translates between an external system's model and the application's own model. It prevents foreign terminology, schemas, and design decisions from spreading through the internal domain.
The Strangler Fig pattern incrementally replaces a legacy system by routing selected capabilities to a new implementation while the remaining functionality continues to use the old system.
A distributed monolith is a system split into multiple deployable services that remain so tightly coupled that they must change, deploy, or be available together.
Define services around cohesive business capabilities, give them clear data ownership, minimize synchronous dependencies, and design contracts that allow independent evolution.