Introduction

I’ve never worked at a consultancy myself, I’ve had the opportunity to dive into codebases that were initially developed by consulting firms. What I found was eye-opening: a mix of hurried patches, minimal documentation, and a mountain of technical debt.

This article explores the hidden costs of these bad codebases in production and why they often become a burden on the companies that rely on them.

Let’s get started

In the fast-paced world of software development, companies often rely on consultancies to help bring their products to market quickly. There’s a dark side to this arrangement: bad codebases. When consultancies deliver suboptimal code, it can have far-reaching consequences for the product, the company, and its customers. This article explores how and why bad codebases make their way into production and the impact they have on the long-term success of a project.

The Race to Deliver: Speed vs. Quality

Consultancies are often brought in with tight deadlines and aggressive project timelines. The pressure to deliver quickly can lead to shortcuts in the development process. These shortcuts may include:

• Lack of Proper Documentation: To save time, documentation may be minimal or entirely absent. This makes it difficult for future developers to understand the codebase, leading to maintenance challenges.

• Technical Debt: To meet deadlines, consultancies might implement quick fixes rather than long-term solutions. This creates technical debt that accumulates over time, making the codebase increasingly difficult to manage.

• Inadequate Testing: Rushed timelines often lead to insufficient testing. Bugs and vulnerabilities may go unnoticed until they become critical issues in production.

By neglecting these clean code principles, consultancies may deliver a product that meets immediate requirements but sets up a precarious foundation. The resulting codebase becomes a labyrinth that’s not only hard to navigate but also expensive to refactor or extend, thereby impeding the software’s evolution and scalability.

The Transient Nature of Consultancy Engagements

Consultancies are typically engaged for a specific project or period. Once the engagement ends, the consultants move on to their next project, leaving the client to manage the codebase. This can create several problems:

• Lack of Ownership: Since consultants aren’t typically involved in the long-term maintenance of the codebase, there’s less incentive for them to ensure the code is clean, well-documented, and maintainable.

• Knowledge Transfer Gaps: The transition from consultants to in-house teams often lacks proper knowledge transfer. In-house developers may struggle to understand and work with the codebase, leading to inefficiencies and errors.

• High Turnover: The high turnover rate in consultancy firms means that the developers who originally worked on the project may no longer be available to provide support, leaving the client without a knowledgeable resource to turn to.

The Impact of Bad Codebases on Production

A bad codebase doesn’t just cause headaches for developers; it can have serious implications for the business as well:

• Increased Costs: Maintaining and fixing a bad codebase requires more time and resources, leading to higher costs. What seemed like a cost-effective solution in the short term can become a financial burden in the long term.

• Slower Development Cycles: As technical debt accumulates, it slows down the development process. Adding new features or fixing bugs becomes increasingly difficult, delaying product updates and new releases.

• Poor User Experience: Bugs and performance issues that stem from a bad codebase can negatively impact the user experience. This can lead to customer dissatisfaction, increased churn rates, and a damaged reputation.

Why Do Bad Codebases Happen?

Several factors contribute to the prevalence of bad codebases delivered by consultancies:

1. Misaligned Incentives: Consultancies are often rewarded for delivering on time and within budget, not for the quality of the code they produce. This misalignment of incentives encourages speed over quality.

2. Lack of Long-Term Perspective: Since consultancies are typically focused on short-term projects, there’s little consideration for the long-term health of the codebase.

3. Insufficient Oversight: Clients may lack the technical expertise to properly oversee the work being done by the consultancy, leading to suboptimal code being accepted into production.

Mitigating the Risk of Bad Codebases

While the risk of receiving a bad codebase from a consultancy cannot be entirely eliminated, there are steps that companies can take to mitigate this risk:

• Set Clear Expectations: Clearly communicate the importance of code quality, maintainability, and documentation from the outset of the project. Make these factors part of the success criteria.

• Engage in Code Reviews: Regular code reviews involving both consultancy and in-house developers can help catch issues early and ensure that the codebase meets the required standards.

• Prioritize Knowledge Transfer: Ensure that there’s a formal process for knowledge transfer from the consultancy to the in-house team. This includes comprehensive documentation and training sessions.

• Continuous Integration and Testing: Implement continuous integration and automated testing to catch bugs and issues as they arise, rather than allowing them to accumulate.

Conclusion

Bad codebases delivered by consultancies can have a profound impact on the long-term success of a company project, so make sure when you are asking a consultant to do it, review their past work, and establish clear, ongoing communication to ensure that the quality and maintainability of the code meet your project’s needs and standards.