You raise your eyebrow and look at them hesitantly.
“Hey, any news on that newest debugging issue we’ve had with the Georgian client?”, you ask, brazenly enough for James to smirk in return, but not loudly enough to warrant any suspicion on your end.
James stops a full meter apart.
“I think I deserve a raise”.
As your mind races through all the possibilities, you try not to give away your surprise and say something that you’d regret later.
What happens now?
When your developers ask for a raise, it can become a challenging issue for any tech manager. Your response can have an undeniable impact on company morale, staff retention, and the budget as a whole.
Impulsively blurting out “NO” will most likely not end well. Postponing their concern isn’t a viable option, and retorting with a blatant cliffhanger (“We’ll talk again in six months”) isn’t too good either.
Below we’ll look at some tactics on how to respond to this request without offending neither the developer nor the company owner – all while keeping the budget in a healthy state.
It isn’t always about the money
The easiest thing in the world would be to give them a salary increase, plain and simple. They’ll be delighted, you will escape the pressure and the company will thrive.
Only, it’s not that simple.
Money doesn’t always necessarily buy happiness (although, it buys financial security and ease of mind). But, even if you did provide your developer with a pay raise, it’s very unlikely that it’ll make them truly happy moving forward.
A study examining this topic sheds light on something quite surprising.
Namely, a person’s wellbeing rises proportionally with their income, however, the progress stops when they reach an annual income of $75,000. This means that those who were happy with a little, to begin with, will be happy even when they earn more, and those who didn’t start off too thrilled, won’t automatically be happier just because of a raise.
The number may be different depending on the buying power in relation to the place of residence, but the point remains the same. Once you reach a certain financial threshold, your basic needs are fulfilled and your happiness starts to stagnate.
In other words, happiness isn’t necessarily tied to a higher salary once these prerequisites are met.
So, if it’s not about the money, then why is your developer engaging in a salary negotiation in the first place?
That’s what you need to find out.
When you identify the root cause and then treat it accordingly, good things will start to happen:
- Your developers will become happier
- Their request for a raise will either be withdrawn or postponed for a better time
- They will stay at your company and won’t look for other jobs
Here’s how to proceed.
Find an answer to what’s bothering your developer
Go back to the time when you were in their shoes. When you were either asking for a raise or went to start at another company that, most likely, included a pay raise.
There’s a great chance that you felt like you were underappreciated and underpaid.
Those feelings aren’t rare or uncommon. But here’s what’s interesting: a recent survey found that 65% of employees would prefer a new manager over a pay raise.
This is why, when a developer from your team asks to renegotiate their salary, it probably has a great deal to do with the manager or the person who directly oversees their work.
It could be something that you failed to do or something that you overdid.
The best advice on how to deal with this is to schedule a 1-on-1 and have an honest conversation with your software developer.
If you’re unsure about how to start, here’s a list of questions that you could use:
- What’s your favorite part about working here?
- What’s your LEAST favorite part about working here?
- Do you feel like you’re working more, less, or just the right amount of hours?
- Do you find yourself aligned with the company culture?
- Is there anything that you’d like my help with?
Asking is one thing, but be careful to listen to their answers as well. Follow up with more questions to further clear things up. Only when you can say that you’ve actively listened to them, then you’re ready to start tackling the issues at hand.
Use a performance evaluation
Annual performance evaluations are necessary to push your developers to grow, even if they don’t ask for a raise. They encourage good devs to keep pushing their boundaries and become better in every aspect of their work, and they also sort out the bad apples in a case when termination is looming around the corner.
In fact, having elite developers is worth more than our intuition is capable of assuming — this includes experienced managers as well.
Replacing high performers can become a lot more expensive than simply offering them a bonus or a raise. Make sure your best devs are always paid proportionally to the amount of their creative output at all times.
Most managers would argue that objectively doing a performance evaluation is an impossible task. However, you can always use the help of several performance heuristics to give you a general idea of where the developer stands skill and productivity-wise.
They are an elite developer, a unique problem-solver, and a master coder - they deserve the highest possible raise;
They are a very good developer, solid problem-solver, and a productive coder - you should offer them a medium raise and encourage them to keep working on their skills;
They are struggling with some projects and their code is not up to par - you should offer to help them out in learning and improving, and encourage them to keep trying;
They are not performing well for at least few months in a row - perhaps you should consider terminating their contract and looking for another replacement for the job. Ultimately, and eventually, you'll decide when and how to announce possibilities for a raise in the future.
The performance evaluation can be done in conjunction with a personality test and a detailed input from their coworkers and managers likewise.
This would give you a clearer picture of how to proceed when a developer approaches asking for a raise.
Rethink their roles and responsibilities at the company
There is a point in every developer’s professional journey where the years of experience take their toll. Namely, work no longer represents a challenge, and instead, it starts to feel like a chore.
When you’re getting bored out of your mind at work, those negative emotions start spilling out outside work and start pestering you more. Achieving mastery at your tech stack, especially true for software engineering and development, could also warrant a proportional response directed at the top brass.
Asking for a raise.
As someone who manages the person who requests a pay raise, discussing their accountability, growth, and responsibility is an excellent non-financial way to tackle the problem.
An interesting study has backed this exact same notion: the No.1 thing employees are mostly gunning for is achieving growth and happiness, sometimes even more popular than cash.
For software developers (working in a variety of tech companies) in particular, however, the most prominent thing that makes them happy is a competitive salary, closely followed by a healthy work-life balance, and a strong sense of productivity and flexibility at work, among other things.
Together, these two studies paint a somewhat clearer picture on what software developers expect from their workplace.
In a situation like this, bringing new responsibilities to the table could stir the pot just enough to shift the focus from thinking about a raise to working on new challenges. For example:
Adding more resources on projects that were previously lacking resources
Examining the salary range and making a stronger case for a pay raise at the project's end
Freeing up their time to learn a new framework, get a new certificate or explore their pet project more in-depth
One of the underlying reasons why most managers don’t promote their best talent is because of the reasoning that “you simply can’t promote everyone”.
Sometimes, it’s not so easy to dish out promotions because of multiple factors, including how the hierarchy of the company is set up, a mediocre performance review, or simply the nature of the developer’s role in the company.
For example, they could be leading an important web project that requires all their attention and focus. They could also manage a couple of junior developers and ensure a smooth workflow thanks to their unique skill set and years of experience in, let’s say, backend development.
If you promote this person to a senior role, their attention would suddenly shift away from the project and everyone will take on more responsibility in order to get the project done.
Instead, there are other ways to grow your developers' roles without a promotion. These include:
Pair them up with a mentor (or two) with more experience in their particular tech stack
Enroll them in a course to learn new technologies, not necessarily tied to their old proficiency
Push them to become more assertive and grow into a leader
It’s also important to assess what the developer brings to the table as well. Are they winging it to try out their luck, or coming prepared with spreadsheets, plans and past achievements to show for their dedication and willingness to grow?
Treat their approach accordingly and show them alternative ways to grow besides getting the obvious increase in salary.
Reassess your company culture
Being fully transparent about both the bad and good times in your company can go a long way in justifying whatever decision you are ready to make.
If your company struggles in any capacity, and you’re being honest and upfront about it, those developers looking for more money will change their perspective and will try to look at things from your point of view.
Similarly, if you’re between rounds of funding, you can postpone the salary talk (this time, rightly so) until after series A of funding.
On the other hand, if your company is lavishly enjoying broccoli chips, gluten-free snacks (not that that’s anything wrong with these, but they’re still considered an office luxury), or an endless supply of coconut water, then it’s going to be a heck of a lot tougher to escape salary renegotiation.
At the end, it boils down to the following: if your company is spending money where it shouldn’t be, this assumption will extend to developer paychecks. It will be hard to say no or offer alternative growth measures if you’re not practicing peak frugality, or, at least, economic responsibility.
If your company ends up in a similar situation like this, there are only three viable options:
Actually offer your developers a raise to remain consistent with your company’s ways
Deny the increase, and immediately cut costs where applicable
Deny the increase, and get ready for your developers to interview elsewhere and get new job offers at a competitive market rate
When your developers ask for a raise, it can feel like a tough spot to be in. But, with good situational awareness and the right approach to the situation, you can always turn a potential turnover into a loyal and happier developer.