In the IT world, a monolith is a software system that attempts to solve all the requirements and challenges with one single software suite. In other words, a monolith is a "all-in-one" solution; the Jack of all Trades that everyone hopes and wishes for. But what sounds so simple in theory is in reality often more complex than it seems – and than it should be. And was has been replaced by new Headless systems. Steep thesis? Let's take a closer look.
A special feature of monolithic systems is that the software components are firmly connected to each other and thus dependent on each other. They’re not loosely coupled, as it is the case with modular systems or headless software. This interconnectedness within monoliths is, from our current perspective, a problem: They quickly reach their limits when the application needs to grow or has to be adapted to the individual needs of the company.
Another monolithic characteristic is, as already mentioned, the large range of functions that are mapped within this one system. But the many features quickly lead to a huge and complex monolithic code base. This is not only more burdensome to manage, but also makes updates or technical enhancements more difficult: Because changes to one part of the software can lead to unintended effects on other parts – requiring longer development and testing cycles.
But like many things, the software system landscape has evolved. That we as a digital agency tend to advise against monolithic systems today does not change the fact that the history of the monolithic internet has long been crowned with success.
The World Wide Web is now a good 30 years old. In this country, the success story began when AOL brought broadband internet to Germany in 1995. And it wasn't long before some companies also went "online". In the dotcom boom phase of the 2000s, companies discovered the possibilities of the internet: be it to reach a broad audience, sell products, offer services or simply to show digital presence.
The demand for simple, fast and universal website and platform solutions was clearly there. And that's why the offer grew as well. During this time, many well-known CMS and e-commerce software suites were born, such as TYPO3 (2004), Sitecore (2001), Drupal (2000), Shopware (2004), Oxid (2003), First Spirit (2000) OpenText (1991), Magnolia (1997), Intershop (1992), Demandware (2004) and so on and so forth.
But why is it that, in the past, the monolithic solutions of a few, large software providers have often been the most successful? As so often, it has to do with security and trust.
When it comes to implementing software projects, it usually takes a company's IT experts to ensure that the software can be integrated cleanly into the company's existing infrastructure. Thus, the IT department has a great responsibility to decide on the most fitting and secure option.
This is why, especially in the past, many IT teams relied on the best-known standard solutions from legacy tech companies when deciding on a CRM, PIM or ERP system. And thus on the solutions that enjoy a particularly high level of trust on the market. For example, many companies followed the "Microsoft strategy" or the "SAP strategy". This means: a large software manufacturer is chosen as the company solution for all IT tasks that arise. Over time, requirements such as web server IIS (Internet Information Server from Microsoft) and MSSQL databases arose – because software and support were purchased and licensed from Microsoft anyway. This also had the advantage that interfaces between the systems could usually function seamlessly or were already in place. So all in all, it was an IT decision that was certainly plausible from the point of view back then. This led to the following solutions:
Software that was close to the vendors' software strategy
Solutions that were compatible with the enterprise software database systems
Software for which updates and support could be purchased via framework agreements
Software that was already equipped with interfaces to CRM, ERP and PIM
Software that matched the companies' IT infrastructure
Congratulations, you're caught in the vendor lock. When you choose a system of a legacy tech company, you make a commitment to operate exclusively in the vendor's particular world. This also means that one's own special requirements can only be met with custom code and on the basis of the existing system and product landscape. With this decision, you get basic compatibility and security – but you pay the price of interchangeability and innovation. And also the price of high maintenance costs, which we will briefly touch on next from the agencies' point of view.
At this point we want to be a little provocative, because let's be honest: We have also benefited from this in the past. From an agency's point of view, it can be a profitable business model to sell the monolithic on-premise solutions.
Because the suites are usually hosted on internal or external servers, they also have to be regularly maintained and serviced. Besides security and bug fixes, they require regular software updates, which cannot be centralised – as it is possible with a SaaS solution, for example. And because the monolithic code base is often adapted to the individual and very specific needs of the companies, such updates and upgrades are very time-consuming and costly. As a rule, between 20 and 25% of the initial costs are incurred for this. In other words, the initial costs of 500,000 euros, for example, are followed by another 100,000 to 120,000 euros in maintenance costs – not even including the annual licensing costs.
So extra wishes and maintenance have their price. From the agency's point of view, this is a business model that not only pays off financially, but also increases customer loyalty and thus security.
We can state the following: monolithic systems may have been the most trusted solution in the past. The Swiss Army Knife that promises to fulfill all requirements. But today, they are definitely no longer “all-round carefree packages”. Legacy and monolithic content management systems require companies to make costly and resource-intensive deployments that are not necessarily future-proof.
This is because monolithic systems no longer meet all requirements that today's internet and modern software development bring with them. Within the last few years, the market, the variety of solutions and the demands of users have evolved. A paradigm shift has taken place, which we discuss in more detail in this Seek + Find article.