All articles

Getting Rid Of Bad Developers During A Project

Are you stuck with some bad developers?

Trying to get rid of bad developers during a project can be a nightmare.

All software products need to be well made if they are to succeed in this highly competitive marketplace. Only then will they have the chance of making the big bucks.

Here’re a few amazing case studies of companies who hired DevTeam.Space to build their software products:

  1. DentaMatch – Healthcare Android and iOS App
  2. eTournament Management Application – eGaming Management Web Application
  3. CSGO Team Management Project – Web-based Management Program

Introduction

Picture the scene…

You are an entrepreneur or a senior project manager in an enterprise company. You have a competent software development team, however, you need more developers for a new project.

After scanning the market, you hire a few freelancers or developers from a software development company. Then your nightmare begins.

They perform sub-optimally, impacting the project by causing time and cost overruns. Reaching your breaking point, you decide enough is enough and decide to get rid of them.

Recognize the story? Well, if you do then you aren’t the only one.

This is a daily problem in the software development industry. You can read more about this in my article “10 biggest challenges when developing an app”.

DevTeam.Space recently took over the project development for Adventure Aide, a tourism and recreation app. Several freelance developers had been working on this project since 2014, however, the project was stalled and failing. Our DevTeam.Space development team took over the project.

We refactored and rebuilt the application architecture for both the mobile site and backend (read more about this in “Adventure Aide”).

Our work on this project gave us the motivation to write this guide to help other companies in getting rid of bad developers during a project.

If you are one such company then read on, as we will now explain the steps you need to take to ensure you get your project back on the road to success.

Contents

1. Finding competent developers to replace the underperforming ones
2. Invoking the “exit” clause in the contract with the ineffective developers
3. Take control of any open-source tools used by the earlier developers
4. Transition-in the source code
5. Ensure sufficient documentation for the new developers to get started
6. Assess the impact of below-par performers
7. Transition the relevant sub-projects to the new developers
8. Integrate the new developers in your team
9. Facilitate collaboration between the new developers, testers, and DevOps engineers
10. Ensure that the code review process covers the work by the new developers
Managing your project after replacing developers mid-project

1. Finding competent developers to replace the underperforming ones

 

replacing bad developers

You need to first find competent developers so that you can replace the ineffective ones you’ve found yourself stuck with. The kind of software developers that you are looking for should possess the following skills and competencies:

  • They should consistently demonstrate high professional ethics.
  • Since you can’t guide them through every step of a software development project, you need developers with decision-making capabilities.
  • While developers don’t need to be computer-science experts, they do need to have solid concepts of computer science fundamentals.
  • You need developers that are proficient with popular programming languages, however, your project requirements will determine the choice of language. E.g., you need Node.js programmers for web development, Kotlin/Java developers for native Android development, Swift programmers for native iOS development, etc. If your project involves AI/ML, then you should hire programmers with Python skills, whereas you need Ethereum or Hyperledger Fabric development skills in a blockchain project.
  • Competent developers should know popular SDLC models like Agile and Waterfall well. I have explained the importance of this in our guide “How to find a good software developer”.
  • You need developers that know how to mitigate key application security risks.
  • Good software developers should have enough knowledge of popular architecture patterns like the microservices pattern.
  • Scalability of your app is important, therefore, you should hire programmers that know how to code scalable apps.
  • Programmers that you hire should have sufficient familiarity with managed cloud services platforms e.g., Platform-as-a-Service (PaaS) platforms, Mobile-Backend-as-a-Service (MBaaS) platforms, and Blockchain-as-a-Service (BaaS) platforms.
  • You need developers with good knowledge of development tools and frameworks.
  • Industry knowledge is often important, especially in heavily regulated industries like healthcare. You should look for such knowledge in the developers you hire.
  • You need programmers that can work cohesively with your larger team, therefore, the ability to collaborate is important.

It’s not easy to find such developers, however, we at DevTeam.Space have the experience to help you with this. Read our guide “7 essential tips for hiring the best developers for your project” for more insights.

2. Invoking the “exit” clause in the contract with the ineffective developers

exiting a contract

After identifying new developers, it’s time to invoke the “exit” clause in the contract in regards to the under-performing programmers. Your contract with them will vary depending on whether you hired freelancers or developers from a software development company.

However, you need to ensure the following when you invoke the “exit” clause:

  • The outgoing developers should document their work.
  • They should provide sufficient information about any open-source tools that they were using.
  • You need the outgoing developers to provide the relevant details about the source-code repositories.
  • They should also allocate sufficient time for the transition to the new developers.

You can read more about this in “So, you need to exit your incumbent supplier?”.

3. Take control of any open-source tools used by the earlier developers

Open-source tools are very popular, therefore, many developers love to use them. Software development projects have benefited significantly from open-source software, which you can read about in “Creating better technology with open source”.

Programmers commonly use their favorite open-source tools and frameworks in the projects they work on. You might have a situation where your earlier developers might have used such tools in your project.

This requires careful consideration on your part, and you should have detailed discussions with the earlier developers about this. Account for every open-source tool they have brought in your project.

There could be complex licensing requirements depending on how you use an open-source tool. These complexities could be higher in regards to an enterprise-level product.

You need to take all the appropriate actions so that you don’t face legal challenges with your project. Read “Open source software licenses explained” to learn more about this.

4. Transition-in the source code

Your new developers need to have clarity over the source code, therefore, you now need to transition-in the source code from the outgoing developers. You should involve the new developers in this process as much as you can.

Ensure that you note down the source code repositories, latest versions, change history, etc. so that the new developers don’t need to depend on the outgoing developers later. Read more about this in “A guide to switching development teams in the midst of a project”.

5. Ensure sufficient documentation for the new developers to get started

