What are Microservices?

Microservices (or microservices architecture) is an architectural approach in which a single application is composed of many loosely coupled and independently deployable smaller components, or services organised around business capabilities.

What is Monolithic Architecture?

A monolithic architecture is the traditional unified model for the design of a software program. Monolithic Architecture is like a big container, wherein all the software components of an app are assembled and tightly coupled, i.e., each component fully depends on each other.

How Microservices architecture makes Developer life easy?

• Highly maintainable and testable - enables rapid and frequent development and deployment
• Loosely coupled with other services - enables a team to work independently the majority of time on their service(s) without being impacted by changes to other services and without affecting other services
• Independently deployable - enables a team to deploy their service without having to coordinate with other teams
• Capable of being developed by a small team - essential for high productivity by avoiding the high communication head of large teams

When should you use Microservices?

Any architectural style has trade-offs: strengths and weaknesses that we must evaluate according to the context that it's used. This is certainly the case with microservices. While it's a useful architecture - many, indeed most, situations would do better with a monolith.

Microservices provide benefits…

• Strong Module Boundaries: Microservices reinforce modular structure, which is particularly important for larger teams.
• Independent Deployment: Simple services are easier to deploy, and since they are autonomous, are less likely to cause system failures when they go wrong.
• Technology Diversity: With microservices you can mix multiple languages, development frameworks and data-storage technologies.

…but come with costs

• Distribution: Distributed systems are harder to program, since remote calls are slow and are always at risk of failure.
• Eventual Consistency: Maintaining strong consistency is extremely difficult for a distributed system, which means everyone has to manage eventual consistency.
• Operational Complexity: You need a mature operations team to manage lots of services, which are being redeployed regularly.

Conclusion

Building complex applications is inherently difficult. A Monolithic architecture only makes sense for simple, lightweight applications. You will end up in a world of pain if you use it for complex applications. The Microservices architecture pattern is the better choice for complex, evolving applications despite the drawbacks and implementation challenges.

References: https://microservices.io/patterns/microservices.html
https://www.nginx.com/blog/introduction-to-microservices
https://eventuate.io/exampleapps.html