Monolithic vs Microservice

Monolithic application is the traditional application which you normally create (i.e., a single big system) which consists of different components as a single deployable unit.

Example of a monolithic application could be an application that has a front-end, back end system that performs several services.

In this the application is normally deployed as a single unit.

Problems with Monolithic approach:

• A single code base which contains the entire application is difficult for the developers to understand particularly people who are new to the team. The application can be difficult to modify.
• The application takes a lot of time to startup, not to mention the deployment.
• The build of the application takes more time, the larger the code base, the slower will be the IDE, the build sometimes has to build components that are not related to the developer currently working on.
•  Code base maintainence: Maintaining the single code base for all the developer could be a nightmare particularly when a developer committed a wrong code at the end of the day.
• Scalability: You might have only certain parts of the application that need to be scaled, but you might have to scale the entire application.
• Deployment dependency: If you have multiple components and developers in a single code base, you may not be able to deploy or wait for a particular interval to get your code deployed to some environments even though you completed your change faster.
• Every developer need to know the technical stack used in the entire application. Only developers of certain skillset will be able to contribute. Use of a limited technical stack for the entire development team

A lot of problems which are mentioned above can be resolved in the microservice architecture.

A microservice is a relatively small service that can be deployed independently and scaled. This is normally done by a small group of developers who can choose their preferred technical stack to solve a problem.

A big application can comprise of multiple microservices developed by different teams of different skillset. This eliminates any long term commitment to a technology stack.

The code base is relatively small, and hence the build and deployment time is also less.