Legacy systems still form the backbone of many enterprises. Yet as the demand for efficiency, scale, reliability and agility grow larger, we've seen an evolution in these underlying technologies to meet those needs. Let's explore some of these technologies, their history and their evolution to see why such a change was inevitable. Because in today's digital economy, organizations need to drive at a very different speed than was previously acceptable and embrace change in their competitive landscape and products.
Service-Oriented Architecture to the Rescue
Legacy systems, which are the mainstay of many enterprises, weren't developed to support the implementation and adoption of new technologies and growing economies working at breakneck speed. Consequently, as the number of digital transformation initiatives increases and the speed of expected delivery intensifies, IT leaders become overwhelmed by the sheer number of requests across the systems. Moreover, existing legacy interfaces, developed in a world of daily batch calls, are not fit for purpose for today’s digital channels that require real-time data.
Enter service-oriented architecture (SOA), with its promise of speeding up project delivery, increasing IT agility and scalability and reduce integration costs. Gartner analyst Roy Schulte defined service-oriented architecture in 1996 as follows:
“A service-oriented architecture is a style of multi-tier computing that helps organizations share logic and data among multiple applications and usage modes.”
The goal of SOA is to create independent services that represent a single business activity with a specified outcome, that is self-contained and can be consumed by others irrespective of its implementation details based on the exposed interface. However, as SOA was adopted by organizations across the world, SOA governance requirements, large scale ESB integrations, and a need for large service registries made the implementations heavy and monolithic.
The original promise of SOA was to speed up project delivery, increase agility and reduce costs. However, SOA adopters found that it increased complexity and introduced bottlenecks. Although teams were able to create faster connections, they also needed to maintain a large ESB implementation which slowed down time to production and didn't provide a reasonable return on investment.
Related Article: Modernizing Legacy Tech: Big Bang or Piecemeal?
Microservices: Creating the Software Assembly Line
Microservices are in fact, the next step in the evolution of service-oriented architectures. A microservice is:
- Functionally Scoped: Microservices design is based on services and applications that accomplish one narrowly defined business function. A microservice need not necessarily be small, its size depends upon the complexity of the business function it accomplishes. However, it will be smaller than an application that contains its functionality as well as other business functions.
- Autonomous: As essential element of a microservice is that it should be autonomous. That is, it should be able to function on its own and without the need for other services. Other services might be layered on top of it (such as a service that handles user authentication), but it performs its business function independently. It can be developed and tested independently, and it can be deployed independently.
More than anything else, a microservices design forces us to rethink the way we plan projects and lead teams. It affects how we think of deliverables, application lifecycles and time to production. It is amenable to a DevSecOps based approach which is founded in amalgamated scrum teams with a focus on automation, speed and agility. In some ways it is akin to the change in thinking that came with assembly line production and Lean philosophies that revolutionized the manufacturing industry in the early 20th century. Some of the benefits of using a microservice-based architecture are:
Speed — Since a microservice is an autonomous unit, independent scrum teams can develop, test and put it into production irrespective of other parts. Each new unit provides a critical and unique functionality but no one single unit prevents the whole from functioning. Hence services can be created and deployed to production in small sized scrum teams.
Agility — An agile environment succeeds on small units which can be built in scrum teams of six to eight, tested and added to the release pipeline. Microservices not only just work, but thrive in an agile environment and promote quick, faster releases of independent units that can be promoted to production as autonomous units.
Flexibility — The autonomy and lack of dependencies in microservices provides a number of advantages: teams are able to use the language and tools that best fit the problem, they can test, build and deploy functionality without being impeded by other teams and services, and the code base each team must manage is considerably smaller and simpler. They provide the flexibility to try out a new technology stack on an individual service as needed. There won’t be as many dependency concerns and rolling back changes becomes much easier. With less code in play, there is more flexibility.
And last but not least, Simplicity — Microservices provide us with the smallest productivity unit in a complex ecosystem of IT services within any organization — like the cells with the complex human body. It forces organizations to think of their simplest business function and smallest unit of work. In addition, rather than working on an element of a project that is centrally managed, each team working within the context of a microservices architecture is free to innovate within the context of a simple business function, promoting innovation and risk taking which does not affect the entire organization.
Thinking about and designing our applications in terms of small independent units is the first step towards building a modern infrastructure that is nimble, agile and scalable. While there will still be technical debt as teams balance timelines and design, it easier to pay down that debt. In fact, as organizations evolve and modify their requirements, IT departments can work alongside them in replacing services rather than maintaining them.
Related Article: What Microservices Bring to the Digital Workplace
Learn how you can join our contributor community.