When you listen to a professional or college sports team discuss a bad stretch, they often mention that they will get back to basics. These statements are not a knock on the players. They understand the basics. It is instead a focus on doing the things that have to be done. It is a return to their foundation so they can simplify and then work on building again. This approach happens to work well for software projects as well.
Spinning Out Of Control
The good and bad news is that software projects almost never go just a little off-track. A slight stumble in a project either gets righted quickly or it starts to spiral away. Thus, it tends to be easy to see that a plan is out of control when you look at it on paper. There will be features that are not implemented, slipped dates, and requirements that have been ignored.
Like the coach of a team struggling to succeed, we can simplify without getting bogged down in blame or questioning the skills of the team. This approach is not just saving the feelings of the team members; it also happens to be an excellent way to triage the situation.
Back To Basics = Simplify
I think the best benefit that comes from this approach is that it forces us to simplify and focus. The first step is to look at the requirements and assess where the software is about them. When I say requirements, I am talking about the original, not the ones with a pile of change requests. Those change requests may be vitally important, but let’s ignore them for now.
Once you have the gap analysis complete on the software and the starting requirements, it is time to tackle the scope creep and change requests. As you move through these items, start each one by asking if it is required. Nice-to-have features often show up in early change requests because we have a lower bar of entry. When things are on schedule and expectations are met, we are happy to add a feature or two. That changes once we are behind schedule or on a death march.
The Baby and The Bathwater
There will almost always be changes that can be made to the scope at this point. Things have gone for a reason. There are cases where a technical issue or challenge causes a project to go off the rails. However, I have rarely experienced this. It is far more prevalent to have a project die due to a thousand cuts. There are all sorts of little slips and additions that have led us to this wreck.
That being said, our gap analysis will almost always highlight opportunities for removing features and simplifying the project. When we tackle these, it needs to be with discretion. Some features can be turned off to reduce scope without much effort. However, many will have tentacles reaching into other areas. Thus, unlike a sports team, we may have features that we need to keep due to the complexity. Of course, if we have good adherence to version control best practices, we should not run into this problem. If you just fell on the floor laughing, you are not alone.
It is important to note that this is a perfect example of where good version control practices can help. You can use branches and tags to group and categorize the features as you remove them. This will allow you to attempt merging those features back in for a future release.
The Bottom Line
When you find yourself in the middle a project catastrophe, get back to basics. Focus on the requirements you have to meet and a simplified target. You do not get to cut out some of the basics. Thus, testing, code reviews, comments/documentation, and those other areas of the SDLC we like to skimp on are not valid targets for getting on track. You may do these in a less flowery way and simplify some of those processes, but throwing them out is only going to get you back to this position in the future.
Are you struggling with a project today? Take a shot at going back to basics and see if that doesn’t quickly give you a path to success. This is not a silver bullet. There is still work to be done and corrections to be made. However, this can get you headed to the light at the end of a tunnel instead of the next oncoming train.