Senior devs going solo often underprice by 40% by converting their W2 salary to hourly rates. Here's why that math is broken and how to fix it.
You've just left your job. You were making $150k a year as a senior engineer. The math seems obvious: divide by 2,000 hours (a standard work year), and you get $75 per hour. Maybe bump it to $85 or $100 to account for taxes and benefits. You're now a freelancer, and you've got your rate.
Then three months in, you're exhausted, barely covering your expenses, and wondering why freelancing feels like you took a pay cut.
You didn't take a pay cut. You made a pricing mistake—one so common that it affects nearly every senior developer who goes solo. And it's costing you tens of thousands of dollars a year.
The mistake is simple: converting your W2 salary into an hourly rate by dividing annual pay by hours worked. This approach is broken because it ignores the fundamental difference between being employed and being self-employed. It conflates billable hours with total work hours, ignores the cost of running a business, and undervalues the expertise you've spent years building. The result? You're typically underpricing yourself by 30–50%.
Let's walk through why this happens, what it costs you, and how to actually price your services so you're making what you deserve.
When you were employed, your company paid you $150k. But they weren't paying you for 2,000 hours of billable client work. They were paying you for 2,000 hours of total time at the company—which included meetings, onboarding, training, internal projects, code reviews, and probably a good chunk of time waiting for builds to finish or dealing with organizational overhead.
More importantly, your employer was covering costs you now have to cover yourself:
Let's do the real calculation.
You were making $150k. Your employer's total cost for you was higher—typically 25–35% higher when you factor in payroll taxes, benefits, and overhead. Let's say your fully-loaded cost was $190k.
Now, as a freelancer, you need to replace that $150k in take-home pay plus cover all the costs your employer used to cover. Let's break down what you actually need to earn:
Income needed:
Realistic billable hours:
$207.5k ÷ 1,520 billable hours = $136.50 per hour
But you set your rate at $85–$100 per hour. You're undercharging by 30–40%.
Over a year of full-time work, that's the difference between making $130k and making $207.5k. That's $77,500 you're leaving on the table annually.
This mistake doesn't just cost you money in year one. It compounds over time in several ways.
You attract the wrong clients. When you underprice, you attract price-sensitive clients who shop primarily on hourly rate. These clients tend to be demanding, slow to pay, and quick to nickel-and-dime you on scope. They're also less likely to refer you to other clients, because your low rate signals (to them) that you're junior or desperate. You end up spending more time on client management, dealing with scope creep, and chasing payments—all of which reduces your effective hourly rate even further.
You can't afford to say no. Underpriced freelancers take every project that comes along. You can't afford to be selective. This means you end up working on projects that aren't a good fit, with technologies you don't enjoy, or with clients who drain your energy. Burnout follows quickly.
You don't invest in yourself. When you're barely covering expenses, you can't afford to invest in learning new skills, attending conferences, or building tools that would make you more efficient. This keeps you stuck in a low-price, high-effort trap.
Your rates don't grow. Once you've quoted a client at $85/hour, it's psychologically difficult to raise your rate for future work with that same client. You're anchored to the low number. Even when you do raise rates, you're still starting from an artificially low baseline.
The developers who go solo and actually thrive aren't the ones who underprice aggressively. They're the ones who price correctly from the start, attract better clients, and have the breathing room to do their best work.
There are a few reasons why this mistake is so common among senior developers.
First, you're used to thinking in terms of salary. For years, your compensation was a number on a paystub. You got a 3% raise, or you negotiated a new salary. This anchors your thinking to annual income divided by hours. It's a familiar mental model, and it feels safe.
Second, you're afraid of pricing yourself out. When you go solo, there's real uncertainty. You don't know if clients will hire you. You don't know how long projects will take. There's a temptation to underprice as a way to "get your foot in the door" or to seem more competitive. This is a trap. As research from The Lonely Entrepreneur shows, overcomplicating pricing structures and treating pricing as static are critical mistakes—but so is underpricing out of fear. The reality is that undercutting on price doesn't win you better clients; it wins you clients who will always expect low prices.
Third, you might not be accounting for the real costs of self-employment. If you've never run a business before, it's easy to underestimate the cost of taxes, insurance, equipment, and downtime. You think, "I'll just work more hours," but there's a limit to how many billable hours you can realistically work in a year.
Fourth, there's a psychological discomfort with valuing your own work. When you work for a company, the company sets your salary, and you don't have to think about your own value. When you go solo, you have to name a number. For many developers, this feels uncomfortable or even arrogant. It's easier to default to a "reasonable-sounding" hourly rate than to do the math and ask for what you're actually worth.
These psychological barriers are real, but they're also fixable. The key is understanding that pricing isn't about being greedy—it's about sustainability. If you underprice, you'll burn out, and you'll be forced to go back to employment. That's not a win for anyone.
Most developers who underprice are using what's called "cost-plus" pricing: they calculate their costs (or in this case, their old salary) and add a small markup. This is the most common pricing approach, and it's also the most dangerous for freelancers.
As NetSuite's guide on pricing mistakes explains, failing to segment customers and relying solely on cost-plus approaches leaves significant money on the table. The problem with cost-plus pricing is that it ignores what the client is actually willing to pay based on the value you're delivering.
Consider this scenario: You're hired to build a feature that will increase a client's revenue by $100k per year. Using cost-plus pricing, you might charge $50/hour and spend 200 hours on the project—$10k total. You've made a good margin, and you feel good about it.
But from the client's perspective, they're getting $100k in value for $10k. They're thrilled. And you've massively underpriced.
Value-based pricing flips the model. Instead of calculating your cost and adding a markup, you estimate the value the client will get from your work and price accordingly. In the scenario above, you might charge $25k or $30k for the same work, because that's a fraction of the value you're creating.
Value-based pricing is harder than cost-plus pricing because it requires you to understand your client's business and the impact of your work. But it's also much more profitable, and it attracts better clients—clients who care about outcomes, not just hourly rates.
For solo developers, the sweet spot is often a hybrid: use cost-based pricing as a floor (you need to cover your expenses), but use value-based pricing as a ceiling (you shouldn't leave money on the table). This is where The Dumb Pricing Mistake People Make becomes relevant—understanding the cost-stacking approach and value margin testing methodology helps you determine optimal pricing without leaving revenue on the table.
One of the biggest mistakes senior developers make is sticking with hourly rates. Hourly rates are easy to quote, but they're also the most vulnerable to the underpricing trap.
When you charge by the hour, you're incentivized to work slowly (more hours = more money) and the client is incentivized to rush you (fewer hours = less money). This misalignment leads to conflict and undervaluation of your expertise.
Project-based pricing (also called fixed-price) is often better for both parties. You estimate the scope, you quote a fixed price, and you deliver. If you finish early, you keep the extra profit. If you finish late, you eat the cost—but this incentivizes you to work efficiently and get good at estimation.
Retainer pricing is even better for building a sustainable solo business. Instead of charging per project, you charge a fixed monthly fee in exchange for a certain number of hours or a certain level of availability. This creates predictable revenue, reduces sales overhead, and builds stronger client relationships.
Retainers are particularly valuable for solo developers because they solve the "feast or famine" problem. Instead of having months where you're fully booked and months where you're scrambling for work, you have a baseline of predictable income. This gives you the breathing room to be selective about additional projects.
The transition from hourly to project-based or retainer pricing does require better estimation skills and a deeper understanding of your client's needs. But it's a worthwhile investment. Developers who charge retainers typically earn 30–50% more than developers charging hourly rates for the same amount of work.
Let's do the real calculation one more time, with a framework you can use to figure out your own number.
Step 1: Decide on your target annual income.
This is the amount you want to actually take home and spend. If you were making $150k as an employee and you want to maintain that lifestyle, start with $150k. If you want to make more, great—adjust accordingly.
Step 2: Calculate your true business expenses.
This includes:
Your total annual income needed is: Target income + X
Step 3: Estimate your realistic billable hours.
This is where most developers get it wrong. You can't bill 2,000 hours per year. A realistic estimate is:
Step 4: Divide.
Total annual income needed ÷ Billable hours = Your hourly rate
For a senior developer who was making $150k, this typically comes out to $120–$160 per hour, depending on your expenses and how conservative you are with billable hours.
If you calculated $85–$100 per hour, you now understand why you're struggling.
The financial impact of underpricing is significant, but it's not the only cost.
Underpricing affects your reputation. When you charge low rates, clients assume you're junior or desperate. They treat you differently. They're more likely to request endless revisions, to expect you to be available at all hours, and to question your decisions. Your low rate becomes a signal of low quality.
Underpricing attracts the wrong clients. Price-sensitive clients are often the most demanding and the slowest to pay. They're shopping primarily on rate, which means they're likely to leave you for someone cheaper as soon as a better deal comes along. You don't build long-term relationships; you build a constant churn of short-term projects.
Underpricing prevents you from doing your best work. When you're constantly stressed about making ends meet, you can't afford to take time to learn new technologies, refactor old code, or think deeply about architecture. You're in survival mode, grinding through projects as fast as possible. This hurts the quality of your work and your own professional growth.
Underpricing leads to burnout. You're working more hours for less money, dealing with difficult clients, and not making the income you expected. Burnout is inevitable. And when you burn out, you often go back to employment—which means all the effort you put into going solo was wasted.
The developers who thrive as solopreneurs aren't the ones who undercut on price. They're the ones who price correctly, attract better clients, and have the breathing room to do their best work.
Now that you understand why the salary-to-hourly conversion is broken, let's talk about pricing strategies that actually work.
Strategy 1: Anchor to value, not cost.
When a client asks for your rate, don't lead with an hourly number. Instead, ask questions about their business, their goals, and the impact of the work you'll do. Understand the problem you're solving and what it's worth to them. Then price accordingly.
For example, if you're building an integration that will save a client 10 hours per week, and they value their time at $100/hour, that integration is worth $52k per year to them. You might charge $15k–$25k for the project, and both parties feel like they got a great deal.
Strategy 2: Use retainers for predictable revenue.
Retainers are the most underrated pricing model for solo developers. Instead of charging per project, offer a monthly retainer for a certain number of hours or a certain level of availability. This creates predictable revenue and stronger client relationships.
A typical retainer might be: "$5k per month for 20 hours of development work, plus email support." If the client needs more than 20 hours, you bill hourly at a premium rate (e.g., $150/hour instead of $100/hour). This incentivizes you to be efficient within the retainer hours while capturing additional value if the client needs more.
Strategy 3: Use project-based pricing for larger engagements.
For bigger projects, move away from hourly billing entirely. Estimate the scope, quote a fixed price, and deliver. This aligns incentives: you're motivated to work efficiently, and the client knows exactly what they'll pay.
Project-based pricing does require better estimation skills. You'll get better with practice, but expect to underbid on your first few projects. That's okay—it's part of learning.
Strategy 4: Build in price escalators.
As Simon-Kucher's research on pricing mistakes shows, lack of annual price escalators is a common SaaS mistake—but it applies to freelancers too. If you have long-term retainer clients, plan for annual price increases of 5–10%. This accounts for inflation and your increasing expertise. Most good clients expect this and budget for it.
Strategy 5: Segment your pricing by client type.
Not all clients are equal. A startup with a tight budget is very different from an established company with a healthy budget. You can offer different service levels or pricing tiers for different client types.
For example:
When you raise your rates from $85/hour to $130/hour, you'll face objections. Here's how to handle the most common ones.
"That's more than I budgeted."
Response: "I understand. Let's talk about what's most important to you in this project. Maybe we can scope it down to fit your budget, or maybe we can structure it as a retainer so you're not paying for everything upfront."
The key is not to immediately drop your price. Instead, explore whether the project can be scoped down or restructured. Sometimes the answer is that this client isn't a good fit, and that's okay.
"I can get someone to do it for less."
Response: "You might be able to. I'd encourage you to talk to a few developers and see what you get for the price. I'm confident in the quality of my work and the value I deliver. I'm happy to discuss specific concerns about scope or timeline if you have them."
Don't defend your price. Let the client make the comparison. Good clients will come back.
"Why are you so expensive?"
Response: "I'm not the cheapest option, but I'm also not the most expensive. I price based on the value I deliver and the quality of my work. I've been doing this for [X years], and I've built a track record of delivering results. I'm confident that the investment will pay off."
This isn't arrogant—it's accurate. Senior developers should price like senior developers.
Pricing isn't something you set once and forget. As your business grows, your pricing should evolve.
In your first 6 months: You might charge closer to $100–$120/hour. You're still building your reputation and portfolio. Focus on getting good clients and delivering excellent work.
After 6–12 months: You should be raising your rates. If you're fully booked and getting good feedback, you've earned the right to charge more. Increase by 10–20% and let clients know. Most will accept it.
After 1–2 years: You should be at $130–$160+/hour, depending on your niche and the complexity of your work. You should also be experimenting with retainers and project-based pricing.
After 2+ years: You might move away from hourly billing entirely. You might have 2–3 retainer clients providing 60% of your income, plus a few project-based engagements. Your effective hourly rate is now much higher because you're not billing for all your time.
The goal isn't to maximize your hourly rate—it's to maximize your sustainable annual income while maintaining work-life balance and doing work you enjoy.
This is where tools like Cashierr come in. When you're solo, it's easy to lose track of whether your pricing strategy is actually working. You need visibility into:
With visibility into your actual revenue and profitability, you can make smarter pricing decisions. You'll know if your rate increases are working. You'll know which clients are worth keeping and which ones are dragging down your profitability. You'll have the data to support your pricing conversations.
You spent years building expertise. You've solved hard problems, shipped features that matter, and earned the respect of your peers. When you go solo, don't throw all of that away by pricing like a junior developer.
The salary-to-hourly conversion is broken because it ignores the real costs of running a business, the value you deliver, and the limited billable hours you actually have available. It's a shortcut that feels safe, but it costs you tens of thousands of dollars per year.
Instead, do the math. Calculate your real expenses. Estimate your realistic billable hours. Figure out what you actually need to earn. Then price accordingly.
You'll attract better clients. You'll do better work. You'll have the breathing room to grow. And you'll actually make what you deserve.
The mistake isn't in going solo. The mistake is in underpricing. Fix that, and everything else gets easier.
When you're ready to implement a new pricing strategy, here's how to have the conversation with clients.
For new clients: Just quote your new rate. Don't apologize for it. If they push back, explore whether the scope can be adjusted or the project can be restructured. Some clients will say no, and that's okay. You're filtering for clients who value your work.
For existing clients: Be transparent. You might say something like: "I've been doing some analysis on my business, and I've realized my previous rates didn't account for all the costs of running a solo operation. Starting [date], my rate is increasing to $[new rate]. I really value our relationship, and I hope we can continue working together at the new rate. I'm happy to discuss any concerns."
Most good clients will accept a reasonable rate increase, especially if you've been delivering value. The ones who don't might not be good clients anyway.
For retainer clients: Build in annual escalators from the start. You might say: "This retainer is $5k per month, with a 5% annual increase each year to account for inflation and my increasing expertise."
This sets expectations upfront and removes the awkwardness of negotiating a raise later.
As you think about pricing, it's worth exploring how other business owners approach this problem. Forbes' guide on pricing strategy provides a comprehensive look at developing effective pricing strategies and avoiding common valuation errors. Entrepreneur's article on pricing offers expert advice on pricing methodology and the psychological factors that influence customer purchasing decisions.
For a deeper dive into the mistakes most companies make, Engine Builder Magazine's resource on common pricing mistakes identifies cost-based pricing as the primary mistake and its impact on sales cycles and profit margins. And New Hope's guide to pricing mistakes explains the critical error of basing prices on costs rather than customer value perception—a fundamental mistake solo developers often make.
The key insight across all these resources is the same: pricing based on cost (or in your case, your old salary) leaves money on the table. Pricing based on value is where the real opportunity lies.
Once you've got your pricing right, the next challenge is planning. How much revenue do you need to hit this quarter? What does that mean in terms of client work? Are you on track?
This is where revenue planning and forecasting becomes critical. As a solo developer, you need to answer two questions:
Cashierr's agentic approach to revenue planning helps you answer these questions. Instead of manually tracking spreadsheets and trying to predict the future, Cashierr's AI agents do the work for you. They track your goals, project your revenue, and flag gaps before they hurt.
With the right pricing and the right planning tools, you can build a solo developer business that's not just sustainable—it's actually profitable and enjoyable.
You've earned it. Now price like it.
Master the 3-bucket system for solo developers: operating, tax, and profit accounts. Stop leaving money on the table and make tax season painless.
Master your solo dev finances in 30 minutes every Friday. Track revenue, expenses, goals, and cash flow with this step-by-step ritual.
Master revenue forecasting by tracking just 5 metrics. Learn which data points drive 80% of forecast accuracy for freelance developers.