Microservices Architecture 2025 Complete Guide: From Monolith to MSA, and Back to Modular Monolith

┌─────────────────────────────────────┐
│           Monolith Application      │
│  ┌─────────┐ ┌─────────┐ ┌───────┐ │
│  │  User    │ │  Order  │ │Payment│ │
│  │  Module  │ │  Module │ │Module │ │
│  └────┬─────┘ └────┬────┘ └──┬────┘ │
│       └──────┬─────┴─────────┘      │
│         ┌────▼────┐                 │
│         │  Shared │                 │
│         │   DB    │                 │
│         └─────────┘                 │
└─────────────────────────────────────┘

┌────────┐    ┌────────┐    ┌────────┐
│Service A│    │Service B│    │Service C│
└───┬─────┘    └───┬─────┘    └───┬─────┘
    └──────────────┼──────────────┘
              ┌────▼────┐
              │   ESB   │
              │(Message │
              │  Bus)   │
              └─────────┘

┌─────────┐   ┌─────────┐   ┌─────────┐
│ User    │   │ Order   │   │ Payment │
│ Service │   │ Service │   │ Service │
│  :8080  │   │  :8081  │   │  :8082  │
└──┬──────┘   └──┬──────┘   └──┬──────┘
   │  REST/gRPC  │   Event    │
   ▼             ▼            ▼
┌──────┐    ┌──────┐    ┌──────┐
│UserDB│    │OrderDB│   │PayDB │
└──────┘    └──────┘    └──────┘

Timeline:
2000 ──── 2005 ──── 2014 ──── 2020 ──── 2025
 │         │         │         │         │
 ▼         ▼         ▼         ▼         ▼
Monolith  SOA    Microservices Service   Modular
                               Mesh      Monolith
                               Spread    Resurgence

# Module boundary definition using Shopify's Packwerk
# packages/checkout/package.yml
enforce_dependencies: true
enforce_privacy: true
dependencies:
  - packages/inventory
  - packages/payment

┌─────────────────────────────────────────────┐
│            Modular Monolith                 │
│                                             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │  User   │  │  Order  │  │ Payment │    │
│  │ Module  │  │ Module  │  │ Module  │    │
│  │         │  │         │  │         │    │
│  │ Public  │  │ Public  │  │ Public  │    │
│  │   API   │◄─►   API   │◄─►   API   │    │
│  │         │  │         │  │         │    │
│  │ Private │  │ Private │  │ Private │    │
│  │  Impl   │  │  Impl   │  │  Impl   │    │
│  └──┬──────┘  └──┬──────┘  └──┬──────┘    │
│     │            │            │            │
│  ┌──▼──┐     ┌──▼──┐     ┌──▼──┐         │
│  │user │     │order│     │pay  │         │
│  │schema│    │schema│    │schema│         │
│  └─────┘     └─────┘     └─────┘         │
│     └────────────┼────────────┘            │
│           ┌──────▼──────┐                  │
│           │  Shared DB  │                  │
│           │(Separated   │                  │
│           │  Schemas)   │                  │
│           └─────────────┘                  │
└─────────────────────────────────────────────┘

// Java modular monolith example (Spring Modulith)
@ApplicationModule(
    allowedDependencies = {"order", "shared"}
)
package com.example.payment;

// Inter-module communication via events
@Service
public class PaymentService {

    private final ApplicationEventPublisher events;

    @Transactional
    public PaymentResult processPayment(PaymentRequest request) {
        Payment payment = Payment.create(request);
        paymentRepository.save(payment);

        // Publish event to other modules (no direct dependency)
        events.publishEvent(new PaymentCompletedEvent(
            payment.getId(),
            payment.getOrderId(),
            payment.getAmount()
        ));

        return PaymentResult.success(payment);
    }
}

Start: New Project
  │
  ▼
Team size > 50? ──Yes──▶ Are domains clearly separated?
  │                                    │
  No                                  Yes ──▶ Consider MSA
  │                                    │
  ▼                                   No ──▶ Modular Monolith
Need independently scalable services?
  │
  Yes ──▶ Extract only those services (Hybrid)
  │
  No ──▶ Monolith or Modular Monolith

