- Home
- Services
- Transformation
- Technical Debt Assessment
- We have to take over software written by others, and we don’t know what state it’s in
Code inherited from another vendor
We have to take over software written by others, and we don’t know what state it’s in
Anyone who inherits software written by others doesn’t know what will break when they touch it, because the tests that would describe it are missing, and doesn’t know where to start writing them, because the debt has never been mapped. Without either, every change costs more than expected, the knowledge that left with the people who wrote the code can’t be rebuilt, and even releasing still depends on those who have gone.
Book a callDoes this sound familiar?
- The people who wrote the code have gone, or can’t be reached for everyday questions.
- The first change we asked for cost far more than planned, and we can’t say why.
- It isn’t clear how the software is built and released, and some of the access was held only by the people who were here before.
- Starting again from scratch keeps coming up, and there is no way to know which business rules would be lost.
- We have to decide how much to invest in this software, and all we know of it is what the people who handed it over have told us.
How do you end up with software nobody knows?
Code says what the software does and stays silent on why it does it that way. The gaps start there, with the knowledge that left with the people, and branch out into missing tests, debt that was never mapped and a release process that someone else knew how to run.
The knowledge left with the people
The reasons behind decisions, the edge cases added over time and the business rules that exist only in the code were in the heads of the people who built it. You rebuild them by writing tests and reading the code together, one edge case at a time.
Nothing tests the current behaviour
Without tests that pin down current behaviour, every change is a bet on what might break elsewhere. The first tests go on the functions the business uses most, before anything is changed.
The debt has never been mapped
Years of accumulated debt are written down nowhere, and the person taking over hasn’t yet seen the whole system. Until there is a map of the areas that slow changes down and the ones that can stay where they are, the choice between fixing, containing and rewriting remains a matter of opinion.
Someone else knew how to release it
Build, environment configuration and release steps often live in a local script or in one person’s memory. Until they become a pipeline your team can read and run, every release still depends on the people who left.
What changes when inherited software becomes yours
Instead of an account from the people who handed it over, you have a map of the state of the code, written by someone who didn’t build it and has nothing to defend, with the areas that slow changes down ranked by how much they slow them. The decision to fix, contain or rewrite is taken on that basis, without passing judgement on whoever came before.
Releases go out from a pipeline that anyone on the team can run, with access in your hands, and the first changes go out protected by tests. Anyone who joins later will find in the code and the tests what used to be known only to those who left.
Let’s start with the software you inherited
We’ll work out with you where to start looking at the system, and whether the Technical Debt Assessment is the right first step.
Message sent
Thanks for reaching out. Our team will get back to you within 24 hours with a tailored proposal