• December 8, 2016

The Breakup: Leaving Legacy IT for Microservices Architecture

Increase agility by breaking applications into component parts defined by function.

To compete in the super-fast digital environment, flexibility must be an integral element of enterprise culture. Key to this nimbleness is microservices architecture. Microservices architecture makes applications easier to develop and maintain by breaking them down into small, independently composable pieces.

Big Code

Traditionally, enterprises have embraced monolithic architectures, or single-tiered applications with user interface, processing, and data access code combined into a single program on a single platform. In these designs, the application performs every step necessary to complete a specific function, end to end.

The drawbacks? Monolithic architectures tend to be rigid and are difficult to scale. And because processes are so tightly integrated, one small change to a specific function must be deployed across the entire application structure. This means developers can’t work independently creating and deploying specific process components. They are dependent on the entire team working the application, a process that increases development time. Plus, if any component has a glitch or fails, it can bring down the whole application.

Plug and Play

Rather than a single monolithic piece, microservices architecture turns an application into a modular suite. Each function is broken down into a small, bite-sized chunk executing a highly defined task. These service pieces communicate with each other via simple, language-independent application programming interfaces (APIs), creating a loose integration of components and the specific functions they perform. Think of it as a suite of small plug-and-play services for designing complex, mostly cloud-based solutions.

The advantages propelling microservices architecture adoption are flexibility, customization, scalability, and speed. Because each service is an independent component, fault isolation is significantly enhanced: the full application is relatively unaffected by the failure of a single component. Plus, it allows the enterprise to play the technology field by eliminating long-term adherence to a single technology stack.

Microservices also mean there is less code and fewer cumbersome structures in play, creating a better developer experience. This makes the Holy Grail of continuous delivery possible by enabling developers to easily adapt services to user feedback, marketplace shifts, and business strategy adjustments.


This promising architecture also poses significant challenges. Because different teams using different technologies assemble each component, compatibility issues can emerge. Myopia, or the tendency of development teams to focus on the goals of their individual component service at the expense of the overall system, can also be a problem. Microservices architectures also heighten cataloging and testing demands to tease out and fix incompatibilities.

A typical enterprise can have hundreds of applications. Microservices architecture potentially compounds this expanse by transforming it into a sprawl of thousands of loosely integrated microservices.

Yet increases in agility and a stronger innovation stance can more than offset these challenges. Instead of building monolithic systems, the enterprise can focus on developing reusable building blocks to be configured and implemented as requirements dictate. With this architecture in place, the enterprise can continuously build and deploy new business functionality, pivoting to—and in anticipation of—marketplace shifts.

Like this story? Read about the great cloud takeover.