┌─────────────── E-Commerce Domain ───────────────┐
│                                                  │
│  ┌──────────────┐    ┌──────────────┐           │
│  │  Catalog     │    │  Order       │           │
│  │  Context     │    │  Context     │           │
│  │              │    │              │           │
│  │ - Product    │    │ - Order      │           │
│  │ - Category   │    │ - OrderItem  │           │
│  │ - Price      │    │ - Shipment   │           │
│  └──────────────┘    └──────────────┘           │
│                                                  │
│  ┌──────────────┐    ┌──────────────┐           │
│  │  Identity    │    │  Payment     │           │
│  │  Context     │    │  Context     │           │
│  │              │    │              │           │
│  │ - User       │    │ - Payment    │           │
│  │ - Role       │    │ - Refund     │           │
│  │ - Permission │    │ - Invoice    │           │
│  └──────────────┘    └──────────────┘           │
└──────────────────────────────────────────────────┘

┌────────────┐                    ┌────────────┐
│  Upstream  │                    │ Downstream │
│  Context   │ ──Conformist────▶  │  Context   │
│            │                    │            │
│  (Order)   │ ──ACL──────────▶  │ (Payment)  │
│            │                    │            │
│            │ ──OHS/PL───────▶  │ (Shipping) │
└────────────┘                    └────────────┘

ACL: Anti-Corruption Layer (translation layer)
OHS: Open Host Service (public API)
PL:  Published Language (shared schema)

// 1. Decomposition by Aggregate
// Order Aggregate Root
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderLine> lines;
    private OrderStatus status;
    private Money totalAmount;

    // Business logic within the aggregate
    public void addItem(ProductId productId, int quantity, Money price) {
        OrderLine line = new OrderLine(productId, quantity, price);
        this.lines.add(line);
        this.totalAmount = calculateTotal();
    }

    public void confirm() {
        if (this.lines.isEmpty()) {
            throw new OrderException("Cannot confirm an empty order");
        }
        this.status = OrderStatus.CONFIRMED;
    }
}

// order_service.proto
syntax = "proto3";

package order.v1;

service OrderService {
  // Unary RPC
  rpc CreateOrder (CreateOrderRequest) returns (CreateOrderResponse);

  // Server streaming - order status updates
  rpc WatchOrderStatus (WatchRequest) returns (stream OrderStatusUpdate);

  // Client streaming - bulk order registration
  rpc BulkCreateOrders (stream CreateOrderRequest) returns (BulkCreateResponse);

  // Bidirectional streaming - real-time order processing
  rpc ProcessOrders (stream OrderAction) returns (stream OrderResult);
}

message CreateOrderRequest {
  string customer_id = 1;
  repeated OrderItem items = 2;
  ShippingAddress shipping = 3;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  int64 price_cents = 3;
}

message CreateOrderResponse {
  string order_id = 1;
  OrderStatus status = 2;
  int64 total_cents = 3;
}

enum OrderStatus {
  ORDER_STATUS_UNSPECIFIED = 0;
  ORDER_STATUS_PENDING = 1;
  ORDER_STATUS_CONFIRMED = 2;
  ORDER_STATUS_SHIPPED = 3;
  ORDER_STATUS_DELIVERED = 4;
}

Producer                         Consumer
┌─────────┐    ┌─────────┐    ┌─────────┐
│ Order   │───▶│  Kafka  │───▶│ Payment │
│ Service │    │ Topic:  │    │ Service │
│         │    │ orders  │    │         │
└─────────┘    └─────────┘    └─────────┘
                    │
                    ├────────▶ ┌─────────┐
                    │          │Inventory│
                    │          │ Service │
                    │          └─────────┘
                    │
                    └────────▶ ┌─────────┐
                               │Notific- │
                               │ation    │
                               │ Service │
                               └─────────┘

// Kafka Producer - publish order events
@Service
public class OrderEventPublisher {

    private final KafkaTemplate<String, OrderEvent> kafkaTemplate;

    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = OrderCreatedEvent.builder()
            .orderId(order.getId())
            .customerId(order.getCustomerId())
            .items(order.getItems())
            .totalAmount(order.getTotalAmount())
            .timestamp(Instant.now())
            .build();

