There’s some good reasons to break up a system into one or more smaller services.
Wikipedia does a pretty good job here:
Modularity: This makes the application easier to understand, develop, test, and become more resilient to architecture erosion. This benefit is often argued in comparison to the complexity of monolithic architectures.
What this is saying is that in a monolithic system, the boundaries in the application architecture are easy to break and leak, which can cause monolithic systems that start with clean seperation of concerns into well designed modules layered or composed together can over time erode where those seperation are slowly broken over time and everything becomes one big ball of mud. I’d say Clojure is less prone to this, since its primitives tend to be simpler: pure functions and immutable data, but it can still happen.
Scalability: Since microservices are implemented and deployed independently of each other, i.e. they run within independent processes, they can be monitored and scaled independently.
Think that’s self-explanatory.
Integration of heterogeneous and legacy systems: microservices is considered as a viable mean for modernizing existing monolithic software application. There are experience reports of several companies who have successfully replaced (parts of) their existing software by microservices, or are in the process of doing so. The process for Software modernization of legacy applications is done using an incremental approach.
Sometimes it can be easier to refactor a big system by breaking it piece by piece into smaller services.
Distributed development: it parallelizes development by enabling small autonomous teams to develop, deploy and scale their respective services independently. It also allows the architecture of an individual service to emerge through continuous refactoring. Microservice-based architectures facilitate continuous integration, continuous delivery and deployment.
This is the most important one in my opinion, in that with care you can build a monolithic system that doesn’t have its architecture erode, you can manage to measure and scale appropriately, and you can successfully refactor a legacy one without breaking it down into seperate services, but with a monolithic system you really can’t achieve distributed development, especially with regards to distributed independent deployments/delivery.
All from: Microservices - Wikipedia