Legacy software applications were written decades ago using outdated programming languages and are usually run on mainframe servers. They are massive in size, and hence, the goals of modification and maneuverability are very tough to implement. Third-party integration is another difficult assignment. To incorporate changes (induced by business, technology, and user) is time-consuming and error-prone. They're tightly coupled and usually run in a single process. All these properties make them unamendable and unapproachable for any kind of crucial advancements. They are not modern in the sense that they are not generally web and mobile-enabled. Precisely speaking, they aren't agile or adaptive. They're resisting technology upgrades, which makes them very expensive to maintain. Thus, moving from legacy applications to modern applications by leveraging a bevy of pioneering technologies, programming languages, and development frameworks and platforms has gained a lot of attention. With newer architectural patterns and styles emerging and evolving, software architects and developers are keen to embrace them to bring forth competitive applications that can easily fulfil the varying expectations of businesses and people.

The concept of DevOps is sweeping across IT organizations in order to eliminate any kind of friction between development teams and operation teams. Greenfield projects and cloud-native applications are being deployed and operated using this new concept. There are write-ups in this chapter about DevOps, which is being positioned as a must for the digital era. As there is constant chopping and changing being demanded in software solutions from various sources, the significance of DevOps is garnering more support.

For monolithic applications, functionalities are duplicated in the source code. Several units across the enterprise bring forth their functionalities, which have to be integrated with the core application. When a company buys another company, their source code has to be integrated. Such integrations ultimately lead to the duplication of the same functionality. If there's any modification to be incorporated in to a single functionality, the whole monolithic application has to be recompiled and redeployed. There are definitely some deficiencies as far as legacy applications are concerned. That's why modernization has started to gain attention.