        kafkaTemplate.send("orders.created", order.getId(), event)
            .whenComplete((result, ex) -> {
                if (ex != null) {
                    log.error("Event publish failed: orderId={}",
                        order.getId(), ex);
                    // Compensation logic or retry
                }
            });
    }
}

// Kafka Consumer - payment processing
@Service
public class PaymentEventConsumer {

    @KafkaListener(
        topics = "orders.created",
        groupId = "payment-service",
        containerFactory = "kafkaListenerContainerFactory"
    )
    public void handleOrderCreated(OrderCreatedEvent event) {
        log.info("Order event received: orderId={}", event.getOrderId());
        paymentService.processPayment(event);
    }
}

Need synchronous call?
  │
  Yes ──▶ For external clients?
  │          │
  │        Yes ──▶ REST (OpenAPI)
  │          │
  │        No ──▶ Need high performance? ──Yes──▶ gRPC
  │                    │
  │                  No ──▶ REST
  │
  No ──▶ Need ordering guarantee?
            │
          Yes ──▶ Kafka (ordering via partition key)
            │
          No ──▶ Need fan-out?
                    │
                  Yes ──▶ SNS + SQS / Kafka topics
                    │
                  No ──▶ SQS / RabbitMQ

Without Service Mesh:          With Service Mesh:

┌─────────┐  ┌─────────┐     ┌─────────┐  ┌─────────┐
│Service A│──│Service B│     │Service A│  │Service B│
│         │  │         │     │ ┌─────┐ │  │ ┌─────┐ │
│(retry,  │  │(retry,  │     │ │Proxy│─┼──┼─│Proxy│ │
│ auth,   │  │ auth,   │     │ │(side│ │  │ │(side│ │
│ metrics)│  │ metrics)│     │ │car) │ │  │ │car) │ │
└─────────┘  └─────────┘     │ └─────┘ │  │ └─────┘ │
                              └─────────┘  └─────────┘
   Communication logic          Cross-cutting concerns
   in every service             delegated to infrastructure

# VirtualService - Canary Deployment
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - match:
        - headers:
            x-canary:
              exact: "true"
      route:
        - destination:
            host: order-service
            subset: v2
    - route:
        - destination:
            host: order-service
            subset: v1
          weight: 90
        - destination:
            host: order-service
            subset: v2
          weight: 10
---
# DestinationRule - Circuit Breaker
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        h2UpgradePolicy: DEFAULT
        http1MaxPendingRequests: 100
        http2MaxRequests: 1000
    outlierDetection:
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
  subsets:
    - name: v1
      labels:
        version: v1
    - name: v2
      labels:
        version: v2

Order creation scenario:
1. Order Service: Create order
2. Inventory Service: Reserve stock
3. Payment Service: Process payment
4. Notification Service: Send notification

What if payment fails at step 3?
-> Steps 1 and 2 need to be rolled back!

┌─────────┐  OrderCreated  ┌─────────┐  StockReserved  ┌─────────┐
│  Order  │──────────────▶│Inventory│───────────────▶│ Payment │
│ Service │               │ Service │                │ Service │
└─────────┘               └─────────┘                └─────────┘
     ▲                         ▲                          │
     │    StockRelease         │   PaymentFailed          │
     │    (compensate)         │◀──────────────────────────┘
     │◀────────────────────────┘
     │    OrderCancelled (compensate)

                    ┌────────────────┐
                    │  Order Saga    │
                    │  Orchestrator  │
                    └───┬──┬──┬──┬──┘
           1.Create    │  │  │  │  4.Notify
            Order ┌────┘  │  │  └──────┐
                  ▼       │  │         ▼
          ┌─────────┐     │  │   ┌──────────┐
          │  Order  │     │  │   │Notificat-│
          │ Service │     │  │   │ion Svc   │
          └─────────┘     │  │   └──────────┘
              2.Reserve   │  │  3.Payment
                Stock┌────┘  └─────┐
                     ▼              ▼
              ┌─────────┐   ┌─────────┐
              │Inventory│   │ Payment │
              │ Service │   │ Service │
              └─────────┘   └─────────┘

