We need to build ABC, so that our client can do 123. Developers nod their head in confirmation that they understand what needs to be done. Been there before?
What usually follows is the lack of shared understanding between the team members, this means that everyone has their own idea of what ABC is and how it should get implemented. So being that the awesome development team understands what needs to be done, they go straight to implementation and after that all they’ll need to do is test the product and deliver to the client. Saving time right?
Well, as you may have guessed given the title of this post what would follow in such a scenario is chaos, pure chaos, especially with non-trivial products being handled by a team of developers! Since everyone on the team understands it as he or she thinks it should be, they will all build what they think it should be, and the moment you start integrating what each person has done that’s when you begin to notice that everyone wasn’t thinking about the same thing.
Usually this is resolved by the developers deciding on changes they need to make in order for them to get their code integrated, only to find out that they face the same issue when they need to integrate with some other parts of the code built by another awesome developer. And so the cycle continues… and valuable time is wasted…
The solution to this is to have some design before any implementation is done. Design here is a communication tool to help the team achieve the much desired shared understanding so it covers things like architectural design, user interface design, user experience design and so on. The reason you need this is:
- Things that are harder to change are decided upon.
- Team members get to contribute and therefore the quality of the design is improved. It is important to get team members to contribute rather than wait till when they commence implementation. It is worthy to note, some things don’t show up until you start implementing but is wiser to reduce the amount of design decisions you make during implementation by doing some design in the first place.
- The all important shared understanding becomes easier to achieve.
Decide early on things that have multiple ways of implementation but rarely change once decided upon. Design is about making the important decisions and achieving a shared understanding in a team.
Decisions cost time. Time is an important resource. It usually determines if you will get a happy client or not and in some cases whether you get paid or not.
A lot of teams tend to make design decisions during implementation and this costs a lot of time. The main reason this is bad is, you may not be looking at the implication the design decisions on some other important parts of the code.
On the flip side, a good design should design for volatility and change, some things are harder to change but good design aims to make such changes easier to do.
In summary, changing the important stuff in a software product costs time, the happiness of clients and ultimately revenue. This can be avoided by doing some designs, reviewing with your team and getting their input. The goal is not to come up with a perfect design but to have a process in place whereby you minimize the impact of poor design decisions being made during implementation.