Converting a standard business into a digital business is vital to enlarge the business and expand its production. Furthermore, Integrating heterogeneous systems and constructing an ecosystem with these integrated elements are basic needs in the digital conversion of enterprises. For instance, a large number of companies have one or more legacy systems that deliver restricted assistance to merge with other systems. Nevertheless, it is unrealistic to substitute all existing systems by constructing them from scratch. Hence, the challenge is to drive all these current systems towards brownfield integration. This article investigates the significance of brownfield integration, methodologies, and key functionality requirements.
Brownfield vs. Greenfield
First of all Brownfield’ and ‘greenfield’ are both software development terms. Moreover, brownfield development describes problem spaces needing the development and deployment of new software systems within the immediate presence of existing (legacy) software applications/services. Furthermore, this implies that any new software architecture must take into account and coexist with live software already in production. A brownfield project usually refers to a major upgrade, or a redevelopment of an existing live application where there are issues like backward compatibility to existing file formats, interfaces, modules, etc. On the other hand, greenfield development lacks any constraints imposed by prior work.
Most importantly, both terms relate directly to IT production operations. Furthermore, brownfield ops are IT operating as traditional IT services with legacy tools and processes, emphasizing safety and accuracy – what a traditional IT organization does best. Similarly, greenfield emphasizes agility and speed, like a digital startup, and is closely tied to cloud adoption and new tools/processes. Therefore, See the attributes below that summarize the contrasts between brownfield and greenfield ops.
Why is Brownfield Integration Important?
First of all, Brownfield software development refers to the development and deployment of a new software system in the presence of existing or legacy software systems. Moreover, brownfield development usually happens when you want to develop or improve upon an existing application, and compels you to work with previously created code. Therefore, any new software architecture must consider and coexist with systems already in place – to enhance existing functionality or capability. Examples of brownfield software development include: adding a new module to an existing enterprise system, integrating a new feature to software that was developed earlier, or upgrading code to enhance the functionality of an app.
- It offers a place to start with a predetermined direction.
- Gives a chance to add improvements to existing technology solutions.
- Supports working with defined business processes and technology solutions.
- Allows existing code to be reused to add new features.
Brownfield Integration Methodologies
First of all, the latest enterprise systems can be classified into four types based on the integration capabilities.
- Systems based on standard protocols
Some current methodologies may have an option to merge with other systems in a standard way. Moreover, this means support for standard protocols such as JMS, FTP, HTTP, etc. Furthermore, it is extremely probable that a system constructed in the previous decades includes APIs for integration. Besides, the majority of integration solutions aid this form of integration and integrate with these systems is relatively easy.
- Systems based on non-standard or proprietary protocols
Some methodologies deliver extension points to integrate with other methodologies. However, these extension points are not established on a general standard. For instance, some systems deliver SDKs to construct programs to integrate with their methodologies. Proprietary methodologies such as SAP does the same. Moreover, this category contains the majority of brownfield systems. Furthermore, compared to methodologies rely on standard protocols, integration with these methodologies is not straight forward, yet not impossible.
- Systems that don’t provide any integration points
Some standalone methodologies do not supply any extension loops for integration at all. Moreover, most of these systems use databases to store information. Therefore, integrating with these methodologies need integrating with their databases.
- File-based systems
most importantly, the majority of old methodologies use files such as CSV to transfer data. Hence, files are required to integrate with these systems.
Key Functionality Requirements
The characteristics required in an integration solution for brownfield integration :
- Message Transformation
According to the above figure, brownfield represents the right-hand side and the left-hand side represents the system that we are currently building. Let’s assume that we receive a request from the user and we are unable to deliver the message as it is to the existing system. In such a situation, we require to transform and build the message as required by the existing service.
- Protocol Switching
According to the figure, the brownfield methodology is exposed over the JMS protocol and we require to create a new methodology that is exposed over the HTTP protocol. Therefore, the main feature of an integration solution is the ability to perform protocol switching.
- Message Routing
First of all the above figure represents the customer is sending two forms of messages. Moreover, routing could depend on the details of the message, a header, or some property of the message. Based on the type of message, it requires to be routed to the correct service.
- Parallel Processing
Another key feature is parallel processing. In this case, we have two systems and we require to communicate with both systems simultaneously to decrease latency. Firstly, this system clones the incoming message request and direct it to both services simultaneously.
- Service Orchestration
When creating an integration solution we may have to link with multiple systems and orchestrate them to create a new service. The above figure represents three systems that exist in the brownfield. In this case, we orchestrate them to create a system that delivers new features and invoke services one after the other sequentially.