Secrets to Managing a Software Modernization Project

“How in the heck can you love working in software maintenance and modernization?”  This is a question I’ve gotten asked quite a lot over the years. To many people, working on challenging, older, complex, or brittle systems is something they like to run away from. But not us. There’s a lot of satisfaction in improving the software that is often at the heart of our client’s operations. Among other reasons, it’s meaningful to work on projects that matter.

However, a critical component of success also has to do with the way we run projects. Over the years, we’ve compiled several tenets to our approach that help make a project run smoothly. These seem like secrets because many of them are just so different from what you find in traditional operations, but these ideas aren’t new. Many of them are inspired by the Agile Manifesto, particularly its twelve principles. The difference is that instead of looking at Agile as a methodology and debating the merits of sprints and story points, we’ve always taken it more as a guiding philosophy that we can use to build our own way of working.

As someone with a background in business, the first time we experimented with some of these, I admit that I bristled. I loved the feeling of certainty, perfection, and accuracy. When members of the team mentioned these as project requirements, I was often confused because it was just so different from what I was familiar with. A decade in, however, I’ve learned that, at least when it comes to software modernization, these practices work.

Focus on the System, Not Just the Components

Your health depends on more than just the biological mass of your body, and your software is more than what’s in your source code. At Corgibytes, we take a holistic approach to code health. In addition to helping you pay down technical debt and add new features, we also look outside the codebase to help discover and resolve root causes that may not be immediately obvious. Some examples include: DevOps, Architecture, Documentation, Organizational Structure and Culture, Team Dynamics, Business Initiatives, and more.

Embed Empathy into the Process

Empathy is an essential skill for healthcare workers and software developers. For over a decade, we’ve woven our core value “Act with Empathy” into our operations and daily development practices. When empathy is applied directly, we have seen stunning positive results. For the past two years, I’ve been digging even deeper into this principle and am currently working with Pearson to publish our learnings into a book. Keep an eye out for Empathy-Driven Software Development coming in 2023.

Communicate for Historical Mutual Understanding

All code is communication. We don’t code for the compiler, we code for people. The ability to make progress on a codebase largely depends on how well you understand the system and the context that you’re developing for. This means working with people who have different skills and experiences and finding ways to proceed with joint solutions. Additionally, people on a team come and go. As we build our understanding, we emphasize creating durable artifacts of our work so that the people who come after us have an easier time understanding why choices were made.

Maintain Technical Excellence

Honing your skills requires a commitment to professional development. Early in my career, I worked at a company where I was expected to be 100% billable and then somehow squeeze in professional development. But you can’t add to something that’s already full. So when we had the chance to build professional development into our operations, we did. While it can be awkward to have conversations with clients about why we won’t staff someone on their project for more than 36 hours per week, this small reduction in billable hours delivers lots of value to a project by helping to ensure our team members are rested, focused, and building new skills.

Be Prepared for Surprise and Change

Even with effective planning and preparation, things don’t always go the way we expect. This is why our operations lean heavily on practices that allow us to be responsive. We don’t adhere to a specific type of methodological dogma to achieve this. To us, Agile is much more than sprints, standups, and story points. While team rituals can be incredibly beneficial, rote execution of a predefined process often fails. We focus on pragmatism, excellent communication, collaboration, trust, and empathy. We’re not afraid to experiment with new ideas and enjoy co-creating processes that work for your situation.

Make Safety a Prerequisite

We admit it — we took the wording of this principle directly from the Modern Agile movement. In many cases, we recommend activities that are designed to stabilize the system and mitigate risk. This is rooted in a sense of safety,  protection, and ethics. Some clients have found it frustrating when Corgibytes advocates strongly that significant safety concerns are prioritized over deploying new features. For example, making sure the code lives in a source control system instead of in a local environment or that customers’ passwords need to be encrypted. These recommendations come from a sense of care, duty, and recognition that having a strong foundation is the key to long-term health.

Estimate Is a Verb, Not a Noun

Responsible fiscal management is a critical aspect of any project. Budgets are real and it’s important for businesses to manage their expenses. That’s why we approach estimating as an ongoing activity instead of a static deliverable. The software systems we are specialists in working with are inherently complex with significant uncertainty, like the weather. This means that linear project management often fails, wasting precious time and budget. Our approach to estimating is to continuously ask the right questions, communicate using ranges and confidence values, and regularly refine the definition of done that will help you meet your overall business and project goals.

Build Hygiene Habits

Health, whether that’s in humans or software systems, is an ongoing activity. Just like you need to brush your teeth every day to prevent big problems later, there are small development practices that when performed regularly make a big difference. This includes activities such as upgrading languages, frameworks, and third-party dependencies, writing code in a way that’s intention-revealing, taking a test-first approach to writing and refactoring code, extracting methods so they don’t become too complex, resisting the copy and paste urge to avoid duplication, and many, many others.

Optimize for Resilience and Longevity

Too much short-term thinking can lead to brittle systems that are prone to sudden breakage. That’s why we constantly keep our eyes on the horizon, balancing short-term needs with long-term goals. When a codebase is healthy, it can recover quickly when it becomes stressed and operate sustainably into the future.

Whole Team Approach

Healthcare teams are much more than just a doctor. Behind the scenes, there are teams of nurses, technicians, administrators, janitorial staff, assistants, and specialists who all work together in concert to give you the care you need to improve your health. This is why Corgibytes works with a single blended rate. While you may interact with individual Code Whisperers on a regular basis, there is a whole team behind them to support their work.

Gradual Gradients over Brusque Binaries

Effective change often happens gradually over time. We’ve seen this time and again when it comes to digital transformations. Hard cutoffs can be tempting but they rarely go well. Our approach is more diligent. By replacing a system over time, eventually, you can get a brand new app with less risk and the benefit of operational continuity. When you think about it, this is exactly how our bodies work. Cells are constantly regenerating at different rates and every few years, you might even consider yourself a new person.

Business Goals Drive Recommendations

Just like a doctor’s treatment plan will vary based on their patient’s goals, our recommendations are not one-size-fits-all. The better we understand your business’s broader strategy, the better we can devise solutions that will help you achieve them. This way, we are constantly working together to assess your Return on Investment and can adapt as needs change.

Software projects work best when we don’t just talk about adaptability and communication, but actively incorporate them into our operations. Learning to love legacy code has been a joyful journey for me, and I hope it will be for you, too.