As you are transitioning the work from under-performing developers to new developers, you need to ensure that the new developers have access to sufficient documentation. There are two aspects to it, which are as follows:

  • The documentation should help the new developers to understand the project, and you should be able to help here. Your PM or IT architect should already have documentation covering requirements, architecture, design, test plan, test cases, etc.
  • Now, you also need documentation regarding the specific work that the under-performing developers undertook. This documentation should cover the modules they coded, unit test plans, bugs detected, etc.

Now, it’s likely that the under-performing developers didn’t document their work sufficiently. In such cases, you need to work with them to create the necessary documentation.

I recommend that you involve the new developers in this documentation step. DevTeam.Space developers consistently document their work, and we ensure high-quality documentation. Read “Software documentation: 6 best practices that work” to judge our documentation capabilities.

6. Assess the impact of below-par performers

assess developer

While you have seen the adverse impacts to the project caused by the below-par performance of the original freelancers, you would do well to conduct a detailed assessment. You should include the new developers in this exercise, moreover, you should cover the following aspects:

  • Did the earlier developers code according to the requirements and technical design?
  • Are the modules coded by them align with the architectural pattern chosen in this project, or are they misaligned?
  • Did the under-performing developers mitigate the key application security risks?
  • Does the code written by the earlier developers introduce new security risks?
  • What was the outcome of the formal review sessions, e.g., what were the defects identified by the code reviewers?
  • Did the earlier developers use the right frameworks, coding guidelines?
  • What issues did your testers identify with the code written by the earlier developers, moreover, what is the status of these issues?

This assessment can be complex, however, we at DevTeam.Space have the right expertise for this. You can judge our expertise in “How to change your software development company mid-project”.

7. Transition the relevant sub-projects to the new developers

You have just assessed the impact of the below-par developers on your project, and with this, you have sufficient information to transition the impacted sub-projects to the new developers. This exercise involves the following:

  • You need to provide all the relevant documents to the new developers.
  • The information about source code repositories, versions, and changes are important for the new developers, therefore, you need to provide them with that.
  • Provide them with all the review reports, bug reports, and status of action items concerning the impacted modules/sub-projects.
  • Have the necessary discussion with the new developers and ensure that they have everything they need to do a good job.
  • The new developers will need the authentication information to use your development tools/environments, and you need to provide them with that.

You can learn more about this transition in “Best practices: Vendor to vendor transition of IT services”.

8. Integrate the new developers in your team

I assume that you have hired highly competent new developers to replace the under-performing developers. You still need to make the new developers productive, and the best way to do that is to integrate them into your team.

You should consider using the “Scrum” technique to manage your Agile projects since Scrum works well for such projects. With this technique, you can build high-performing teams that focus on delivering business value through collaboration.

“Scrum teams” are cross-functional teams where developers and testers work together. A “Scrum master” leads a scrum team. Since scrum teams don’t work in silos, they facilitate collaboration, as I’ve explained in “How to build a Scrum development team?”. Developers at DevTeam.Space are highly familiar with scrum.

Scrum teams work based on requirements given to them by a “Product Owner”. Such teams are empowered, and they plan “Sprints”, i.e., iterations in “Sprint planning meetings”.

Scrum teams use processes and documentation, however, their focus is on delivering business value to customers. Therefore, they don’t create unnecessary documentation, rather, they stress on working together to deliver incremental value.

9. Facilitate collaboration between the new developers, testers, and DevOps engineers

Given that you were already executing a project and you just needed to replace one or more under-performing developers, I assume you already have robust testing and DevOps processes. Well, even the best processes will work only when people use them intelligently. When you hire new developers, you need to enable them to collaborate with your testing and DevOps teams.

You probably had worked hard to establish a “Continuous Integration” (CI)/”Continuous Delivery” (CD) environment. Collaboration between the scrum master, developers, testers, and DevOps engineers is the key to establishing a robust CI/CD environment.

Read more about this in “5 common pitfalls of CI/CD—and how to avoid them”. If your new developers don’t collaborate, then you will find it hard to maintain an effective CI/CD environment.

At DevTeam.Space, we have developers who demonstrate a high degree of technical skills as well as the competency to collaborate. You only need to enable them to collaborate by integrating them in your team.

10. Ensure that the code review process covers the work by the new developers

Assuming you have onboarded high-quality developers to replace the under-performers, you can expect to get quality code. However, you need to ensure that your code reviewers review their code thoroughly. This has many benefits, e.g.:

  • You identify bugs earlier and achieve consistency in your project delivery.
  • Expect less coding errors over time when you consistently review code, moreover, you can expect that the code in your project proactively mitigates application security risks.
  • Since code reviews show up bugs earlier in the cycle, you can experience an overall improvement in your development schedule and efficiency.

Read more about these benefits in “Build your own code review solution for your future projects”.

At DevTeam.Space, our developers are well familiar with code review processes. Our development teams are also well-versed with code review checklists, and you can judge our capabilities by reading “Code review checklist: Stop producing bugs now!”.

Managing your project after replacing developers mid-project

You have now replaced your under-performing developers with competent ones, subsequently, you have also transitioned your project to the new developers. The success of your project now depends on effectively managing the process at every step.

You should use advanced project management processes, methods, and tools (PM&T) for this. However, the new developers need to be central in this process.  This requires them to have a working knowledge of such PM&T. Given the AI-powered Agile processes used by DevTeam.Space, if you still require experienced help then our developers are best-suited to help you!

DevTeam.Space is a vetted community of expert dev teams supported by an AI-powered agile process.

Companies like Samsung, Airbus, NEC, and startups rely on us to build great online products. We can help you too, by helping you to hire and effortlessly manage expert developers.

LinkedIn Facebook Twitter Facebook Messenger Whatsapp Skype Telegram