Great relationships are at the centre of any good business. It is a prerogative of any business, big or small, and regardless of nature of business, to cultivate the kind of relationships that let it thrive. And so it is with the developers, to seek such kind of relationships with their clients.
Creative works require close collaboration between the creative and the customer. After all, the creative is in the business of turning the client’s dreams and expectations into reality. The developer has the tough job of bringing the client’s vision to life.
Moving from idea to realised concept involves the transferring of ideas between the developer and the client. Unless this transference of ideas is perfect, the process of converting the client’s idea into reality is compromised. It is therefore in the best interest of the developer to cultivate great relationships that facilitate this process.
Below are some of my ideas and beliefs that revolve around the developer-client relationship, which when practised by the developer, will result in great business relationships.
You might be a developer or you might be a client looking for a developer, you might even be in any other business, and still, these principles will help you develop the right, mutually respecting and beneficial relationships in your future projects.
Integrity speaks to what you are, as a business: what you stand for. It is necessary for a developer to have a high level of integrity, if they are to maintain strong customer relationships. Integrity is about adhering to a strict moral or ethical code. It also means keeping your word.
This might mean not taking some types of jobs, that are in conflict with the business’ beliefs and values. Such kind of jobs might range from things such as building a porn website, because they have the potential to expose minors to inappropriate images, or billing customers at exorbitant rates than you believe the work is worth.
Acting with integrity goes beyond putting a values or mission statement on a website for clients to read. It is actually living those values.
I personally do not get motivated by money on a job. Don’t get me wrong, more money is great, but I don’t believe it should be the source of motivation when working on a project. In order to build better relationships with clients, a developer should treat all projects with a high level of enthusiasm and commitment, regardless of the price tag.
This means that a developer should be able to commit strongly to delivering a quality product, despite any price differences across projects. This therefore means diligently working on a project, whether or not it pays significantly more, or less than another project.
Supposing a developer does a project for free, or completes a heavily discounted project for charity, they should apply themselves with the same level of creativity, and deliver on all aspects as if it was their highest paying project.
Acting with integrity is rooted in principles beyond mere monetary value. It is also in the developer’s best interest to behave this way. They say karma’s a bitch and what goes around comes around.
If a developer conducts themselves only in proportion to the return on a project, their level of work will show this, and it will have a negative impact on their portfolio and future returns.
It is often tempting as a developer to promise the world to a client. Sometimes customers will have lofty ideas about what they want done. In their quest to get the contract, developers may just nod yes to everything that the client requests, when they cannot deliver.
Acting this way is not good for the developer-client relationship, and does nothing but set up the developer for an eventual fall. When a client asks for over the top designs and features, it is better for the developer to act on the side of caution.
It is better to under-promise and over-deliver. This approach takes in the client’s requests and cautiously points out the areas that are possible, and those not easy, or even impossible to implement, but makes the client aware that some of the asks, are a long shot, and may not be possible to execute, or at least not the way the client desires.
The developer would then go on to make a conscious determined effort, to deliver on all the requirements, including the possibly unlikely outcomes. This approach is a great reputation builder. If the developer does not deliver as desired, then the client is prepared for the outcome, but if they do deliver, or better yet, deliver beyond expectation, they earn major points with the client and improve their reputation.
It is imperative that a developer is a good listener. There is often a wide knowledge gap in the area of software development, between the developer and the client. Due to this gap the developer may be inclined to monopolise the conversation with the client.
Every aspect of a project poses this possibility. It is very important for the developer to be conscious of this factor, because after all, it is the client’s concept and the developer is merely tasked with realising it.
Open communication is critical for the developer-client relationship. The developer should see the interaction as an opportunity, to share knowledge, and the sharing should go both ways. A little more listening than talking on the part of the developer, should be on the cards.
Sometimes the communication process does not go smoothly, and the developer will find themselves holding a “hot potato”. This can happen when the project deliverable is unacceptable in the eyes of the client because, according to them, it is way below what was required or expected. In such cases, arguing with the client will only make the situation worse.
In most cases, the only option with a positive outcome, is for the developer to eat humble pie, and go back to the drawing board and redo some, and at times, all of the project. Understandably this move represents a perceived waste of time and other resources, but fighting with customers over the outcome of a development job is likely to spell further disaster.
In the event of this happening, it is best to look at the situation as a learning experience, correct the mistakes if possible, and move on.
Finally, I hear the statement, “The customer is always right”, being thrown around quite a lot. I strongly disagree with this statement, especially in the arena of software development. The phrase is misleading, factually incorrect, and can lead to poor development work being let out into the wild.
I rather contend that “The customer is not always right, but you should make them feel like they are at all times”. Altering this saying, makes the developer conscious of the fact that, they are in a position to call a spade a spade, when a customer is wrong, but have to approach the situation delicately. Taking this approach is one of the first steps in the direction of building good developer-client relationships.
Want to hear some more from the Webmobyle Blog? Please