top of page
  • Writer's pictureVictor Kmita

Made with XME: From Monolith to Microservice With Fast Code

A good architecture will allow a system to be born as a monolith, deployed in a single file, but then to grow into a set of independently deployable units, and then all the way to independent services and/or micro-services.

Robert C. Martin,

Senior Application Development Analyst at IBM

2020 proves that businesses need flexibility and permanent well-functioning to stay afloat in any conditions. A robust digital base is an integral part of achieving it. That is why the enterprise’s transformation begins with the software one. Now the app architecture changing from monolithic to microservices is one of the dominant trends. But it's not something new. Following O’Reilly’s research, as of 2020, 28% of companies have been using microservices architecture for at least three years. But even today, not every enterprise knows how to move monolithic architecture to microservices appropriately. Let's see:

  • why this path matters and worth the effort

  • how the monolith is inferior to microservices

  • and in which way fast code solutions can help

Monolith vs. Microservice: What’s The Difference?

Let's move from simple to complex and talk about concepts before revealing the secret of the successful switching start.

What is monolithic architecture? Imagine a rigid vertical hierarchy, where the system components are subject to a single source of control and completely depend on it. This is how monolithic-based software works. Each application comprises an interface, a database, and a back-end part. The last one runs user requests, updates databases, etc. Here, the server part is the monolith - key control file of the system. The processes are linear and clear - this is a benefit. But total control limits software flexibility. Each update entails the change of the entire monolith and the release of a new program version. It’s a drawback.

What's behind microservices? Here, the opposite is true: one large system is divided into separately deployable microservices that perform specific processes. They operate with minimal central control and integrate seamlessly with each other. Services are created based on the business capability of the company without restrictions on their number. Advantages of a microservice architecture include the ability to change component properties in short terms without interrupting system operating.

Microservices-based CRM middleware Case Study | Monolith vs Microservices |

Microservices vs. Monoliths: Which is Right for Your Enterprise?

The microservice architecture seems to be modern, while the monolithic one is a bit legacy. But, despite the obvious advantages and stable popularity of the first one, not all companies are in a hurry to switch. It's because of several factors:

  • the transition period is too long and requires radical internal changes that affect the business functioning

  • the procedures are expensive and not every enterprise can afford them

Here it's reasonable to create a hybrid system that combines well-integrated monolithic and microservice elements. This provision can accompany the transition period, help to make changes gradually, and enable the business to adapt.

But what if the monolithic elements are clumsy and slow down the system? In this case, microservice-based middleware is an excellent auxiliary for them. Answering the question, what is middleware: it is a suite of software that provides seamless and fast interaction between internal system components. Earlier, XME. has worked on an order management system able to support monolithic ERP and help it interact with the rest of backend systems. It can be a shining example of middleware integration.

It is a logical place that moving from a monolithic to a microservice architecture should be started from determination and elimination of core bottlenecks.

Victor Kmita, CEO at once said:

The telecom industry usually begins architecture updating from CRM or Billing Systems, as they are crucial for business.

As seen, the above ERP, CRM, and also billing systems are principal not only for the telecommunications area but for any business. They are difficult to transform and demand an increased level of stability. Therefore, such systems remain monolithic for a long time after deciding to switch to microservice architecture.

Thus, different types of microservice-based middleware services are the best way to eliminate bottlenecks, make monolithic systems flexible, highly integrated, and scalable. Let's consider how CRM middleware was designed on the fast code platform and kicked off the client's migration from monolith to microservices.

Monolith-Microservice Transition: The First Step With Fast Code Platform

A lot of those standards are in middleware. The next generation of applications will be a lot more middleware dependent, so you have to start there.

former CEO/Chairman of Infor and President of Oracle

The company, serving about 20 million customers, turned to to create a digital additional solution for its existing monolithic CRM system. Management was planning a global transition to a microservice architecture, and this product became the beginning. The client has the following business needs:

  • creation of middleware for CRM system in the short term

  • ensuring a unified approach to the entire system transformation

  • designing a scalable service that allows quick service provision

  • strengthening the integration between CRM and other back-office systems

Microservices-based CRM middleware Case Study | Defining client's needs |

No other platform-based or boxed solution can boast of the seamless integration feature, speed of development, and scalability at the same time. Fast code platform has become a strategic tool, providing the client with desirable freedom to decide and develop new services regardless of the vendor. Together with robust middleware, the customer got full control over the entire transition process and a versatile base to perform it successfully.

Victor Kmita,

CEO at

Microservices-based CRM middleware Case Study | Victor Kmita about fast-code platform |

The development cycle took 6 months, which is 1.5 times faster than the term offered by other companies. It included several milestones, like:

  • analysis of the current conditions

  • future solution design and project planning

  • development

  • testing

  • acceptance and implementation

Microservices-based CRM middleware Case Study | Development cycle |

Milestones overlapped, each one took approximately 1-3 months. On the supplier side, a team of 10 specialists worked on the solution. The development of such products often requires significantly more professionals, but the fast code platform offers modern toolkits that optimize work and save resources.

The development resulted in a full-fledged customer service that seamlessly integrates with almost all back-office systems, including CRM, billing, ERP, communication channels, network management, etc. Among it, the product has the following features:

  • ready-to-use native interface

  • secured integration with partners and government authorities

  • high level of omnichannel and scalability

Microservices-based CRM middleware Case Study | Reasons to choose XME.platform |

The system turned out to be conveniently configurable and testable. Moreover, the client trained its internal IT-team that independently creates similar services based on the code platform compliant to the wide list of non functional requirements.

As practice shows, the transition from a monolithic architecture to a microservice one is a complicated and time-consuming process. To go through it quickly, a company will need to identify its weak points and strengthen positions with highly interacting microservice solutions. As seen, XME. fast code platform is a perfect base to develop them due to the significant pros it gives to the business.

Microservices-based CRM middleware Case Study | Project Outcomes |


Read more

Want to beat 53% your competitors?

bottom of page