Strangler Pattern: The shortcut to modularized it

The Strangler Pattern is a concrete method for achieving modularization of public IT and its benefits. We argue that we can save money and regain the dynamism in public IT by increasing the independence between the parts of the IT systems.

In this article, we describe how we can succeed in this without having to start from scratch.

Choke the monolith bit by bit with the Strangler Pattern Instead of establishing a large modernization project where the system is redeveloped or rebuilt all at once, we can, with the Strangler Pattern, move functionality into new modules bit by bit.

The principle is that we select a module, which we develop an independent version of. Once the new module is developed and tested, the corresponding functionality in the monolith is phased out and replaced with the new module.

Our example with document management can be a starting point. We build a new document management module while the existing one continues as usual and define a solid contract between the module and the old system.

The new module has its own data model and its own database. When the new document management module is ready, it replaces the old one, which is then shut down. The Strangler Pattern thus helps us to “choke” the old system bit by bit.

How do we best organize the work with modern IT?

The larger a module is, the more it resembles a monolith in itself. At the same time, the extreme is a jumble of countless modules, which is also not optimal. The modules must be able to communicate with each other, and the coherence must be manageable. So how do we divide the monolith?

“The key is to sit down and see which elements – modules – we can naturally divide the system into.”

The division must be logical, and each module must have a well-defined responsibility, where an unnecessarily complicated landscape of dependencies does not arise.

When you have divided the modules on paper for the first time, then take each one and see if these can also be divided, or if you have now achieved an overall structure with appropriate module sizes.

Six rules of thumb for working with the Strangler Pattern and modular architecture

Recognizing that the system’s architecture is not the only factor affecting the organization of the work, here are a few rules of thumb to keep in mind when starting the modularization work:

• Consider how large teams you want to work in. Our experience is that a team size of five to nine people is good. Then consider how much one team can handle. That is a good guideline for a module size.
• A division into five to nine modules is a good starting point.
• It typically makes sense to separate the administrative parts from applications that refer to them.
• Security and rights management are also good to have in a separate module.
• Integrations to third-party systems should be independent modules. Thus, changes in related systems cannot affect the central modules in the solution.
• Each frontend to the solution is a candidate for its own module. Build a backend service for the specific frontend according to the ‘Backend for Frontend’ principle.

Behavioral change is the biggest challenge

As a conclusion to this article, we would like to comment on what can actually be the hardest to implement in the transition from monolith to modular or service-based IT. Namely, the behavioral change.

Developers have worked with monoliths for a long time, and habits are notoriously hard to change in practice.

A service-based and modular IT architecture places new demands on the individual developer, who suddenly has to relate to the fact that the individual modules are actually independent. Topics such as transactions, consistent data, and error handling require a new and different mindset among developers.

The transition is difficult, but the longer we wait, the bigger the bill will be. At the same time, it is of course important to move at the right time.

Do you need sparring before you start?

We are happy to find the right expert for you who can help you get started with transforming your monoliths into modern modular IT.

Contact Joachim Skov by email: jhs@mjolner.dk or mobile: +45 41 95 36 24.