Microservices Architecture: Future of Software Architecture?

We use a lot of Microservices in our day-to-day lives without even realizing it because they generally do the same task but in a more efficient and more rapid manner. Let’s discuss, how they are more efficient when compared to the “Monolithic” Architecture world. It’s very interesting and informative. There are real-time examples that use Microservice Architecture given at the end of the article but before it’s important to understand this paradigm.

Photo by Tim J on Unsplash

Cloud Computing Generation

We are living in a cloud computing generation where every other thing resides on very huge servers having immense computing power and very large storage capacity. Companies these days deploy their code in these remote servers where they run 24*7 with ~0ms downtime.
When servers are being so reliable, generally everyone expects the Apps which are running on these servers should also be available 24*7 and without any major issues.
Now, by using Microservice Architecture in their apps they can almost get rid of this issue as Microservice Architecture works on mainly three principles, which are: Single Purpose, Loosely coupled, and High Cohesion.

I know these sounds alienated words to you or maybe they are not clearly understandable at this point in time but their meaning is very simple.

Single Purpose:
Design an App that is built only for one purpose. For Example, Search exclusive App, Image Recognition Exclusive App, Cart Checkout Exclusive App.

Loosely Coupled:
Sometimes we need components created for Single Purpose to communicate with each other and that’s where loosely coupled principle plays a very crucial role in designing these kinds of Architecture. These components should talk to each other in a very loosely coupled fashion, meaning, they should create their own APIs(read, create, update, delete) in such a way that those are very generic and can be used by any component whatsoever in the future that might be created for that App. Designing it in a Generic Fashion will ensure not major design changes just for one component requirement, if that’s the case, then it is not a good design(we again need to sit back and review it thoroughly). Also, in loosely coupled principle, components are free to create their tech stack independent of other components(for example, one can use Node in Backend and others can use Python or maybe FORTRAN (pun intended) ).

High Cohesion:
Last, components themselves should be having a high cohesion nature, meaning all parts of one component should be highly dependent on each other. Without “High Cohesion”, we would end up having “distributed monolithic’ architecture, where one feature is scattered over multiple components which is a violation of Microservice Architecture.

Overall Structure of Microservice Architecture.

Benefits of inculcating Microservice Architecture

There are numerous benefits of adopting a Microservice Architecture

  1. Independent Deployment: Components can now be deployed independently without having to wait for other components to be ready, which helps in faster changes in the production and new features every other day.
  2. Less Downtime: Can you think of a time when major eCommerce companies like Amazon, Flipkart, Walmart were down because they were upgrading the App? I think no. Because all of them use Microservice Architecture and that’s the reason, they don’t need to take the whole App Down just because they are rolling out a teeny-tiny feature, they can very well take down that corresponding component without affecting other components in the Application.
  3. Faster Rollout: Apps can roll out their new features in a very rapid fashion considering that they are evolving independently without having to wait for other teams/components to integrate their feature with.
  4. Less Hardware Maintenance: Microservice Architecture gives developers enough freedom to choose their tech stack based on the kind of problem they are solving. For example, for the feature which needs a lot of Mathematical or Statistical Analysis, they can use Python/R as a Backend in that; and for other features, they can use JAVA, C#, Node, .Net as a Backend.

Is it always necessary to have Microservice Architecture instead of Monolithic Architecture?

The answer is NO, BIG NO. You should very understand the efforts and the value your product brings in. Generally, at first, implementing Microservice Architecture is a very tedious task, you need to have a separate Team/Architecture for each component that you need to have in your Application and a lot of thought process goes into that which might not be a viable option for small companies or Application built in very less budget, so there comes a saviour way to create Applications in “Monolithic” fashion or you can also say “traditional” way of creating Applications. If there are not so many components in that case also, you can think to adopt a “Monolithic’ way of doing things. But keep in mind, to modularize your application as much as possible so that later in case you want to redesign it in a “Microservice” way you don’t face many challenges in doing so.

Real-world Examples:

Walmart
Amazon
Paypal
Spotify
….
….
.
The count is endless, but these are some of the world-famous Applications which almost everyone uses.

I hope this has given you a Basic insight into what is Microservice and what are the main guiding principles behind it. So, next time, you are doing any development or asked to do so, you can very well ask or guide whether we should use Microservice or should we go with Monolithic Design as changing them, later on, would be a very very *100 tedious task and thus this thought process for a basic foundation is justified to spend some time on.

peace: V

Software Engineer by Profession. Part-time writer by Choice. Github: https://github.com/atul-mittal-07/

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store