How to refactor a monolithic application into microservices

It's clear why so many companies are switching their monolithic platforms to microservices. These products are faster to develop, more resilient and more flexible than others. All of those factors contribute to cost-saving development processes and happier teams.


What are monolithic applications?

A monolith is software that's built as a single unit organized by layers, not according to context or functionality. They're usually built in three parts: a client-side user interface (front-end), a database, and a server-side application. To make any alterations to the system, a developer must build and deploy an updated version of the server-side application. The problem we often see with monolithic applications is how quickly they turn into a "ball of mud" where no developer, PM or group of developers understand the platform in its entirety.


What is a microservices architecture?

Microservices is an architectural style that structures an application as a collection of loosely coupled services, which are organized by functionality or business capabilities.  Consider disassembling a monolith into a set of independent services that are developed, deployed and maintained separately.  It enables the continuous delivery/deployment of large, complex applications. Developing services separately allows developers to use the best development framework and tools for each task at hand which can improve the site's overall functionality.


Best practices for refactoring from monolithic to microservices architecture:

The process of transforming a monolithic application into microservices is important for scaling your product but can be extremely difficult. At Big Room, we often support companies as they refactor their software as they hit scalability issues, and we've seen what works and what missteps to avoid. Here are some of our recommendations:

Start now. When your monolith has become unmanageable, stop adding new code to the architecture. Consider building a standalone microservice that integrates with the outdated platform. This will be more work upfront, but beneficial as you refactor the rest of the architecture.

Avoid the urge to rewrite the entire platform using microservices from scratch. Appealing as it may sound, there are too many risks. Testing and rewriting in smaller chunks is recommended.

Incrementally refactor your current platform. By building your new application in tandem with the monolithic platform you can slowly replace or reduce these functionalities until they aren't needed, or become a microservice. There are still some risks, but far fewer than building from scratch.

Split the front and back ends. There is often a separation between the client-side user interface (front-end), and the database and server-side application. This might be a natural seam to split the monolith into two manageable applications. This allows you to scale and maintain these applications separately. You will likely still need to continue to look for ways to reduce the monolithic functionality, but this is often the best place to start.

Plan and prioritize. Business and engineering leads should work together to prioritize modules that need to be refactored. Prioritizing modules that are easiest to convert to microservices may create some momentum around the process. Mix in business priorities that may be more problematic to extract, but will have the most impact on the product success. These may include modules that improve the user experience or sales process.


If your product team is looking to maximize productivity, embrace agility and improve customer experience this is the right time to step out from the muddy monolithic Web applications and embrace microservices. If you are interested in learning how these basic principles apply to your application talk to one of our development strategists!


Share this post