Deployments in Monolithic Architecture

Published in

Design Microservices Architecture with Patterns & Principles

4 min readFeb 16, 2023

In this article, we are going to learn Monolithic Architecture and Deployments when designing any software architecture for our projects.

By this article, we are going to learn how to perform deployments between Modules in Modular Monolithic Architecture and Design our E-Commerce application with Modular Monolithic Architecture.

I have just published a new course — Design Microservices Architecture with Patterns & Principles.

Architecture Design Journey

There are many approaches and patterns that evolved over decades of software development, and all have their own benefits and challenges.

In the last article, we have learned and designed e-commerce application with Modular Monolithic Architecture style. Now we will focus on Vertical Considerations of Monolithic Application that you can see it the picture above. There are several vertical consideration that we are going to discuss:

We are still in Monolithic architecture and vertically we will learn

Deployments of Monolithic Architecture

In a monolithic architecture, deployment is typically done as a single unit. This means that all of the application’s components are packaged together and deployed to the same server or cluster. This approach is relatively simple, as it involves deploying a single package to a single target, and it can be done using a variety of tools and deployment pipelines.

However, because all of the application’s components are deployed together, this can create challenges when it comes to versioning and managing dependencies. For example, if a change is made to one module of the application, the entire application may need to be redeployed, even if the change only affects a small part of the application.

Since this is single code base, it is harder to implement new changes especially in a large and complex application with highly tight coupling. Any code change affects the whole system. Even the smallest change requires full deployment of the entire application — it is so expensive and risky. This is the pain point of Monolithic Architectures that is not reliable that a single bug in any module can bring down the whole monolithic application.

You can see the image at above:

The large developer team commits their changes to a single source code repository.
The path from code commit to production is long and difficult and involves manual testing.
The application is large, complex, unreliable, and difficult to maintain.

As the application grows and becomes more complex, it can become more difficult to manage the deployment process. Deployments may become more frequent, and there may be a need to deploy different parts of the application to different environments or servers.

To address these challenges, some organizations have begun to adopt more modular and distributed architectures, such as microservices. In a microservices architecture, each service can be deployed independently, and updates can be rolled out in a more granular fashion. This approach can help to reduce the risk of downtime and can make it easier to manage dependencies and versioning across different services. However, it also requires a more complex deployment pipeline, as multiple services need to be deployed and managed independently.

Design Modular Monolithic Architecture — E-Commerce App

If we design e-commerce application with Modular Monolithic architecture, you can see the image below:

According to architecture, we can encapsulate new feature developments into a module. And every module can implement its own architecture like Layered, Onion, Clean and so on.

Design Microservice Architecture — E-Commerce App

If we design e-commerce application with Microservice architecture, you can see the image below:

Product microservice can use NoSQL document database Shopping Cart microservice can use NoSQL key-value pair database and Order microservice can use Relational database as per microservice data storage requirements.

What’s Next ?

Step by Step Design Architectures w/ Course