Challenges of microservices versus a monolithic application

package com.bank.service;

import com.bank.model.Account;
import com.bank.repository.AccountRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;

@Service
public class MonolithTransferService {

    private final AccountRepository accountRepository;

    public MonolithTransferService(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }

    @Transactional
    public void transfer(String fromId, String toId, BigDecimal amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();
        from.debit(amount);
        to.credit(amount);
        accountRepository.save(from);
        accountRepository.save(to);
        // One transaction, one database, one stack trace.
    }
}

Expected output (log):
Transfer of 50000.00 from SAV2001 to SAV2002 committed in single transaction.

package com.bank.payment;

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.math.BigDecimal;

@Service
public class PaymentService {

    private final RestTemplate restTemplate;

    public PaymentService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public void transfer(String fromId, String toId, BigDecimal amount) {
        // Network call to Account Service: debit
        restTemplate.postForEntity(
            "http://account-service/api/v1/accounts/" + fromId + "/debit",
            new DebitRequest(amount), Void.class);

        // Network call to Account Service: credit
        restTemplate.postForEntity(
            "http://account-service/api/v1/accounts/" + toId + "/credit",
            new CreditRequest(amount), Void.class);
    }
}

Expected output (log):
Debit request sent to account-service for SAV2001.
Credit request sent to account-service for SAV2002.

package com.bank.saga;

import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.logging.Logger;

@Service
public class TransferSagaOrchestrator {

    private static final Logger LOG = Logger.getLogger(TransferSagaOrchestrator.class.getName());
    private final AccountClient accountClient;

    public TransferSagaOrchestrator(AccountClient accountClient) {
        this.accountClient = accountClient;
    }

    public void executeTransfer(String fromId, String toId, BigDecimal amount) {
        try {
            accountClient.debit(fromId, amount);  // Step 1: local tx in Account Service
            accountClient.credit(toId, amount);    // Step 2: local tx in Account Service
            LOG.info("Transfer saga completed: " + fromId + " -> " + toId);
        } catch (Exception e) {
            // Compensating action: re-credit the sender
            accountClient.credit(fromId, amount);
            LOG.warning("Transfer saga compensated: re-credited " + fromId);
        }
    }
}

Expected output (failure case):
WARNING: Transfer saga compensated: re-credited SAV2001

package com.bank.resilience;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.logging.Logger;

@Service
public class ResilientAccountClient {

    private static final Logger LOG = Logger.getLogger(ResilientAccountClient.class.getName());

    @CircuitBreaker(name = "accountService", fallbackMethod = "debitFallback")
    @Bulkhead(name = "accountService")
    public void debit(String accountId, BigDecimal amount) {
        // Remote call to Account Service with timeout
        // restTemplate.postForEntity(...)
        LOG.info("Debit successful for " + accountId);
    }

    public void debitFallback(String accountId, BigDecimal amount, Throwable t) {
        LOG.warning("Account Service down. Queuing debit for " + accountId);
        // Queue for retry when service recovers
    }
}

Expected output (circuit open):
WARNING: Account Service down. Queuing debit for SAV2001

package com.bank.readmodel;

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import java.util.logging.Logger;

@Component
public class AccountReadModelUpdater {

    private static final Logger LOG = Logger.getLogger(AccountReadModelUpdater.class.getName());
    private final LocalAccountRepository localRepo;

    public AccountReadModelUpdater(LocalAccountRepository localRepo) {
        this.localRepo = localRepo;
    }

    @KafkaListener(topics = "account-events", groupId = "payment-service")
    public void onAccountEvent(AccountEvent event) {
        localRepo.upsert(event.getAccountId(), event.getHolderName(), event.getBalance());
        LOG.info("Read model updated for account: " + event.getAccountId());
    }
}

Expected output:
INFO: Read model updated for account: SAV2001

package com.bank.tracing;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.logging.Logger;

@RestController
public class TransferController {

    private static final Logger LOG = Logger.getLogger(TransferController.class.getName());

    @PostMapping("/api/v1/transfers")
    public void initiateTransfer() {
        // traceId is auto-injected by Micrometer Tracing
        LOG.info("traceId=abc123 Transfer initiated at gateway");
        // Calls to payment-service, account-service, notification-service
        // all carry the same traceId in W3C traceparent header
    }
}

Monolith operational footprint:
  1 repo, 1 pipeline, 1 database, 1 deploy

Microservices operational footprint:
  5+ repos, 5+ pipelines, 5+ databases
  + Service Registry (Eureka/Consul)
  + Config Server (Spring Cloud Config)
  + API Gateway (Spring Cloud Gateway)
  + Container orchestration (Kubernetes)
  + Distributed tracing (Zipkin/Jaeger)
  + Log aggregation (ELK/Loki)
  + Monitoring (Prometheus + Grafana)

package com.bank.decision;

/**
 * Decision framework for monolith vs microservices.
 *
 * Choose MONOLITH when:
 * - Small team (fewer than 10 developers)
 * - Early-stage product with unclear boundaries
 * - Simple domain with few bounded contexts
 * - Speed of initial development is the priority
 *
 * Choose MICROSERVICES when:
 * - Multiple teams need independent deployment
 * - Components have very different scaling needs
 * - Domain is well-understood with clear bounded contexts
 * - Organization can afford the operational investment
 */
public class ArchitectureDecisionRecord {
    // This is a documentation class, not runnable code.
    // The decision is organizational, not technical.
}

package com.bank.antipattern;

// WRONG: Distributed monolith. Two services that always deploy together.
public class WrongTransferService {
    // This service calls LimitCheckService synchronously for EVERY transfer.
    // LimitCheckService shares the same database.
    // They always deploy at the same time.
    // This is NOT microservices. This is a monolith with network hops.
}

// CORRECT: Keep tightly coupled logic in one service.
public class CorrectTransferService {
    // Limit checking is a method inside TransferService.
    // One database, one deploy, one transaction.
    // Split only when a separate team needs independent ownership.
}

Distributed monolith symptoms:
- Services always deploy together
- Shared database between services
- Synchronous chains where A cannot work without B
- Every feature change touches multiple services