Software architecture comes under design phase of software development life cycle. It is one of initial step of whole software development process. Without software architecture proceeding to software development is like building a house without designing architecture of house.

So software architecture is one of important part of software application development.

When we are building web or software applications, we constantly look for ways to improve our code and use better tools to get the best experience, performance, and many other things, not just on the final client-side but also in the development and deployment process.

we discuss Monolithic architecture ,Microservices and Modular Monolithic Architecture.

MONOLITHIC ARCHITECTURE

A monolith application is the one where the application is a single unit, which means that all the  logic is in one place and if a change is applied to the application, it affects the whole application and needs to be fully deployed again to include the changes working in the production server. Also, this kind of application usually uses only one type of database and one programming language for development.

MICROSERVICES

An application built using the microservices architecture is one where the whole application is divided into different pieces of software, each independent of the other, using different programming languages, libraries and frameworks, and even different databases. The changes applied to one of these pieces don’t affect the others, making the development process more flexible.

• Services are completely independent; each one has its own dependencies and logic.
• Each service could have a different database (this is optional because they can share the same database, but it’s preferred).
• Each service can use a different programming language and technology.
• When there is a change in the code, you can deploy only one service without interrupting or affecting the others.
• More scalable .

MODULAR MONOLITHIC ARCHITECTURE

Modular Monolith Architecture is a software design in which a monolith is made better and modular with importance to re-use components/modules. It’s often quite easy to transition from a Monolith Architecture to Modular Monolith. The modular monolithic architecture consists of dividing our logic first into modules, and each module will be independent and isolated. Then, each module should have its own business logic — and, if necessary, its database or schema. In that way you can build and modify the layers of each module without affecting the others.

Communication must be done  between the modules through public APIs, allowing access to the logic of each module from the other using public methods, and not using the internal functions and logic of each one.

• Modules are interchangeable.
• Code is reusable.
• Better organization of the dependencies compared to traditional monolithic apps.
• Easier to maintain and develop new versions than traditional monolithic apps.
• You can keep the whole project as a single unit, without needing different servers for deployment.