How to Execute Technology Migration Without Business Harm
Software development is always a mysterious journey with unpredictable twists and turns. Even though the client and developers discuss all the requirements before work starts, new circumstances may require significant changes in the long run.
For example, sometimes, organizations conclude that their given IT infrastructure, software architecture, or even programming languages no longer meet their business needs. In this type of situation, they will decide to change the project tech stack and switch to more relevant technologies. Of course, such an extensive change cannot be implemented overnight. It requires extensive preparation and can take months, if not years.
What motivates companies to migrate to new technologies, and how can this tech migration be made in the most painless way? This document will discuss these questions in more detail.
Why do companies migrate tech stack?
Outdated tools can prevent business growth through the inability to implement certain features or to enable specific integrations. Given this, companies decide to change the IT environment or rewrite the codebase to achieve business goals and meet present-day needs.
Delving deeper into the reasons that push companies to implement technical migration, we can highlight the following:
Low software performance. Outdated technologies often cause lower performance and reduced speed of the software system.
High maintenance costs. Obsolete technologies consume more energy and require greater attention from maintenance personnel.
Security gaps. Old technologies often come with security vulnerabilities and outdated protocols, increasing the risk of malicious intrusion.
Regulatory compliance issues. Changes in regulations and compliance requirements may necessitate technology migration solutions.
Compatibility issues. As new technologies emerge, older systems become incompatible with newer hardware, software, or industry standards.
Unable to scale. A 20-year-old software running on-premises cannot quickly be scaled through the addition of more IT resources. This forces companies to turn to mainframe migration to cloud more often these days.
Unable to innovate. Old technologies prevent companies from developing innovative features that could enhance a product and attract a wider audience.
Unable to reach strategic goals. Outdated software systems prevent businesses from expanding into new markets, launching innovative products, and repositioning in the industry.
Vendor lock-in. Old software systems dependent on a single vendor do not have room for changes, which often forces companies to migrate a tech stack.
Staff shortcomings. Developers who were coding in Cobol, Fortran, or other obsolete languages are now retired, with no new specialists being trained.
Optimize project costs.
Technology migration: key strategies
Technology migration does not always mean a complete abandonment of the existing system. In most cases, it is enough to modernize a specific part of the program to remove the negative impact of old tech on the business.
However, partial modernization is not always possible. In some cases, organizations revamp the product from changing infrastructure to rebuilding the architecture, putting enormous resources into the upgrade campaign.
The strategies below describe the most common types of migration to new technology and use cases when they are applicable.
Switching from one programming language to another
Currently, dozens of programming languages are used in software development. Each has specific features and suits certain types of tasks. However, some organizations cannot take advantage of modern technologies because they continue to use obsolete purpose-built enterprise software.
According to the Advanced Mainframe report, 42% of companies still use Cobol-based software, 37% utilize programs written in Assembler, and 32% run applications in ADSOl.
The same report lists Java, Python, and C#(.NET) as the primary languages to which organizations would like to migrate.
Another use case for switching the tech migration is the need to use more universal programming languages. Having chosen a narrow-focused language that is good for specific tasks, companies face some limitations with extending their software capabilities. For example, the points of concern may be associated with app performance, third-party integrations, deployment opportunities, or other crucial aspects of software development.
Below are common use cases for tech stack migration and programming language pairs.
Easily connect third-party services
Adopting APIs and 3rd party integrations
Today, software rarely works in isolation. Even if you develop a program for internal enterprise needs, you need to connect with third-party services, and third-party services may want to connect with you. To make this integration effortless, you need well-developed APIs, available libraries, and structured documentation.
Many programming languages and other software technologies, especially the young ones, lack well-designed solutions for external integrations. While this may not raise issues in the initial stages of the project launch, problems can appear and grow as the project matures and expands functionality.
To simplify third-party integrations, companies migrate to a more sophisticated tech stack. In particular, they choose technologies with advanced APIs, libraries, and extra development tools.
Currently, the most module-rich languages are JavaScript, Python, Java, and C#(.NET).
Most module-rich languages
Moving to the modern IT infrastructure
IT infrastructure is the environment for operating the software system. This includes hardware, software, networking, data storage, facilities, and other components necessary to support the delivery of IT services within an organization.
40, 30, or 20 years ago, an IT infrastructure setup meant running software on a mainframe or deploying a local application environment. This approach required significant investment, both during the installation phase and during the infrastructure maintenance. Therefore, with the advent of cloud providers, organizations are increasingly implementing mainframe cloud migration. They choose third-party infrastructure where they can quickly deploy an application using on-demand IT resources at a reasonable price.
It is important to note that a cloud-based infrastructure does not always mean moving to the cloud in the classical sense. Often, organizations choose to rent a bare metal server and set up the software part of the infrastructure themselves.
This approach may be more cost-effective for systems that do not deal with much traffic and can accommodate load levels.
If you develop a high-load system, like a game, mobile banking, or e-commerce platform, then migrating an on-premises system or mainframe to the cloud is necessary for easy scaling. AWS, Google Cloud, and Microsoft Azure are major cloud providers with a range of services, pricing models, and solutions for enterprises and startups.
A hybrid model is also a popular choice for organizations that want to maintain some data in their data centers while leveraging cloud services for scalability.
Below are common use cases for transitioning between different IT infrastructures. They include mainframe migration, on-premises systems migration, and transitioning of specific software parts.
Software rearchitecting
In some cases, organizations need to make structural changes to the software architecture while preserving its external functionality. This is done with the aim of improving the system's performance, scalability, maintainability, and security. By reorganizing the underlying components, modules, and relationships of the software program, companies achieve better productivity and business outcomes.
Cross-functional teams, including architects, developers, and stakeholders, are engaged in rearchitecting to ensure alignment with business goals. Comprehensive testing and validation are critical to verify that the rearchitected system not only meets its technical objectives but also delivers a better user experience and improved performance.
The use cases of using architecture as a part of tech stack migration are provided below:
Containerization
Containerization allows packaging and running applications and their dependencies in consistent and isolated environments - containers. Containers are lightweight, portable, and can be easily moved between different computing environments. Docker is one of the most popular containerization platforms. Kubernetes, in its turn, is an orchestration tool for automating container management.
Containerization is a relatively new approach to technology migration strategy. It is a key element of DevOps practices, which aim to automate the development lifecycle and build software development in CI/CD pipelines.
Containerization is one of the few technologies suitable for a wide range of projects because it simplifies the management of IT resources and automates the software development process. This is why containerization is often present in a technology migration plan.
Perhaps the only projects where containerization may be inappropriate are GUI and real-time applications. The thing is, containers are designed for headless, command-line applications, which means they lack the necessary infrastructure for handling graphical interfaces out of the box. In the case of real-time apps, containers may not guarantee sub-millisecond response times.
Below, we list the most common use cases of containerizing applications as a part of abandoning obsolete tech.
What challenges to expect during tech migration
Technology migration is a big task accompanied by many challenges. To minimize the risk of failure, the company must develop a technology migration plan, prioritize tasks, and clearly define the final result.
The complexity of the tech migration depends on the application itself, the architecture, external integrations, license agreements, the number of features, etc. The most common obstacles to tech stack migration and tips on how to overcome them are discussed below.
Dissimilarity of programming languages
Migration to another programming language is always a tricky task. However, if you do this within the same family of languages, the transition may be gradual and not so problematic. An example of such a tech migration is moving from Skala to Java. These languages work within the same virtual machine and are compatible at the bytecode level, so the transition occurs within the same tech stack. The same can be said about the .NET languages. For example, migration from F# to C#, or vice versa, should be seamless.
If you decide to perform a migration between languages that belong to diverse language families, the transition will be more complicated. In this case, the entire tech stack will need to be re-selected. Fortunately, some programming languages can integrate non-native components. For example, Java can integrate C-components through the native Java interface.
Enhance software performance
Limited pool of tech experts
Technology migration often means rebuilding the product from scratch using a completely different tech stack, such as programming languages, APIs, frameworks, databases, operating systems, etc. At the same time, it is necessary to save all the data, functionality, and integrations. So, ideally, the development team that created an app in the original technologies should perform the migration. However, in practice, this isn't easy to implement for two reasons:
the app developers no longer work in the company
the app developers do not have enough expertise in the new technology they plan to migrate to
That is why companies often look for developers who can study the current application and migrate it to a new infrastructure, perform re-architecture, or rewrite its code in a new language. Unfortunately, this task becomes even more complicated without self-explanatory code, well-developed documentation, and specialists who are well-versed in the project details.
Therefore, organizations may spend months, if not years, building a team to get this job done.
The solution, however, may be to turn to a ready-made team that has extensive experience in software engineering and technology migration projects. Such a team does not need to be located nearby. Today, many businesses benefit from outsourcing software development abroad, especially in the Eastern European region.
Overwhelming tasks for QA
Revamping software, especially on a tight schedule, creates a massive scope of tasks for QA engineers. If the testers know nothing about the original software, they have double the workload - firstly, to study the app in the "old" tech, then to ensure that everything works appropriately in the "new" tech.
The QA team should develop a detailed test plan to avoid missing things and make sure the app works as expected. The plan should cover all the aspects of software operation, check the app under different workloads, and ensure it is resistant to various malicious attacks. Here are the basics the testers should cover as a part of the test plan:
Define the scope of work: what, when, and how it should be tested.
Study requirements, business rules, and mapping documents.
Learn dependencies and interactions with other apps and services.
Create test cases and queries based on the software specifics.
Execute test cases and record results.
Compare the results with the expected output.
Run non-functional and functional software testing.
Extended maintenance
Technology migration of a large project is done in slow steps by rebuilding and testing the software's individual parts. This process may take from several months to several years, depending on the project volume and complexity. However, while you are working on the app renovation, you should also support the old version of the product. It means handling user requests, investigating issues, fixing bugs, and doing whatever is necessary to keep the app's stable work.
Only after a new product is developed, tested, and approved for release can you start the actual migration. In this case, it will be easier for those who migrate the web app. The thing is, you can replace the backend and frontend parts without informing users about it. However, with mobile apps, things are more complicated. In this case, the company needs to notify users about suspending the current app version and ask them to install the new version of the product.
Integration issues
Modern software has many integrations with third-party services. These services are connected through APIs and ready-made libraries. During technology migration, developers reconnect to external APIs and use new libraries to process the data. Sometimes, it is not possible to find a one-to-one replacement for the library in another language, so developers might need to change the architecture or implement the missing functionality on their own. And even when the solution is found, small differences in, for example, serialization, may break the integration.
Take, for instance, the library implementing the OpenIDConnect standard. Since various parts of a standard are in different stages of approval, parts in the draft state might be missing in some implementations. Because of that, you may miss particular features - for example, simple logout.
Another example of serialization issues may be caused by the high complexity of the serialization configuration when you try to exclude some object properties from the serialized object representation. In a good scenario, your newly written app should show the same results as its predecessor in the "old" language, and the end-users should not notice any changes. So, it is necessary to double-check this functionality and make sure everything works as expected.
Lack of migration tools
Today, no tool can perform 100% correct translation from one technology to another. Although developers use code compilers and data migration technologies in individual cases, these instruments cannot replace humans and need a lot of supervision from developers. Therefore, the more extensive the software is, and the bigger codebase it possesses, the more time and effort it will take developers to migrate it.
With this in mind, it is essential to hire true experts to implement a tech migration project. You must be confident in the professionalism of the team that will upgrade your software or rebuild it from scratch. At the output, you should receive a program that works more efficiently compared to the previous version and contributes to business growth.
Post-migration support
After completing the tech stack migration, you need to ensure the application runs smoothly without crashes and unexpected errors. Make sure to check every migrated module separately and the system as a whole.
When the product goes into production, you may need to extend the customer care and support team. This is necessary for a timely response to unfamiliar problems and to resolve them quickly and efficiently. Also, you must make sure there is seamless communication between the service desk operators and the developers. Well-established cooperation contributes to the cohesive work of departments, enables rapid resolution of problems, and ensures the stable operation of the software.
Technology migration best practices
Software modernization is a non-trivial task solved with the consideration of project-specific details. Many factors influence the technology migration process, several of which are listed below:
software size and purpose
features complexity
current project language
current tech stack and OS
code quality and understandability
external integrations
custom APIs and connected services
development team skills
tech migration project budget
Having analyzed the above, organizations then decide on how to implement migration in technology. In particular, they choose which technologies to use and how exactly to transfer the software to a partially or entirely different tech stack.
Although the tools, methods, and deadlines for such projects are always set individually, experienced developers always use technology migration best practices when executing software re-innovation.
Writing software requirements specification
75% of all IT projects fail due to unclear or inadequate requirements
The software requirements specification (SRS) is a document that contains a complete list of requirements for a software product. A SRS outlines functional and non-functional software requirements and describes how the software will be used, what it will do, and how the users will interact with it.
Below, you can see the structure of the SRS of a software modernization project.
Using advanced migration tools
Whatever type of software modernization is conducted, such a project is very human-dependent. The quality of the upgrade will entirely depend on the expertise of developers and architects. However, there are tech migration technologies that can speed up the process of switching to new tech and make it less expensive. Here are some of them:
Assessing security risks and vulnerabilities
Software upgrades often involve data migration, storage changes, re-encryption, and other actions leading to increased vulnerabilities. In this regard, a mandatory practice when migrating tech stack is assessing risks and creating the most secure space to prevent information leakage.
Risks and vulnerabilities assessment includes:
Network security assessment
Firewall assessment
Code analysis
Log analysis
Intrusion detection
Encryption check
An important role in post-migration security assessment is given to penetration testing. This ethical hacking simulates cyberattacks to assess the security of a system and detect the most vulnerable spots.
Pentesting is not the same as traditional QA. The thing is, pentesters do not accompany the product during the development and do not test it on different implementation stages. They don't know how the system reacts to certain actions, so they "hack" it as real attackers.
Migrating incrementally
Unlike a big-bang approach, incremental tech migration involves individually migrating and testing smaller software sections. It allows for easier issue detection, reduces downtime, and minimizes the overall project risk.
Below is an example of incremental migration of an e-commerce platform:
Ensure successful project modernization
Leveraging codeless testing
Testing is a critical part of software migration to new technologies. As mentioned earlier, this is also one of the challenges of such a project because testers need to study two software (old and new) to adequately assess the quality of the product after migration.
Codeless automation testing can significantly speed up quality assurance. Of course, no-code tools cannot replace humans in developing unique test cases, but they can become great helpers when testing standard processes.
Switching from old tech: success stories from Erbis' clients
Organizations must embrace new technologies to meet current business requirements and achieve growth. Erbis' clients have already taken the path of innovation. Trace their journeys.
Phishfirewall. Anti-phishing software enhancement
Phishfirewall, an established security awareness software provider, chose Erbis to enhance a product that would prevent phishing attacks through the education of employees. The client already had a solution on a no-code platform, which, however, had many significant operational limitations. We proposed the building of a classic SaaS using a high-code approach.
Tech stack
Node.js
Express.js
React
PostgreSQL
Retool
Google Cloud
Docker
End product
An educational app that enhances users' awareness about different types of phishing attacks.
Business outcome
By offering an enhanced anti-phishing application to its customers, our client guarantees that the phish click rate after six months will be less than 1%. For comparison, the phish click rate of competitors is still more than 5% after six months.
Hoste. Property management software modernization
Hoste, a property management startup from Colorado Springs, created software to help hosts manage their properties. The initial version of the software was implemented on the no-code Salesforce platform. However, the client decided to completely rewrite it using cutting-edge technologies due to various performance and functionality issues.
Erbis helped the client implement a state-of-the-art SaaS using efficient technologies.
Tech stack
NodeJS
PostgreSQL
React
Google Cloud
Docker
End product
A full-fledged property management SaaS that allows customers to generate income by providing high-quality hospitality services to guests.
Business outcome
Since the introduction of the new software version, the client has experienced remarkable results, including
expanded customer base
improved user experience
enhanced system performance
zero downtime
boost in income
Digital printing company. POS and ERP upgrade
Our client, an established German digital printing company with a national network of printing shops, realized their point-of-sale (POS) software no longer meets business demands. They turned to us to update the POS software and switch the sales process to a modern automatic mode.
During refactoring legacy POS software for our client, we provided full-stack engineering services. They included product planning, requirements management, architecture design, coding, and quality assurance.
Tech stack
Spring
Google web toolkit
Hibernate
Java
Errai
End product
A robust ERP solution for managing sales, customers, and personnel. It enhances point-of-sale operations and adds value to general workflow through automation.
Business outcome
Our partnership with the digital printing company resulted in modern and reliable ERP software that was installed in 25 printing shops in Germany. After adopting the new software, the client received
automated workflow
reduced manual work
faster completion of repetitive tasks
Marketing SaaS provider. Cloud migration
Our client, a major European marketing SaaS provider, faced the problem of insufficient capacity and high costs on their IBM platform. They decided to change the cloud space and turned to Erbis to help choose a cloud provider and implement seamless cloud migration.
After thorough research, we opted for Amazon Web Services (AWS). We implemented migration from IBM to AWS in three stages: data migration, replication, and security.
Tech stack
AWS
EC2
RDS
Java
Spring
Spring Cloud
Big Data
Hadoop
Kafka
Apache Flink
PostgreSQL
IBM DB2
End product
A full-fledged marketing SaaS running on the AWS platform.
Business outcome
The client confirmed multiple benefits obtained on the AWS platform:
Scalability
Security
Flexibility
Reliability
Automation
Logistics company. Supply chain software modernization
Our client, a logistics company from San Francisco, provides software for carriers and their customers. Their supply chain app was developed many years ago. Eventually, the time came when it no longer met the growing business needs.
Erbis has modernized the supply chain software by
switching it to the microservices architecture
building new web forms that integrate into customer portals
supporting existing platforms while delivering new features to existing customers
Tech stack
JAVA EE 7
Oracle
Saas
Microservices
AWS
Angular JS
End product
A supply chain management solution that aggregates data from more than 40 US-based carriers.
Business outcome
The software is used by Fortune 500 companies, helping them reduce costs and increase operational efficiency. It optimizes business processes, facilitates staff work, and helps to rationally use available resources.
Conclusion
Rapidly changing technologies and innovations force organizations to seek the most efficient ways to implement and maintain their software. Moving from outdated technologies to newer ones can improve quality, enhance functionality, and increase the productivity of the application. At the same time, such a tech migration poses new challenges for organizations, forcing them to look for effective and secure solutions that can benefit business.
If you decide to change the tech stack of your software, you need to seriously address your choice of the technology migration team. Today, there are no tools that could perfectly translate a program from one programming language to another or move it from an outdated IT infrastructure to a modern one.
Most of the work involves manually rewriting the code, adjusting the IT environment, or rearchitecting the system. Therefore, the quality of the final product will depend on the expertise of the development team. If you cannot find one in your location, consider outsourcing the project abroad. Remote collaboration has long been proven effective. And developers from, for example, Eastern Europe deliver a quality product for a much lower cost than their American and Western European counterparts.
At Erbis, we have 11+ years of experience provigin software development and tech modernization services. We will be happy to discuss your project and propose our technology migration plan. You are free to decide if our approach suits your expectations and whether you you want to come into mutually beneficial collaboratio with the Erbis team.
