As monoliths grew, so did the complexities with them, the idea behind self-contained systems was to break these mammoth-sized monoliths into small components that are self-contained. These small systems collaborate to make a complete, logical autonomous unit. The independent nature of self-contained systems is their greatest win over. If one SCS fails, the other SCSs are not affected. Technology decisions and requirements can be limited to a single self-contained system; where requirements to a monolith would impact the whole. The risk of testing out new technologies or approaches is minimized as it is implemented on a single SCS.
This means they are also similar to API widgets. With the Widgets API, we can build applications with marketing functionality. These Widgets like self-contained systems are autonomous units that will support beyond texts and images, for example, sliders, chat apps, YouTube videos. The Widgets API will let you loose in creating new and exciting solutions.
In self-contained systems, multiple teams are not required. Only one team should manage it at a time otherwise multiple teams would require too much communication and interaction making it tightly coupled. Also, less sharing must be done in the database, logic to make it less coupled and a shared UI must be avoided as to implement all the logic.
How to integrate self-contained systems?
Integration in SCS should be done in a way that will support its decoupling nature. Moreover, it is a part of a larger system, so integration is needed. Let’s discuss different ways of integration:
1. UI integration
Doing so provides flexibility. For instance, a product search in one SCS can link to another UI containing product details. For this purpose, we also need to add web parts in other pages, like the shopping cart needs to be present in the header page.
2. Asynchronous Communication
That’s true. A self-contained system can also communicate asynchronously. It will also entertain decoupling and avoid errors. Also, resilience is ensured through this way, as if the system is not available, the events will prop up again and then processed. Moreover, asynchronous communication can use REST or messaging protocols. Remote API calls can also be used asynchronously.
3. Synchronous Communication
SCS can communicate synchronously if necessary, only it will indulge tight coupling. So, it’s better to avoid it.
Advantages of Self-Contained Systems
SCS shares advantages of both the monolith and microservices.
- Like monoliths, SCS has limited distribution, with easy operability and easy refactoring. like microservices, they are independently deployable and loosely coupled.
- SCS has a resilient design as they have their own database and communicate asynchronously.
- Multiple SCS can be combined to have better functionality which won’t impact the individual SCS.
- Each SCS is independent of the other systems and thus, is more scalable. This means we can run a single SCS which can be replaced, managed irrespective of affecting other systems.
- Technical decisions can be made independently like language framework, programming, workflow, etc.
Difficulties while implementing SCS
Data redundancy and eventual inconsistency are the major difficulties we can face while implementing self-contained systems because replicating the data asynchronously indulge writing and testing the feeds.
Apart from this, we also need to consider a few things during UI integration as well. There are also challenges occurring from the architectural split which will need skilled cross-functional teams to handle.
Thoughts on SCS in practice
An SCS is a system of systems wherein a product fits well only if it can define a set of tasks and provide integration required in SCS. The domains once finish their lifetime, can be replaced by other products making the system more resilient. Also, the products must have uniform interfaces that integrate with the rest of the system.
In order to move away from your old monolithic system into a system of systems, you can migrate in small manageable steps which will not only limit the risk of failure but ultimately lead to an evolution in complex systems.
But remember, splitting your system into vertical slices of SCS can look great but without technical know-how, it can be rather messy.
At Softobiz, we have experience in using self-contained systems for enterprise application development. So, with the help of the Softobiz team, you can make your SCS clear, more robust avoiding all the mess which otherwise you can encounter.
