Types of Service Architectures

1. Monolithic Architecture

• Definition: Entire application is built as a single unit (all modules tightly coupled).
• Example: A web app where UI, business logic, and database access are in one deployable artifact.
• Pros: Easy to develop, test, and deploy (initially).
• Cons: Hard to scale, maintain, or update parts independently.

2. Layered (n-Tier) Architecture

• Definition: System split into layers (presentation, business logic, data access).
• Example: Classic 3-tier web apps (UI → API/Logic → Database).
• Pros: Separation of concerns, maintainability.
• Cons: Can become rigid and monolithic if layers are tightly coupled.

3. Service-Oriented Architecture (SOA)

• Definition: Business functions exposed as loosely coupled services, often via Enterprise Service Bus (ESB).
• Example: Banking system with services like “AccountService,” “PaymentService,” etc.
• Pros: Reusability, interoperability, standardized contracts (SOAP, WSDL).
• Cons: ESB can become a bottleneck, heavyweight.

4. Microservices Architecture

• Definition: Application broken into small, independently deployable services communicating via lightweight protocols (REST, gRPC, messaging).
• Example: Netflix—each feature (search, recommendation, billing) runs as separate service.
• Pros: Independent scaling, fault isolation, tech flexibility.
• Cons: Complexity in orchestration, observability, and data consistency.

5. Event-Driven Architecture (EDA)

• Definition: Services communicate via asynchronous events (pub/sub, message brokers).
• Example: E-commerce app—when order is placed, “OrderCreated” event triggers inventory, payment, shipping services.
• Pros: Decoupled, scalable, real-time.
• Cons: Harder debugging, eventual consistency challenges.

6. Serverless (FaaS) Architecture

• Definition: Functions run on-demand in cloud (AWS Lambda, Azure Functions), no server management.
• Example: Image upload triggers a function to resize and store images.
• Pros: Pay-per-use, auto-scalable, minimal ops.
• Cons: Cold starts, vendor lock-in, limited runtime.

7. Microkernel (Plug-in) Architecture

• Definition: Core system with extensible plug-ins or modules.
• Example: Eclipse IDE or product-based systems where new features are added as plug-ins.
• Pros: Extensibility, modular.
• Cons: Complexity in managing plug-ins, integration.

8. API-First / API-Led Connectivity

• Definition: System organized around APIs as first-class citizens.
• Example: MuleSoft’s API-led approach with Experience APIs, Process APIs, System APIs.
• Pros: Standardized communication, easy integration.
• Cons: Requires strong API governance.

9. Cloud-Native Architecture

• Definition: Architectures designed for elasticity, scalability, and resilience in cloud (uses containers, Kubernetes, microservices).
• Pros: Cloud-optimized scaling & resilience.
• Cons: Steeper learning curve, requires DevOps maturity.

10. Mesh / Service Mesh Architecture

• Definition: Layer (like Istio, Linkerd) managing service-to-service communication, security, monitoring.
• Pros: Built-in observability, traffic control, security.
• Cons: Added complexity, performance overhead.