What are microservices and how do they differ from a monolithic architecture?

Direct Answer

A monolith deploys a set of application capabilities together as one unit. Microservices divide capabilities into separately deployable services with explicit network contracts and team ownership. A microservice often owns its persistence boundary, but separate physical databases are a design choice; a monolith can still be modular and can use several databases.

Code Example

// MONOLITH: one app, one DB, an in-process call wrapped in one transaction
@Service
class CheckoutService {
    @Transactional
    public void checkout(Order order) {
        orderRepo.save(order);
        inventoryRepo.decrement(order.productId()); // same DB, atomic
    }
}

// MICROSERVICES: separate services over the network, no shared transaction
@Service
class OrderService {
    private final WebClient inventory; // points at inventory-service
    public void checkout(Order order) {
        orderRepo.save(order);                    // OrderService DB
        inventory.post().uri("/reserve")          // network call
            .bodyValue(order).retrieve()
            .toBodilessEntity().block();          // can fail independently
    }
}

Common Mistakes & Pitfalls

• Premature microservices: Freshers often advocate splitting a greenfield project into microservices immediately because it sounds modern. This creates complexity before you understand your domain boundaries, leading to services that constantly need to call each other—negating independence.
• Ignoring the distributed data problem: Assuming you can join data across services like in a monolith. In microservices, UserService and OrderService have separate databases—you can't write a SQL join. You need API calls, data duplication, or event sourcing, which freshers underestimate.
• Overlooking operational costs: Not realizing that 10 microservices mean 10 deployment pipelines, 10 log streams, 10 health checks, and 10 places where things can fail. Monoliths have one deployment, one log file, one debugger session.