Monolithic application

Introduction to Monolithic application:

Monolithic means Composed all in one piece.
Monolithic applications are single tiered, which means multiple components are combined into one large application.
For instance , the user interface and data access code are combined into a single program from a single platform.
A monolithic application is self-contained and independent from other computing applications.
Monolithic applications are designed to handle multiple related tasks.
They’re typically complex applications that encompass several tightly coupled functions.

monolithic arch.jpg

Let's take an example of an e-commerce application.
The application website authorises customers, logs them in to their account and enables them to add services/products to their cart,make online payments, review their service/products,reschedule and cancellations.
There are several components involved in this entire process, including the customer-facing user interface, plus services for user authentication, payments etc.
If the application uses a monolithic architecture, it is built and deployed as a single application, regardless of how a customer uses it.
Thus, whether users access the application from their desktop or from a mobile device, the application remains tightly coupled, and all the various components and modules are directly connected to each other. Finally, if changes are needed for any one component, code changes are required for all other affected components as well.

Monolithic programs may have better throughput than modular applications.
They may also be easier to test and debug because, with fewer elements, there are fewer testing variables and scenarios that come into play.
At the beginning of the software development lifecycle, it is usually easier to go with the monolithic architecture since development can be simpler during the early stages.
A single codebase also simplifies logging, configuration management, application performance monitoring and other development concerns.
Deployment can also be easier by copying the packaged application to a server. Finally, multiple copies of the application can be placed behind a load balancer to scale it horizontally.

The codebase of monolithic applications can be difficult to understand because they may be extensive, which can make it difficult for new developers to modify the code to meet changing business or technical requirements.
As requirements evolve or become more complex, it becomes difficult to correctly implement changes without hampering the quality of the code and affecting the overall operation of the application.
Following each update to a monolithic application, developers must compile the entire codebase and redeploy the full application rather than just the part that was updated. This makes continuous or regular deployments difficult, which then affects the application's and team's agility.
The application's size can also increase startup time and add to delays. In some cases, different parts of the application may have conflicting resource requirements. This makes it harder to find the resources required to scale the application.