Within software design architecture, there has been a seismic shift towards the utilization of micro services in building customized healthcare solutions and artificial intelligence platforms.
Whereas a number of years ago, monolithic architecture wasn’t the norm, but today micro services are being used rigorously in developing minimal viable products (MVP).
A Monolithic software architecture, is one where the functionality of the system (for example the data processing and output), is unique system processes are all combined into a single software application (the program), rather than containing architecturally separate technological components where the user interfaces the business logic of the application, data access and integrations are combined into a single software application (program).
The benefits of monolithic architecture are as follows:
- faster and simple development;
- simplistic debugging and testing for software bugs;
- straight-forward deployment and utilization onto servers;
- less stringent requirements on software development and information technology operations (DevOps) and less rigid server infrastructure requirements;
- Less experienced developers can work on the project.
The disadvantages of monolithic architecture are as follows:
- challenges to make correct and effective modifications because of its large code base;
- when individual modifications are made to the architecture, there is a requirement to test the entire application and reconfigure any architectural problems;
- furthermore, a small software bug can adversely affect the performance of the whole application;
- the extensive size of the application and / or any modification, can compromise the software performance and thereby require more computational resources.
Micro service architecture, on the other hand is an architectural style that structures a software application as a collection of services that are highly maintainable and testable and are connected to each other over the network. For example, all the implementations like frontend service, backend API (application program interface), backend authentication services, backend business logic and core services, third-party party integration services are separated and work independently. Furthermore, the same operational server(s) are interconnected to each other, over the asynchronous message-bus or REST APIs and with JSONs. Thereby each service is free to use its own database and / or can share the same database; and work totally independent from other services/processes. (Diagram 2).
The benefits of micro service architecture are as follows:
- the software application is decomposed into a set of manageable functional services;
- each functional service has relatively short code base and is easily understood and able to be modified;
- the software debugging and testing process is much more effective as the application is distributed into the services;
- changes and modification on one service do not require to test other services as each service is individual;
- various software teams can develop multiple services simultaneously and leverage different technological stacks depending the specifics of the service, thereby accelerating the development time;
- each service could be deployed on the server independently enabling continues deployment process possible for really large applications;
- each service may be deployed independently thereby, made to run continuous delivery processes for really large applications and thus may be scaled independently by running multiple copies of it after load balancer or over containerization;
- thereby it is very cost effective in terms of computational power to auto scale.
The disadvantages of micro services are as follows:
- the complexity of the project requires to implement inter service communication over the message bus and / or APIs and this may cause errors in implementing the appropriate code;
- the application database is distributed into multiple partitions which are programmed by independent services and the need to update multiple databases driven by different services;
- the deployment process is more complex and requires planned CI/CD process, experienced software developers and operations.
Thereby, monolithic and micro service architectures each have their unique advantages and characteristics, however when an organization needs to make an effective proof of concept and / or an efficient time to market prototype, monolithic is the way ahead. Accordingly, when developing customized healthcare solutions and / or artificial intelligence platforms, we have to utilize an agile methodology gradually build a prototype, test its validity and micro service architecture is the way ahead.
Thereby, if your healthcare organization has a stringent need to develop various healthcare applications, please contact Karni Health Tech and its team of experienced and strong software architects and engineers who can help you build a viable health tech solution.