Top 3 Problems We See When Taking Over A Software Project

In our last blog we explored why an expectation of bug-free or “flawless” software is unrealistic and a prohibitively expensive pursuit, versus building software and expecting some minor bugs to pop up. As a reminder, going back in post-development to fix a glitch that arose during real-world applications or following third-party integrations should be expected and is more cost-effective than chasing perfection at the outset.

A related but far more complicated scenario is when software developers are tasked with fixing another developer’s code. Ideally, this scenario wouldn’t present unsurmountable challenges – if the original developer and customer communicated well, and the codebase was structured to adhere to commonly accepted standards and conventions. The following are some scenarios that can lead to issues, along with ways to mitigate problems as you’re selecting your software development team (or individual).

Offshore Development Teams

The common lure of offshore software development is lower cost. However, that upfront perk is quickly erased if problems emerge during the development process.

The Problems

Accountability Issues

Ensuring accountability can be difficult with offshore teams, especially when they operate in different legal jurisdictions. If an offshore team disappears or fails to deliver quality work, it may be impossible to hold them accountable. You are then left with poorly written code or in some cases, no code at all.

Communication Barriers

Time zone differences, language barriers, and cultural differences can lead to miscommunication and misunderstandings, resulting in code that doesn’t meet the project requirements. A customer who is or has a native speaker or expat on their team may overcome the language and cultural hurdles, but significant time zone differences can lead to delays that add frustration – and costs.

Quality Concerns

Offshore teams may not adhere to the same coding standards and best practices that one would expect from an onshore development team, leading to poorly written code that is difficult to maintain and extend or modify.

Mitigation Strategies

To mitigate these risks you would need to establish clear contracts with offshore developers, including detailed project specifications, deliverables, and quality standards. This may require a level of expertise – both technical and legal – that is outside the reach of many small businesses or individuals. You also need to perform regular check-ins and code reviews to help ensure the project is staying on track.

Relying on a Sole Developer

Relying on a sole, dedicated developer might initially seem like a cost-effective and streamlined solution, giving you direct access to hands-on expertise. However, whether it’s a single developer within an organization or a sole proprietor, this development scenario can be problematic for the developer next in line to pick up the pieces.

The Problems

(Lack of) Documentation

Given that they are the only ones working on the code, solo developers may not prioritize thorough documentation or fully explaining the code, leaving following developers with little to no guidance on the inner workings of the software. This oversight and poor planning can lead to prolonged periods of code analysis and guesswork.

Knowledge Silo

Your solo developer may possess tacit knowledge about the software that isn’t documented anywhere. This loss of institutional knowledge can be detrimental, making it difficult to debug issues or enhance the software. This is especially problematic if the developer has a unique approach to coding that doesn’t adhere to an existing coding standard; new developers must then spend considerable time trying to decipher and understand that style, causing delays and increasing your costs. Many sole developers claim to be “full stack” developers suggesting they are expert at most things. This is rarely if every true.

Availability

This is a big one: That streamlined communication that initially may have seemed so appealing dissolves if your sole developer – your only contact – is out with an extended illness, family emergency, or vacation. While these are all valid reasons for being unavailable, not having other team members to fix issues that may arise or keep the momentum can hinder the progress you relied upon to resume business.

Mitigation Strategies

The best strategy to avoid these pitfalls is to have a collaborative development process so that multiple team members can engage in code reviews and pair programming to distribute knowledge among the team. A well-run software development group operates on the assumption that any member of the team may be unavailable at any time. They enforce best practices that include version control, code change reviews, comments and testing.

Poorly Written Software

Inheriting poorly written software is a nightmare scenario for any developer. Such software can be so riddled with bugs and inefficiencies that it becomes virtually unusable, either never getting released or being released and then quickly retracted.

The Problems

Technical Debt

Poorly written software often accumulates significant technical debt, with shortcuts and hacks that may temporarily fix issues but create larger problems down the line.

Bug-Ridden Code

A lack of adherence to best practices, inadequate testing, and poor design decisions can result in software that is unstable, unscalable and so filled with bugs that the “fix” is often starting over completely.

Performance Issues

Inefficient code can lead to performance bottlenecks, making the software slow and unresponsive. For internal use it can throttle your business processes. Externally this will frustrate your end users and harm your reputation.

Mitigation Strategies

Refactoring – or restructuring – code is often necessary to address issues in poorly written software. This involves rewriting portions of the code to improve its structure and performance without altering its intended functionality. Even well written software over long spans of time can require refactoring. Ask your developer about their coding standards, their testing practices to help catch and fix bugs early, and whether other team members are available to review coding to reduce the amount of technical debt and the need for follow-up fixes.

Development Teamwork Makes Your Software Dream Work

Understanding common and potentially debilitating problems with each of these scenarios can help you as you consider your software development options and arm you with information to pose questions about accountability, collaboration and peer reviews, testing, and documentation. Ensuring your software development team checks these boxes at the outset maximizes your chances of getting the desired outcome.

Should the outcome still be substandard, reach out to the FHG development team. While inheriting another developer’s code is not an ideal situation, it’s one we have encountered numerous times in our development work. Experience, proactive management, collaboration, documentation, and a commitment to quality and accepted standards can many times transform even the most daunting codebase into the maintainable and robust solution that you expected the first time around.