// Saga Orchestrator Implementation
@Service
public class OrderSagaOrchestrator {

    public Mono<OrderResult> createOrder(CreateOrderCommand command) {
        return Mono.just(new SagaState(command))
            // Step 1: Create order
            .flatMap(state -> orderService.createOrder(state.getCommand())
                .map(order -> state.withOrder(order)))

            // Step 2: Reserve stock
            .flatMap(state -> inventoryService
                .reserveStock(state.getOrder())
                .map(reservation -> state.withReservation(reservation))
                .onErrorResume(e -> compensateOrder(state, e)))

            // Step 3: Process payment
            .flatMap(state -> paymentService
                .processPayment(state.getOrder())
                .map(payment -> state.withPayment(payment))
                .onErrorResume(e ->
                    compensateReservation(state, e)))

            // Step 4: Complete
            .flatMap(state -> {
                orderService.confirmOrder(
                    state.getOrder().getId());
                return Mono.just(OrderResult.success(state));
            });
    }

    private Mono<SagaState> compensateReservation(
            SagaState state, Throwable e) {
        log.warn("Payment failed, starting stock compensation: orderId={}",
            state.getOrder().getId());
        return inventoryService
            .releaseStock(state.getReservation())
            .then(compensateOrder(state, e));
    }

    private Mono<SagaState> compensateOrder(
            SagaState state, Throwable e) {
        log.warn("Starting order compensation: orderId={}",
            state.getOrder().getId());
        return orderService
            .cancelOrder(state.getOrder().getId())
            .then(Mono.error(
                new SagaFailedException("Saga failed", e)));
    }
}

         ┌─────────────┐
         │ Observability│
         └──────┬──────┘
     ┌──────────┼──────────┐
     ▼          ▼          ▼
┌─────────┐ ┌──────┐ ┌─────────┐
│  Logs   │ │Metrics│ │ Traces │
│(events) │ │(values)│ │(request │
└─────────┘ └──────┘ │ flow)  │
 What        How much └─────────┘
 happened?   is happening? Where?

