Being a good software developer (especially a senior or a team leader) is not just about writing amazing code and solving difficult problems. These things are certainly important, but building and managing a good relationship with clients might be even more crucial. I’ve talked to the team at Netguru and prepared a list of skills and qualities you might need to forge successful relationships with clients, as well as a list of warnings signs that will help you identify possible problems with the approach you or someone else has been taking.
Skills to learn
Your skill set is the cornerstone of your career as a developer. Aside from the obvious, like knowing your technology and the principles of developing good code, you need some soft skills that’ll build your image as a true professional.
- Know the limitations of your technology, and don’t be afraid to let clients know about them. If the technology doesn’t fit the client’s expectations, then clearly you shouldn’t be using it for the project.
- Learn to deal with legacy code and bad code - in a way that doesn’t involve too much complaining. Grit your teeth and power through. Clients will appreciate your professionalism.
- You need the ability to write consistent code through the whole application - to set up and keep up the project’s coding conventions. You’re probably not the only person who’s ever going to work on the project, so try to make life easier for these potential successors.
- Learn to estimate well. If you have no clue how long a task might take, don’t beat around the bush and just tell the client. Transparency is important.
- It’s important to cooperate with your whole team (including backend developers, mobile developers and designers) - and to do it well, you need some cross-platform knowledge.
- Learn UX/UI design skills (or something else, like material design - whatever interests you most). If nothing else, this will let you join the conversation about design as an equal and help the client make the best decisions.
- Know how to easily transition from one technology to another. You don’t want to seem reluctant or unsure when a technology change is in order.
- Be ready to share your knowledge with the clients. This could be your ideas for technical solutions, awareness of the different devices on the market, or the most common architectures. You are the expert, after all.
- On that topic, you need to be a bit of a public speaker. You’ll mostly be exercising this skill in meetings, and sometimes during conferences, but you need to be confident enough to present your ideas in a way that the client will understand and trust.
- Be a team player. Understand what major stakeholders in your project worry about and work towards, and be there for your team. Stay up to date with what everyone else is doing so you can be ready to jump in and help when necessary.
- A good variety of experience is helpful to have. It’ll be easier to explain concepts to a client if you can use concrete examples, and the client will have an easier time trusting you if it’s obvious you know what you’re doing.
- Build your knowledge of tools for solving common problems. Ideally, try some of them out. You’ll be able to use the same ideas to customise your solutions and easily provide working examples to the team and the client.
- Actively work on maintaining good communication with the client. Repeat what you hear during a meeting to make sure you understood correctly. Don’t rely on assumptions. Be honest about your mistakes and give genuine feedback. You want the client to treat you as a person, not just a nameless developer working on their project.
- Have a note taking system and general organisation skills. You want to make the client feel like you’re just as engaged in their project as they are, and this can be done simply by not forgetting important information and acting on it.
- Know how to find information quickly. Google-fu is an important skill. It’ll help you give good arguments during discussions and make better decisions.
- Learn to anticipate: UI/UX weaknesses, issues on different devices, connections between systems, etc. Your job isn’t only to solve problems, but also to avoid them whenever possible.
Qualities to develop
No one wants you to try to drastically change who you are, but there are some qualities common to successful software developers. You don’t need to work on all of them - just treat them as useful suggestions.
- Good developers tend to be calm and organized. They can keep their cool in a crisis and don’t make emotional decisions even in difficult situations.
- You should be a problem-solver, trying to find new solutions, not complaining about things that aren’t working.
- Have some curiosity for learning the business domain of the project. It’s an amazing opportunity for you to expand your horizons, and your voice will be much more valuable during team discussions.
- Be open to suggestions and looking for help or opening a discussion about a difficult issue. You don’t need to be omniscient. It’s okay if you don’t immediately know the solution to every problem. As long as you’re honest about it and willing to learn, nobody will fault you for it.
- Always be ready to help the people on your team.
- Never tire of learning new things - the tech industry is constantly in flux and you don’t want to get left behind.
- Be patient - with your work, your team and your client. Don’t let frustration build up, or you might end up taking it out on the people around you.
- Respect other people’s views, even if you disagree with them. This may seem obvious, but not everyone realises how destructive it is to a professional relationship to dismiss someone else’s ideas and push your own opinions onto them.
- Be accountable. Make sure the people around you trust you and your word. If people on your team or the client doubt the things you say, you know you’re in trouble.
- Be passionate about your work. You won’t burn out as easily, and you’re very likely to infect people with your enthusiasm.
- You should be creative as a developer. You do creative work, after all: building new solutions and improving old ones. You don’t have to think of yourself as an artist, but remember that you don’t always have to use tried and true solutions and just try something new.
- Being detail-oriented is a big advantage - it’ll keep you from cutting corners. At the same time, remember to keep an open-minded attitude - sometimes corners have to be cut, because it’s better for the client.
- Know your limits, but be confident. Be certain that you’re producing quality code. If you aren’t sure of this, then something is clearly wrong.
Learning new skills and developing useful qualities puts you on the right path, but sometimes you’re in danger of sabotaging your success through certain behaviours. They might cause your teammates or clients to doubt your abilities and as a result, the quality of your cooperation will suffer. Watch out for those, or even small hints of those - it might be better to be safe than sorry. Here are some signs of a developer that’s not fun to work with.
- They think that they are always right and get offended when someone offers constructive criticism.
- They don’t put effort into cooperating with the team and the client.
- Talking too much is also a sign. A developer that tries to show off and look as wise as possible by diving into technicalities actually often ends up making the opposite impression: of someone trying to cover their lack of knowledge.
- They are uncomfortable using new solutions and technologies. A lack of knowledge about new OS version updates and being generally unaware of new developments in your field could also paint you in the wrong light.
- A bad developer does not want to learn, does not like to share knowledge, and is impatient with others. This is a sign of pure egoism, clearly destructive for any career.
- Weak developers follow instructions to the letter, and end up delivering poor quality because they don’t take a proactive approach and ignore potential problems. Not caring about details like proper error handling is a sign of this.
- Balancing responsibility is also important. Taking too much responsibility might be just as bad as not taking enough. Especially if you’re only eager to get the credit for your successes and avoid the consequences of your mistakes.
- A developer who doesn’t ask questions when they are stuck is bound to get into trouble. As previously established, it’s okay to admit that you don’t know everything.
- The inability to calmly and objectively discuss their work is a clear sign of an uncooperative developer. Taking everything personally is bad for the team and for your blood pressure.
- It’s easy to get excited about new tools, but using them just because they are cool and have been featured on a blog you follow is a bad idea. Only do what’s best for the project.
- Attempts to reinvent the wheel are another obvious sign of a misguided developer. A developer’s job isn’t to write a lot of code - it’s to solve problems as efficiently and elegantly as possible.
Hopefully this article will help you choose the next area to work on as your develop your career, and to stay away from toxic behaviours that can turn the client and your team against you.