Legacy meets DevOps: Can you teach an old dog new tricks?

Sean Woodliffe
March 26, 2024

Picture this: you’ve just been handed the keys to a software product that’s been chugging along for a decade. It’s like inheriting your grandfather’s classic car — it runs, but it’s definitely seen better days. You pop the hood and find a tangle of old .NET Framework components spread across a few dusty virtual machines. But hey, at least one of them is on long-term support (LTS), so you’ve got that going for you!

Let's dive into what we would do next to get a handle on this old thing.

Step 1: Audit the Documentation (or Lack Thereof)

First things first, let’s see what we’re working with. You embark on a mission to uncover any existing documentation, if you’re lucky, you might find a few ancient pieces of original information (read: Word docs), or some half-decent readme in the repo or Notion page. But more often than not, you’ll be left with a treasure map full of blank spaces and it’s your job to fill it in. Time to channel your inner archaeologist and start asking questions, because you’ll need to understand as much of the map as possible. This should lead you to…

Step 2: Identify the Key Players

You’ll want to identify the key people who hold the secrets to this legacy application. Seek out the SMEs who have been maintaining the system as they’ve likely developed a deep understanding of the code, knowing its quirks and eccentricities like the back of their hand. Engage these SMEs and tap into their knowledge to gain a deeper understanding of the application’s inner workings. Here's when you’ll need to go back to Step 1 and fill in the blank spaces of your map as you learn more — remember the aim of the game is to leave this product in a better state than you found it.

Also, don’t forget about the client — they’ve been living with this product for years and have valuable insights into its strengths, weaknesses, and future aspirations. Schedule some time with them to gather their perspective, understand their pain points and where they would love to take things. After all, they’re likely the ones who’ve been keeping this legacy application alive and kicking all these years.

Step 3: Prioritise the Modernisation Efforts

Armed with a better understanding of the application and its stakeholders, it’s time to start prioritising the modernisation work. It’s like support triage — you need to determine which areas require immediate attention and which can wait a bit longer.

In order to prioritise them, we first need to start by identifying some of these modernisation efforts, the low-hanging fruit that I would normally go for in a situation like this — quick wins that can demonstrate progress and build momentum.

Setting Up Automated Deployments

One of the first steps in embracing DevOps is to automate your deployment process. Say goodbye to manual deployments and hello to a world of automation – by doing this, you can reduce the risk of human error, increase the frequency of releases, and make deployments a non-event (yes, deploy that change on Friday).

Start by identifying the current deployment process and mapping out the steps involved. Then, explore tools like Octopus Deploy (my personal favourite), Jenkins, Azure DevOps, GitLab etc. to create automated deployment pipelines. These tools (bar Octopus) can handle everything from building the code to running tests and deploying to various environments. It’s like having a trusty sidekick that never gets tired of pushing code.

Running a Code Analysis Tool

Next up, let’s talk about code quality. Over the years, that legacy application has probably accumulated its fair share of technical debt. It’s time to shine a light on those dusty corners and identify areas for improvement. Running a code analysis tool is giving your codebase a thorough health check-up. Tools like SonarQube, ReSharper, or Visual Studio’s built-in code analysis can help you identify potential issues, such as code smells, security vulnerabilities, and performance bottlenecks. By addressing these issues incrementally, you can gradually improve the quality and maintainability of your legacy application.

Setting Up Observability

Now, let’s talk about gaining visibility into your application’s behaviour. It’s time to set up observability and monitoring to keep a watchful eye. Think of it as giving your application a fitness tracker — you want to know how it’s performing, where it’s struggling, and when it needs attention.

Implement logging frameworks to capture valuable insights into your application’s runtime behaviour. Explore tools like ELK stack (Elasticsearch, Logstash, Kibana), Splunk, or Azure Application Insights to centralise and analyse your logs. Set up dashboards and alerts to proactively monitor key metrics and detect anomalies before they become showstoppers.

But remember that observability doesn’t stop at logs. Consider instrumenting your code with tracing and metrics collection. Distributed tracing tools like Jaeger or Zipkin can help you understand the flow of requests through your system, identify performance bottlenecks, and pinpoint the root cause of issues. Metrics collection tools like Prometheus hooked into Grafana allow you to gather and visualise key performance indicators (KPIs) and make data-driven decisions.

By setting up observability practices, you can gain a deep understanding of your legacy application’s health, performance, and behaviour. Giving your application a voice to tell you when it needs help is the best way to do this and allows you to proactively address issues and ensure a smooth user experience.

In an upcoming blog, we’ll dive into further steps we could tackle on this application. Is it time to break down that monolithic structure into smaller, more manageable microservices? Can you leverage containerisation technologies to improve portability and scalability?

Throughout the process, keep an eye on the end goal — transforming this legacy application into a modern, maintainable, extensible system that can continue to deliver value for years to come and more importantly, leaving the product in a healthier, more documented state than when you found it.

We know that undertaking the task of modernising a legacy application is no small feat — it’s a journey filled with challenges, surprises, and the occasional moment of triumph. But with a solid plan, a dedicated team, and some common sense, you can breathe new life into that decade-old product.

So roll up your sleeves, put on your detective hat, and get ready to unravel the mysteries of the legacy application. Who knows, you might even have some fun along the way.

If we can help you with a legacy product, or something new, get in touch on sean.woodliffe@end-game.com.


Recent Posts

Insights delivered to your inbox weekly.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

Get in touch

We’d love to see how we can work together
Send message
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.