Tame and Maintain

Legacy .NET Development

The Problem

Many organisations have legacy systems in place that are essential to some aspect of the business. Often these applications have been developed in-house and adapted and extended over the years.

The same story plays out time and again across many companies:

  • The members of the original development team one-by-one move on to pastures new taking some of their key knowledge with them.
  • Eventually, a completely new team finds themselves responsible for an application that holds a great deal of business value but has come with its share of baggage.
  • They have inherited a large codebase with plenty of associated technical-debt.
  • The application may have an outdated architectural model unsuited to the needs of the business’ current customers.
  • The system may have little or no automated test coverage.
  • Documentation may be limited or non-existent.

It is easy for the new team to begin to feel lost or overwhelmed. The symptoms are common:

  • The team don’t want to change code for fear of introducing bugs.
  • There are areas of the application that are little-understood.
  • Parts of the system are severe performance bottlenecks.
  • There are suggestions that it is time to think about rewriting things from scratch.

If any of this sounds familiar, then you have come to the right place.

How can we help?

Almost always, a complete rewrite is not the best answer. We can help to tame and maintain an important but unruly application and drive modernisation efforts to allow you to extend the lifetime of a legacy Microsoft .NET system.

Our team are experienced in a variety of tried-and-tested techniques for incrementally modernising large and complicated .NET codebases.

We specialise in:

  1. Continuous integration – Implementing systems that provide rapid feedback from testing after any code changes.
  2. Automated testing – Building a test-suite with comprehensive coverage of automated unit and integration tests around existing functionality.
  3. Incremental refactoring – Changing the structure of code to simplify it without changing its behaviour.
  4. Data-access refactoring – Improving the database design itself or the surrounding data-access layer code.
  5. Application re-layering – Implementing a separation of concerns across the application to build a strong layering scheme.
  6. Application re-architecting – Adapting an existing application to a different architectural design e.g. moving an application into the cloud.
  7. Optimisation, metrics and profiling – Careful and comprehensive analysis of application performance to resolve speed and load issues.
  8. Best practices – Applying clean coding, object-oriented and Agile best practices.
  9. Build and deploy infrastructure – Ensuring that the application can be built and deployed reliably in an automated way to any necessary environment.
  10. Continuous delivery – Instigating repeatable, reliable and predictable software release processes to speed up delivery cycles.

Each company, team and legacy application is unique, each requiring a different approach with a combination of the techniques described above.

If you have a legacy .NET application that you would like to discuss with one of our technical experts, please don’t hesitate to get in touch and we will work with you to define the scope of what you can achieve.