I’m coming to terms with the fact that Misha, my dog, is getting old. 

We’re going to have to part ways sooner than I thought. And I have to make some important decisions over the next few years about his:

  • Health
  • Age
  • And physical condition

I want to make sure his final years are as full as possible.

Like anyone, I research, and some of the things I’ve found are wild. Just the other day, I saw a service that clones pets! You send a bit of your dog’s biomaterial to a lab in Texas, and they: 

  • Create
  • Freeze
  • And implant an embryo whenever you’re ready

But cloning is a faraway, dramatic solution, and there are plenty of things I can do with Misha now. I love him and am happy to journey with him to the end.

I’ve been thinking about Misha because I’ve been thinking about technical debt recently, and there are too many parallels to ignore: 

  • He’s no longer a puppy, and the code for our projects isn’t, either 
  • Decisions were made in the past that continue to affect things now
  • And it’s harder to integrate new things

But just like with old dogs, you can take steps as an engineering manager (EM) with old code (specifically with tech debt) to make the aging process easier and minimize problems. 

Here’s what those are.

Prepare people to meet your dog

As your dog ages, you can’t just give them to someone new and say, “Take them for a walk.” Instead, you prepare the person with a list, such as:

  • What the dog can eat
  • What they hate
  • Their quirks
  • Habits
  • And how to get them to do things

Just like people, dogs become more set in their ways. Knowing their patterns and preferences becomes crucial. 

As an example, I know someone with a dog who only walks around their house using a certain path. Taking him another way freaks him out, and he’ll try to run away. Failing to tell someone this information sets them up for their own freakout when it happens.

You can probably see where this is going. The more technical debt you accumulate with a legacy product, the more upfront guidance you have to give when onboarding new engineers. 

Without it, at the very least, they’ll have their own freakout. At the most, they’ll break something.

And if you don’t feel like you know your system well enough to make such a list, it’s time to start learning.

Make changes with care

Aging dogs’ metabolism changes, requiring a special diet. Puppies can stomach all kinds of food, but older dogs like Misha need to be much more careful. So, I get special food recommended by our vet.

Similarly, older projects require care when adding new things. A common and important question you’ll need to get good at answering (if you aren’t already) is whether the change is even worth the headache. Sometimes, integrating a new feature into an old infrastructure is just too much trouble.

Other times, you can build it in parallel, so everything functions together but with only partial integration.

For example, I once worked on a CRM for a number of years, and we later decided to implement a search function. We had a lot of technical debt and decided that trying to integrate the function fully might cause more problems. So, instead, we made it a separate, lightly integrated service.

In short, consider the alternatives your “dog” needs.

Keep up with exercise

As Misha gets older, I keep him busy with things to do. If he doesn’t keep moving, he’ll quickly lose his mobility. So, taking him on regular walks is even more important now than when he was younger.

He also needs to keep his mind sharp. Have you ever heard of dog puzzles? They require the dog to solve a simple device so they can get to the treats inside. 

To me, this is like basic project maintenance. The difference is the “exercise” is scheduling time to see what you can improve and ensuring you have the resources for it.

These don’t have to be big things, though. 

With Misha, even a walk around the block a few times a day is enough to keep him in good condition. For your project, ask what you can make a little bit better today or what you can upgrade, even if it’s not connected to a critical error. 

You won’t win every battle, but you’ll extend its life and slow down the rot.

And do the same with regular vet checkups

Even with regular exercise and healthy nutrition, you’ll still need to regularly visit the vet. 

For instance, maybe your dog’s digestive system isn’t working properly. You’re much more likely to catch this issue in time with a checkup. Unfortunately, this is your best bet since dogs can’t tell you what’s wrong, and many times, it’s difficult to even determine if something is.

It was only when we did a stress test of our CRM’s search functionality that we discovered it was overloaded and slow. Our users, like Misha, didn’t tell us about this and instead used another search service, much to our disappointment.

Unfortunately, this happens, but the point is we wouldn’t have known about this issue without regular code checkups like these. After we found out, we were able to build our AI search process and solve the issue.

So, if you can (and aren’t already), implement steps to:

  • Assess different parts of the system
  • See how much technical debt they have
  • See if there are risks of critical failures
  • And determine what components need more or less resources

Help your dog get around

Misha doesn’t move like he did when he was younger. If I want to take him to a park for a long walk, it’s better to take him by car first instead of walking the whole way. While there, I have to remember to give him enough rest as we go. 

In the past, we would use services like Vercel or Replit when starting a new project. But products outgrow these platforms once they’ve been around for 5-6 years, whether that’s due to expenses or changing needs. So, migration to another platform like Google Cloud, AWS, or even a VPS is necessary. 

You know as well as I do none of this is a straightforward, simple transition. Just like with an aging dog, nuances are involved. Take them into account, and give them the care they need.

Keep your dog’s medical history

I can’t say enough how important this is. 

You’ll likely change vets over time, and they’ll need to know your dog’s medical history. You may think you’ll be able to remember everything, but it’s natural to forget over time.

So, again, you can probably tell what’s coming, but in our world, this means documenting as much as possible for products and features. A lack of documentation is itself a form of technical debt. But as you also well know, nobody ever has enough resources for this task or feels like they could spend their time better elsewhere.

There is, however, a simple question you can ask in response to this: how are they going to spend their time better elsewhere if no one even understands how the system works?!

Maybe don’t get so animated when asking them, but you’ll make your point well. Any changes you or they want to make to technical debt or other areas completely rely on having this documentation.

In addition, you’ll solve the problem of only having one or two people who know the system inside and out. When they’re busy and can’t help with onboarding or other duties, turn to the documentation. You can even suggest AI tools to help generate it.

Pay attention

Younger adult dogs can often take care of themselves. They signal when they need to go outside and look at you very specifically when they want a snack. If you have (or had) a dog, you know this look.

Older dogs often find it harder to communicate when something’s off, wrong, or changing, which happens plenty. They:

  • Walk more slowly
  • Sleep differently
  • Don’t eat enough
  • Have blurry eyes
  • Scratch too much in one spot
  • And so on 

We’re all busy adults, so it’s easy to miss something important if we don’t pay attention to it. But we can also build in time or use tools to give something the attention it needs.

For instance, I recommend writing code that tests your other code.

This is a huge investment, but it signals that other parts of the code are affected when you make a change. This improves your infrastructure’s longevity, as you’ll know quicker when issues emerge so you can take timely action before they lead to a critical error.

The short version: be good to your code

Aging is a difficult process, whether it’s your dog or code getting older. Tech debt is, of course, a part of this with the latter. So, as the EM, give it the same care you’d give your dog.

Take steps such as the following:

  • Familiarize people with your code: make sure all new engineers know your product’s quirks
  • Be careful about integrating new functions: sometimes, new features can break your code (and sometimes, you can do partial integrations)
  • “Exercise” your project: keep things fresh and sharp with regular maintenance
  • Conduct regular checkups: older code might have problems you won’t see until (and unless) you check
  • Take care when migrating: legacy projects need to be transferred to new servers that better fit their needs, but this needs careful planning and execution
  • Documentation, documentation, documentation: older products have nuances that need to be documented in order to be taken into account
  • And pay attention: set up automated testing so you’re alerted to issues

By integrating these practices at work, you’ll improve the health and longevity of your product. You’ll also make everyone’s work lives just a bit easier by helping minimize the messes they need to clean up.

Want more tips on leading effective software engineering teams?

Join my newsletter if you’ve found this content useful

Originally published on Medium.com

Content in this blog post by Alex Ponomarev is licensed under CC BY 4.0.