Whether you are an experienced developer or are just starting in the exciting world of software development, you should spend some time assessing how much your skills are worth.
This is particularly important if you are working as a freelancer because employers are always looking to hire the cheapest app developers. To make matters worse, software development can be such a lonely profession that devs generally get little chance to compare their pay rates with colleagues, and the rise of remote working makes this even more difficult.
There are several key considerations when it comes to identifying your price point. First, you should consider how you are being paid – whether by the hour, by the project, or by salary – and how you want to be paid.
Then you should compare your skills with your peers, and the skills that are in demand among leaders in technical fields.
Finally, you should carefully consider the tax implications of your pay.
In this article, we’ll look at all these considerations, and help software developers to find the right price point for your skills. Then we’ll show you how to increase how much you are paid.
The Raw Numbers
The most basic information you need to calculate your pay is the average across the industry. Unfortunately, it’s not as simple as this. Freelancers are paid vastly different rates depending on their level of experience, where they live, and what kind of project they are working on. Add to this the fact that many devs are paid hourly, rather than on an annual salary, and like-for-like comparison across the industry gets even more complicated.
For the sake of argument, however, let’s look at some of the data on the average annual salary for developers. Data from PayScale indicates that there is a large range of annual salaries for software developers with 5 years of experience, ranging from approximately $80,000 a year to more than $150,000. The median figure is $112,921.
When it comes to freelancers, there is even more variation. The cost of hiring freelancers in North America goes from $50 to $250, but the range is significantly lower in Eastern Europe and India.
This makes calculating the annual salary of freelancers quite complex if looked at on a global scale. For the sake of brevity, then, let’s look at the average freelance rates for developers in the US. Running an analysis on CodementorX shows that most US freelancers charge somewhere between $60-$100 per hour.
How does that compare to developers who are on a salary? According to the Organization for Economic Co-operation and Development (OECD), the average annual hours worked in the US per worker is 1790. Multiplying this number by the average hourly rate gives us a range of $107,400 – $179,000. That means that freelancers – if they are working as much as salaried employees – earn significantly more than permanent staff.
Looking at these raw numbers, however, doesn’t give a full picture of the complexity of how – and how much – developers are paid. So let’s look at some extra factors.
How Will You Be Paid?
The next element to consider when setting your price point is how you will be paid. For developers, this generally means one of three things: a retainer, an hourly rate, or being paid per project.
Of these, being paid by the project is the most difficult to assess, so we’ll start with this. The problem with being paid by the project, for a lot of developers, is that employers generally have little knowledge about the actual scope of the project they are asking you to work on: that’s why they are hiring a dev in the first place.
This means that it is critical that you carefully assess the scope of a proposed job, and sketch out any issues that are likely to arise, long before agreeing on an hourly rate.
Some inexperienced developers can be hesitant to do this because they feel that questioning a project spec is going to lose them a lucrative job. In reality, any good employer will be impressed by the preparation you’ve put into checking the project scope and see you as more professional than someone who blindly accepted it.
Being paid by the hour also presents difficulties, for many of the same reasons. If a project grows beyond the original design specifications, or if your employer is suddenly faced with a crisis, your hours can increase dramatically and at short notice.
Whether that is a problem will depend on you, but if you are being paid by the hour it is worth investing in accountancy software to keep track of this. Otherwise, you may find that your employer is tracking your hours differently, or you might end up with an unexpectedly large tax bill (more on this later).
A retainer is the least complicated way to be paid as a developer, and if you work quickly, it can be a great option. If you charge an average rate and provide quality work at a faster pace, you could enjoy the benefits of long term project stability with a (maybe) higher than average rate.
Compare Your Skills
The next step in calculating an appropriate rate as a developer is to compare your skills with those of your colleagues, and with the skills that employers are looking for.
Doing a basic version of this process is pretty easy. There are plenty of free tools like this freelance rate explorer that will allow you to compare the hourly rates of over 9,000 developers across different tech stacks, regions, and experience levels. This is a great starting point, but you should also note that in-demand skills can change very rapidly, and the price of developing for emerging technologies – like the IoT – is often not well reflected in these calculators.
Equally important, thanks to the rise of the SaaS business model (which relies on hosting products in the cloud accessed by a web browser rather than massive infrastructures), employers are increasingly valuing developers who can swap between many different systems seamlessly and can coordinate with other developers who work for third-party vendors.
There are a few other sets of skills that are in particular demand at the moment (early 2020), and if you have expertise in them it can boost your ratings.
Many device manufacturers are rushing to develop software that can keep up with 5G, and the skills necessary to work with telecom networks are in high demand. Training in the legal and ethical principles of data retention has become a valuable feature for many employers as well. Developers with in-depth knowledge of web application security are also in high demand since over two-thirds of all web apps have high-security vulnerabilities.
Finally, when it comes to calculating your rate you should also recognize that where you are based makes a huge difference. Note that this means you should move somewhere just to get a higher rate – pay rates generally reflect the cost of living in each country – but don’t feel it is unfair if you get a lower rate just because you are not in the USA.
Sadly, this is just how things are working at the moment: experienced U.S. developers have an asking price at about $60-$100+ per hour at a minimum, while non-U.S. developers, depending on where they’re from, set their hourly rates to about $40-60.
Taxes and Jurisdictions
The final part of your assessment as software developers should be the tax you are going to pay on your earnings. How much tax you pay will depend on where you live, of course, but plenty of devs forget to factor this into their hourly quotes until it comes to tax day.
Ideally, you should build a business plan each year, which details how much you expect to earn and the amount of tax you will pay on this. You can then adjust your quotes for projects to take into account the tax you will pay on these earnings.
If you are in the US, it’s worth recognizing that many of the expenses you incur as a freelance software developer – in particular, equipment and any travel you have to do as part of your job – can be written off as a business expense. This can dramatically lower the amount of tax you pay on your earnings, which in turn can lower your quoted rate, which in turn can make you a more competitive prospect when you are bidding for work.
If you’re outside the US, you should also be careful when it comes to working out your taxes as software developers. The IRS is notoriously keen when it comes to taxing citizens working with US dollars, and the majority of developers around the world are paid in this currency.
Increasing Your Rates
Finally, let’s look at some key strategies for increasing your pay rate as software developers. There are some basic, and fairly obvious, ways to do that. One is to increase your experience and to provide clients with an impressive portfolio of jobs you have completed. Both of these can help you in negotiating a better rate for your time. Also, however, there are two further strategies you can use to increase your rate of pay.
The first is to be adaptive to what employers want right now. Often, a quick scan of the mainstream tech press is enough to ascertain what the buzzwords of the moment are. In 2020, three types of skills are in particular demand: working with cryptocurrency systems, the ability to code for IoT devices, and at least a basic grasp of AI systems.
The irony here is that many of the companies who say they want their skills are not working with these technologies. Instead, they put them in their job adverts because they think they will be in the future. As a developer, this means that a little extra reading (or formal training) in these areas can greatly boost your negotiating clout, and ultimately the amount that you charge for your work.
A second way to boost your hourly rate is to stress that, in addition to your technical skills, you are also experienced in working in the business. A recent article on Recruitment Buzz puts this well: “[Businesses] don’t just want good coders. They need good people who can code at the same time as understanding the real-life application of what they are doing. Business-savvy, young, bright developers are very valuable.”
In practice, this means that developers need to start talking the language of business if they are going to go for higher rates of pay. Developers tend to talk about complex issues like scalability, reusability, clarity, calculated risks, and many more. The business primarily speaks in two dialects — time and money.
When negotiating your pay rate as software developers, this is a critical realization. Rather than speaking about the technical difficulties of the task your prospective employer is asking you to do, talk about the time and money that it will require. Instead of pointing out that the code they want you to work with is obscure, talk about how much extra time it will take you to unravel it.
Don’t Give It Away
Ultimately, you should be paid what your skills are worth. However, many developers remain underpaid because they simply don’t realize how valuable their skills are to employers. If you are coding every day, it can be easy to forget just how few people have the skills that you have.
For this reason, you should never work for free as software developers. If you are just starting on a development career, it can be tempting to take unpaid internships, or other unpaid work, to “build up your portfolio”. This, unfortunately, is something of a fool’s errand. Quality employers will never ask you to work for free, and will always pay you properly for your work.
The three elements above should all be involved in setting your quotes to employers as software developers, but you should also not be afraid to vary this as the situation demands. Just make sure that the rest of your finances are as carefully thought through as your development rate, and you’ll be well on your way to becoming the next Bill Gates.