Software Architecture

 

What does System Architecture means

If you have an idea that needs to be properly implemented as software, you need to create a well-structured application for it. To keep it maintainable and allow it to evolve with minimal effort, you need to design and architect the software components accordingly. A good system architecture will help you maintain and scale your application with minimal effort.

A good system architecture helps:

• Ensure your application is easy to maintain and debug
• Support future enhancements and scalability with minimal effort
• Improve performance, security, and reliability
• Clearly separate concerns and responsibilities among system components

Role of a Software Architect 

•  Software Architect is a person responsible for creating an architecture for your software application that is best suited for it.

• They should be able to design an architecture that is robust, fulfills the application's requirements, and can be easily scaled and maintained.

• A Software Architect is not the leader of the software, but a part of the team that develops the software.

• They should work within an agile methodology and be capable of adapting the architecture based on requirements or the demands of the situation.

Types of System Architectures

• Monolithic Architecture
• Layered Architecture (n-tier)
• Microservices Architecture
• Event-Driven Architecture
• Serverless Architecture
• Service-Oriented Architecture (SOA)
• Cloud-Native Architecture
• Distributed Systems Architecture

Monolithic Architecture 

In Monolithic architecture, entire code is stuffed into a single unified application. Your frontend code server code and the database related code will be under one code base. Example ASP.Net MVC application where everything is coupled together very tightly. 

• Monolithic architecture is good solution for the application with less code base and tend to have less functionality
• If you are looking to build an application that will handle a lot of user and application itself enrich with functionality than monolithic architecture is not an optimal choice and here are the reasons 
• For large code base, application with monolithic architecture are complex to manage and maintain. 
• For a small bug fix, you could potentially introduce a larger issue or bug due to the tightly coupled and interdependent nature of the code in this architecture.
• It is very difficult to scale with monolithic application as it tend to get complex and time taking when scaling for large application 
• If any single code as exception or error, it will lead to entire system down. Which is not good in availability prospect  
• I will recommend to use Monolithic architecture if you are looking to build a solution fast and small. But if you are planning for enterprise level application than I would suggest going with other architecture that's most suitable for your requirement 

Layered Architecture 

In Layered architecture, you divide your applications in different business layer. And each layer describe the unit of worker working on it and scaling the application. 

• Your application architecture will simulate the real organization division where first layer could handle presentation layer on which your designer or frontend team could work on and takes the responsibility. 
• Second layer will be with backend team and could call as controller layer, handling all the requests and sending them to business layer 
• A business layer will handle all the core calculation and logic that are necessary to keep the business running 
• And last could be your database layer that will handle the code responsible to interact with your database 

• I will recommend to use layered architecture if you and your team prefer the application architecture reflect the technology distribution based on team responsibilities. At the same time add the layer of encapsulation on each team's work

Microservices Architecture

In a Microservices Architecture, we divide an application into multiple small, independent services, each deployed on separate infrastructure. This ensures that if one part of the application encounters an issue, it does not impact the functionality of the rest of the system.  

• You can create independent service of each domain block and ensure that they can run independently without depending on other services 
• Microservices Architecture is a good solution of the application that needs maximum availability and avoid any mishappening. 
• But with Microservices Architecture, the cost of infrastructure increase as you need to host all the different services independently and also maintenance and deployment cost increase 
• Microservice architecture is suitable if you are planning to have enterprises level application 
• You can start with a simpler architecture in the initial phase of your application, and gradually transition to a microservice's architecture over time. This way, you avoid bearing the cost and complexity of microservices at the early stage itself