┌─────────────────────────────────────────────────────┐
│                    Application                      │
│  ┌─────────────────────────────────────────────┐   │
│  │        OpenTelemetry SDK                    │   │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐   │   │
│  │  │  Tracer  │ │  Meter   │ │  Logger  │   │   │
│  │  └──────────┘ └──────────┘ └──────────┘   │   │
│  └────────────────────┬────────────────────────┘   │
└───────────────────────┼─────────────────────────────┘
                        │ OTLP
                        ▼
              ┌─────────────────┐
              │  OTel Collector │
              │  ┌───────────┐  │
              │  │ Receivers │  │
              │  │Processors│  │
              │  │ Exporters │  │
              │  └───────────┘  │
              └────┬──┬──┬──────┘
                   │  │  │
          ┌────────┘  │  └────────┐
          ▼           ▼           ▼
     ┌─────────┐ ┌────────┐ ┌─────────┐
     │  Jaeger │ │Promethe│ │  Loki   │
     │ (Traces)│ │us/Mimir│ │ (Logs)  │
     │         │ │(Metrics│ │         │
     └─────────┘ └────────┘ └─────────┘
          │           │           │
          └─────┬─────┘───────────┘
                ▼
          ┌───────────┐
          │  Grafana  │
          │(Dashboard)│
          └───────────┘

// Spring Boot + OpenTelemetry auto-configuration
// build.gradle
// implementation 'io.opentelemetry.instrumentation:
//   opentelemetry-spring-boot-starter'

// Custom span creation
@Service
public class OrderService {

    private final Tracer tracer;

    public Order createOrder(CreateOrderRequest request) {
        Span span = tracer.spanBuilder("order.create")
            .setAttribute("order.customer_id",
                request.getCustomerId())
            .setAttribute("order.item_count",
                request.getItems().size())
            .startSpan();

        try (Scope scope = span.makeCurrent()) {
            // Order creation logic
            Order order = processOrder(request);

            span.setAttribute("order.id", order.getId());
            span.setAttribute("order.total",
                order.getTotal().doubleValue());
            span.setStatus(StatusCode.OK);

            return order;
        } catch (Exception e) {
            span.setStatus(StatusCode.ERROR, e.getMessage());
            span.recordException(e);
            throw e;
        } finally {
            span.end();
        }
    }
}

RED Method (Service perspective):
┌──────────────────────────────────────┐
│ R - Rate:     Requests per second    │
│ E - Errors:   Error rate (%)         │
│ D - Duration: Response time          │
│               (p50/p95/p99)          │
└──────────────────────────────────────┘

USE Method (Resource perspective):
┌──────────────────────────────────────┐
│ U - Utilization: Resource usage rate │
│ S - Saturation:  Queue length        │
│ E - Errors:      Resource error count│
└──────────────────────────────────────┘

                    ┌─────────────────────┐
                    │    API Gateway      │
   Client ────────▶│                     │
                    │ - Auth/AuthZ        │
                    │ - Rate Limiting     │
                    │ - Request Routing   │
                    │ - Load Balancing    │
                    │ - Response Caching  │
                    │ - Request/Response  │
                    │   Transformation    │
                    │ - Circuit Breaker   │
                    │ - Logging/Monitoring│
                    └──┬──────┬──────┬────┘
                       │      │      │
                       ▼      ▼      ▼
                    ┌─────┐┌─────┐┌─────┐
                    │Svc A││Svc B││Svc C│
                    └─────┘└─────┘└─────┘

┌────────┐     ┌──────────────┐
│  Web   │────▶│  Web BFF     │──┐
│ Client │     │(GraphQL)     │  │
└────────┘     └──────────────┘  │
                                 │    ┌──────────┐
┌────────┐     ┌──────────────┐  ├───▶│ Order    │
│ Mobile │────▶│ Mobile BFF   │──┤    │ Service  │
│  App   │     │(REST, light) │  │    └──────────┘
└────────┘     └──────────────┘  │
                                 │    ┌──────────┐
┌────────┐     ┌──────────────┐  ├───▶│ User     │
│  IoT   │────▶│  IoT BFF     │──┤    │ Service  │
│ Device │     │(MQTT bridge) │  │    └──────────┘
└────────┘     └──────────────┘  │
                                 │    ┌──────────┐
                                 └───▶│ Product  │
                                      │ Service  │
                                      └──────────┘

Phase 1: Blue (current) running
┌─────────────┐     ┌──────────┐
│ Load        │────▶│ Blue v1  │  (100% traffic)
│ Balancer    │     │ (Active) │
└─────────────┘     └──────────┘
                    ┌──────────┐
                    │ Green v2 │  (idle)
                    │ (Idle)   │
                    └──────────┘

Phase 2: Switch to Green
┌─────────────┐     ┌──────────┐
│ Load        │     │ Blue v1  │  (idle)
│ Balancer    │     │ (Idle)   │
└─────────────┘     └──────────┘
       │            ┌──────────┐
       └───────────▶│ Green v2 │  (100% traffic)
                    │ (Active) │
                    └──────────┘

# Kubernetes + Argo Rollouts canary deployment
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: order-service
spec:
  replicas: 10
  strategy:
    canary:
      steps:
        - setWeight: 5
        - pause:
            duration: 5m
        - analysis:
            templates:
              - templateName: success-rate
            args:
              - name: service-name
                value: order-service
        - setWeight: 25
        - pause:
            duration: 10m
        - analysis:
            templates:
              - templateName: success-rate
        - setWeight: 50
        - pause:
            duration: 15m
        - setWeight: 100
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: order-service:v2
          ports:
            - containerPort: 8080

Phase 1: Place proxy
┌────────┐     ┌──────────┐     ┌────────────┐
│ Client │────▶│  Proxy   │────▶│  Monolith  │
└────────┘     │(Facade)  │     │(all funcs) │
               └──────────┘     └────────────┘

Phase 2: Extract some features
┌────────┐     ┌──────────┐     ┌────────────┐
│ Client │────▶│  Proxy   │─┬──▶│  Monolith  │
└────────┘     │          │ │   │(reduced)   │
               └──────────┘ │   └────────────┘
                            │
                            └──▶┌────────────┐
                                │ New Service│
                                │(extracted) │
                                └────────────┘

Phase 3: Most features migrated
┌────────┐     ┌──────────┐     ┌────────────┐
│ Client │────▶│  Proxy   │─┬──▶│  Monolith  │
└────────┘     │          │ │   │(minimal)   │
               └──────────┘ │   └────────────┘
                            │
                            ├──▶┌────────────┐
                            │   │ Service A  │
                            │   └────────────┘
                            ├──▶┌────────────┐
                            │   │ Service B  │
                            │   └────────────┘
                            └──▶┌────────────┐
                                │ Service C  │
                                └────────────┘

Phase 4: Remove monolith
┌────────┐     ┌──────────┐
│ Client │────▶│  API GW  │─┬──▶ Service A
└────────┘     └──────────┘ ├──▶ Service B
                            └──▶ Service C

1. Analysis (2-4 weeks)
   ├── Domain modeling (Event Storming)
   ├── Dependency analysis (code/data)
   └── Priority determination

2. Foundation (4-8 weeks)
   ├── CI/CD pipeline
   ├── Container/orchestration environment
   ├── Observability stack
   └── API Gateway placement

3. First service extraction (4-6 weeks)
   ├── Select most independent domain
   ├── Implement Anti-Corruption Layer
   ├── Data migration
   └── Dual write / Event bridge

4. Iterative extraction (2-4 weeks per service)
   ├── Extract next service
   ├── Remove monolith code
   └── Integration testing

5. Monolith removal
   ├── Migrate remaining features
   ├── Data cleanup
   └── Infrastructure decommission

// Dual Write Pattern - write to both during transition
@Service
public class UserServiceMigration {

    private final MonolithUserRepository monolithRepo;
    private final NewUserServiceClient newServiceClient;
    private final FeatureFlag featureFlag;

    public User createUser(CreateUserRequest request) {
        // Always write to monolith (existing)
        User user = monolithRepo.save(toEntity(request));

        // Also write to new service (migration)
        try {
            newServiceClient.createUser(
                toNewServiceRequest(user));
        } catch (Exception e) {
            log.warn("New service sync failed, will retry later", e);
            migrationQueue.enqueue(new SyncEvent(user));
        }

        return user;
    }

    public User getUser(String userId) {
        // Switch reads using Feature Flag
        if (featureFlag.isEnabled("read-from-new-service")) {
            try {
                return newServiceClient.getUser(userId);
            } catch (Exception e) {
                log.warn("New service read failed, falling back", e);
                return monolithRepo.findById(userId);
            }
        }
        return monolithRepo.findById(userId);
    }
}

Distributed Monolith Checklist:
[ ] Deploying one service requires deploying others too
[ ] Synchronous call chains span 3+ services
[ ] Multiple services read/write the same database
[ ] Shared library versions must be coordinated across services
[ ] One service failure brings down the entire system
[ ] Service boundaries are drawn by tech layer (front/back/DB)

If 3 or more apply, you likely have a distributed monolith.

Problem: Synchronous chain
Client -> Order -> Inventory -> Payment -> Shipping
                                           (3 sec)
         Total response time: 3 sec + each service processing time
         If any service fails, the entire chain fails

Solution: Async events + immediate response
Client -> Order (200 OK, order accepted)
              |
              +-- Event: OrderCreated
              |        |
              |        +-- Inventory (async)
              |        +-- Payment (async)
              |        +-- Shipping (async)
              |
              +-- Status query API provided

Monolith:
├── Spring Boot + JPA
├── Django + PostgreSQL
├── Rails + PostgreSQL
└── Next.js Full Stack

Modular Monolith:
├── Spring Modulith
├── .NET Aspire
├── Go (module pattern)
└── Rust (Workspace)

Microservices:
├── Communication: gRPC (internal) + REST (external)
├── Messaging: Kafka / RabbitMQ
├── Orchestration: Kubernetes
├── Service Mesh: Istio / Linkerd
├── Observability: OpenTelemetry + Grafana
├── CI/CD: ArgoCD / GitHub Actions
└── API Gateway: Kong / Envoy Gateway