Introduction

Microservices is a relatively new term in the world of software engineering. The microservice architectural style lets us develop a single application as an aggregation of small services. Each independent service will be lightweight mechanisms working on a specific scope, often with the support of an HTTP resource API. One desirable feature of microservice is that each service will be a unit of software that is independently replaceable and upgradeable.  

Is it a boon?

• Small and Easy to Understand:  The services are compact and thus it requires less code thereby making it easy for the developer to understand individual services. The services are small enough that maintenance becomes easy and less time-consuming.

• Technology stack: With the use of microservices, your technology stack is never limited. The use of right technology for each service will bring out maximum efficiency. You remain more flexible with each service using the lesser code and the best technology.

• Resilience / Fault Isolation: Large systems remain unaffected by the failure of a single service. If one of the micro-services stop working – only a small module of the whole system is affected.

• Code Reusability: A service with standardized output for different platform helps us in using the same service for different contexts. 

• Maintenance And Monitoring: Due to its distributed architecture, it becomes easy for a new developer to understand the functionality of a service. Thus, the maintenance and monitoring of a service will tend to consume lesser time.

• Easy to enhance: Each service is less dependent on other services and thus is easy to change, enhance and test.

• Scalability: The microservices architecture gives you the freedom to scale only the service that handles the bigger load. This helps us make keep the system efficient and economical.

Microservices come with its own challenges!

Although software development is moving in the direction modularity, it will come up with its margin of complications.

The communication between microservices should be carefully handled. The requests traveling between modules should not be broken. Faulty communication between modules will cause inconsistent output.

Management of multiple databases can be painful with microservices.
Finding out bugs can be cumbersome. Since the application is an aggregation of small services, finding the origin of the bug will be difficult. Reproduction of an issue will prove to really hectic. 

One worth serious consideration for enterprise applications is microservice. A simple and straightforward application can use monolithic architecture but it will become a maintenance nightmare if used for a larger/enterprise applications. Despite drawbacks and implementations challenges, the microservices architecture is superior for complex and evolving applications. The exertion of MicroServices by giants like NetFlix, Amazon, eBay, and others, provides enough mettle that this architectural style is here to stay.