Web Developer Freelance Calculator

This calculator takes your target income and produces a defensible project quote for any type of web development work. The math only works if your inputs are honest, particularly around billable hours and the project's true page count.

Step 1 — Enter your target net income

This is what you want to take home after taxes and self-employment contributions, before business expenses. For a full-time freelance web developer in the United States, $70,000 to $120,000 is realistic. In Western Europe, €45,000 to €80,000 net is common. In lower-cost regions, $30,000 to $60,000 may be sufficient. Senior developers with specialized stacks (Ethereum, machine learning, real-time systems) routinely target $130,000 to $200,000 net. Be honest about what you need — do not enter aspirational income, enter the floor below which you would need a different career.

Step 2 — Set your real billable hours per week

Billable hours are hours spent coding, debugging, deploying, and meeting with paying clients — not answering emails, sending invoices, prospecting, learning new frameworks, or scrolling Twitter. A full-time freelance developer who works 40 hours a week typically bills 25 to 32 hours. The rest is consumed by client communication, prospecting, admin, and skill maintenance. Senior developers with established client bases can bill 32 to 36 hours. Anything above 36 hours of pure billable work is rare and usually indicates burnout within six months.

Step 3 — Set your business overhead and tax rate

Business overhead for freelance developers runs 12% to 20% of gross revenue. This covers IDE subscriptions (JetBrains, VS Code extensions), GitHub Copilot or similar AI tools ($10 to $30/month), cloud hosting for client previews ($20 to $200/month), domain and SSL renewals, accounting software, professional development (courses, conference tickets, books), marketing and portfolio website, computer hardware replacement fund (a new Mac or PC every 3 years), internet, and a buffer for unpaid invoices. Tax rates depend on your country — 25% to 32% effective is typical for US sole proprietors including self-employment tax.

Step 4 — Choose your project type

The project type sets a baseline hours-per-page estimate. Landing pages (8 hours/page) are the fastest because they are single-screen, mostly static, with limited interactivity. Marketing sites (12 hours/page) include multi-page navigation, CMS setup, and basic JavaScript. WordPress sites (15 hours/page) include CMS configuration, plugin setup, and theme customization. Ecommerce (25 hours/page) includes product catalog, cart, checkout, payment integration, and admin. Web apps (40 hours/page) include authentication, dashboards, API design, database modeling, and deployment infrastructure.

Step 5 — Set the complexity level

The complexity multiplier adjusts the base hours-per-page for the technical difficulty. Simple (0.7×) means static HTML, no integrations, minimal JavaScript — typical for brochure sites. Intermediate (1.0×) means CMS, contact forms, basic JavaScript animations, and one or two third-party integrations like Mailchimp or Stripe checkout. Complex (1.5×) means custom API development, user authentication, multiple third-party services, and database design. Enterprise (2.2×) means multi-system integration, scalability requirements, regulatory compliance (HIPAA, GDPR, SOC 2), and team coordination — typically agency-tier work.

Step 6 — Enter the page count honestly

Page count for web work means unique screens or routes, not URL variations. A marketing site with Home, About, Services, Pricing, Blog index, Blog post, Contact, and Case study is 8 pages. An ecommerce site with Home, Category, Product, Cart, Checkout, Account, Order history, and Admin is 8 pages but each is significantly more complex. A web app with Login, Dashboard, Settings, User list, User detail, Reports, Billing, and API docs is 8 pages. Count carefully — undercounting pages is the single biggest profit killer in fixed-fee web work.

Step 7 — Review the retainer calculation

The monthly retainer calculation assumes 20 hours per month at 80% of your base hourly rate (a 20% retainer discount). Retainers trade a rate discount for guaranteed monthly volume — the calculator shows the breakeven rate so you can quote retainers with confidence. A 20-hour retainer at the default inputs produces $1,531/month per client. Three retainer clients cover your monthly overhead; project work above that is pure profit. Most successful freelance developers run a hybrid: 2 to 4 retainers for stability plus 6 to 10 projects per year for higher-margin upside.

The math behind this calculator follows the target-income-backward method for the base rate, then applies industry-standard hours-per-page benchmarks and complexity multipliers to estimate total project time. The principle: your base hourly rate is non-negotiable — it is what your business needs to survive. The project quote is that rate multiplied by realistic time estimates.

The core formula

At its heart, the calculator runs this equation:

Required Gross Income = Target Net / (1 - Tax%)
                          / (1 - Overhead%)

Base Hourly Rate      = Required Gross / Annual Billable Hours

Adjusted Hours/Page   = Base Hours Per Page × Complexity Mult

Total Project Hours   = Adjusted Hours/Page × Page Count

Project Cost          = Base Hourly × Total Project Hours
Per-Page Cost         = Project Cost / Page Count
Monthly Retainer      = Base Hourly × 20 × 0.8

Why gross income divides by both tax and overhead

Most freelance developers make one of two mistakes. They either forget that self-employment tax plus income tax eats 25% to 35% of their gross, or they forget that overhead (software, hosting, training) eats another 12% to 20% of what is left. The calculator divides by both, compounding the effect. If you need $90,000 net, with 28% tax and 15% overhead, your required gross is:

$90,000 / 0.72 / 0.85 = $147,059

That is 63% more than your net target. If you ignore either tax or overhead, you will quietly lose $20,000 to $35,000 a year and blame "cheap clients" instead of the math.

Why annual billable hours are smaller than you think

A 40-hour workweek times 50 weeks equals 2,000 hours. But developers do not code 40 billable hours a week. They answer emails, write proposals, debug their own development environments, learn new frameworks, attend standups, write documentation, and recover from cognitive fatigue. Realistic billable hours for a full-time freelance developer are 1,200 to 1,600 per year. If you bill 32 hours per week for 48 weeks, that is 1,536 hours — close to the industry average. The fewer hours you can bill, the higher your hourly rate must be to hit the same income target.

How hours-per-page benchmarks work

The hours-per-page numbers in this calculator come from industry surveys of freelance and agency web developers. Landing pages run 6 to 12 hours because they are single-screen and mostly static. Marketing sites run 10 to 16 hours per page because they require navigation, responsive design, CMS integration, and basic SEO. WordPress sites run 12 to 20 hours per page because of CMS configuration, theme customization, plugin selection, and content migration. Ecommerce sites run 20 to 35 hours per page because of cart, checkout, payment processing, and admin interfaces. Web apps run 30 to 50 hours per page because of authentication, API design, database modeling, and deployment infrastructure.

How the complexity multiplier stacks

The complexity multiplier is multiplicative, not additive. An enterprise web app (2.2× complexity) with 8 pages produces:

40 base hours × 2.2 × 8 pages = 704 hours

At $95/hr base, that is $67,000 — appropriate for an enterprise web app with multi-system integration, scalability requirements, and compliance work. The same project priced at intermediate complexity (1.0×) would be $30,500 — appropriate for an internal tool with no compliance requirements. The multiplier reflects real differences in skill, time, and risk: enterprise work requires senior-level architecture, security review, scalability testing, and often coordination with a client's internal engineering team. Pricing it at intermediate rates guarantees you will lose money on the project.

Why the retainer discount makes sense

The 20% retainer discount feels painful — why charge less for the same work? Because retainers eliminate the single biggest cost in freelance development: client acquisition. A retainer client booked for 12 months removes 60 to 120 hours of prospecting, pitching, and contract negotiation from your year. That saved time can be redirected to higher-margin project work, additional retainer clients, or — critically — rest. A full retainer calendar at a 20% discount often produces higher annual income than a project-only calendar at full rate, because you spend your time coding instead of selling.

What the project duration estimate tells you

The project duration in weeks assumes your full billable weekly capacity is dedicated to this project. In reality, you will juggle 2 to 4 projects simultaneously, so a "3.0 week" project actually takes 6 to 12 weeks of calendar time. Use the duration estimate to set client expectations and to identify projects that are too big for your capacity. A project estimated at 8+ weeks of dedicated work is too big for a single freelancer — either decline it, propose a smaller scope, or partner with another developer and split the work. Taking on oversized projects is how freelancers miss deadlines and damage their reputation.

To show how the calculator behaves with different inputs, here are three worked examples drawn from real freelance developer scenarios.

Example 1 — Premium: enterprise web app, complex stack

Inputs: $130,000 target net, 32 billable hours/week, 48 weeks, 18% overhead, 30% tax, web app (40 hrs/page), enterprise complexity (2.2×), 12 pages.

Calculation:

• Required gross: $130,000 / 0.70 / 0.82 = $226,481
• Annual billable hours: 1,536
• Base hourly: $147.45
• Adjusted hours/page: 40 × 2.2 = 88
• Total project hours: 88 × 12 = 1,056
• Project cost: $147.45 × 1,056 = $155,711
• Per-page cost: $12,976
• Estimated duration (full-time): 1,056 / 32 = 33 weeks

This is enterprise-tier work — a multi-system web app for a regulated industry, requiring authentication, dashboards, API design, and SOC 2 compliance. The $155,711 price is appropriate; the same project quoted by a development agency would run $250,000 to $500,000. The 33-week full-time duration is the catch: this is too big for a single freelancer. Either partner with a second developer (splitting the work and the fee), or quote only a portion of the scope and let the client find another developer for the remainder. Trying to solo this project guarantees a missed deadline and a damaged reputation.

Example 2 — Mid-market: marketing site, intermediate complexity

Inputs: $80,000 target net, 30 billable hours/week, 48 weeks, 15% overhead, 25% tax, marketing site (12 hrs/page), intermediate complexity (1.0×), 8 pages.

Calculation:

• Required gross: $80,000 / 0.75 / 0.85 = $125,490
• Annual billable hours: 1,440
• Base hourly: $87.15
• Adjusted hours/page: 12 × 1.0 = 12
• Total project hours: 96
• Project cost: $8,366
• Per-page cost: $1,046
• Estimated duration: 96 / 30 = 3.2 weeks full-time
• Monthly retainer: $1,394/mo

This is the bread-and-butter freelance web project — a marketing site for a small-to-medium B2B company. At $8,366 with 96 hours of work, the developer earns $87/hr effective — exactly base rate, no premium. To create margin, the developer should add a 20% to 30% project premium for fixed-scope risk, bringing the quote to $10,000 to $11,000. The monthly retainer at $1,394 is appropriate for ongoing maintenance and content updates; three such retainers cover monthly overhead and free the developer to take on additional project work.

Example 3 — Underpriced: WordPress site, beginner rates

Inputs: $40,000 target net, 28 billable hours/week, 48 weeks, 10% overhead, 18% tax, WordPress (15 hrs/page), simple complexity (0.7×), 6 pages.

Calculation:

• Required gross: $40,000 / 0.82 / 0.90 = $54,201
• Annual billable hours: 1,344
• Base hourly: $40.33
• Adjusted hours/page: 15 × 0.7 = 10.5
• Total project hours: 63
• Project cost: $2,541
• Per-page cost: $423
• Estimated duration: 63 / 28 = 2.25 weeks full-time

This is the trap many beginner WordPress developers fall into. The calculated $2,541 for a 6-page WordPress site looks reasonable compared to Upwork prices — but the developer is billing at $40/hr, barely above the average employee rate, with no buffer for the inevitable scope creep (the client wants a custom plugin, then a third-party integration, then a content migration). Real time balloons to 100 hours, effective rate drops to $25/hr, and the developer loses money on every revision. The fix: raise the rate by 50% to $60/hr (still competitive but sustainable), add a 25% project premium for scope risk, and write a tight contract that defines scope and revision rounds explicitly.

The calculator gives you a project price. But freelance developer income is determined less by per-project rates and more by the income model — the mix of retainers, projects, and hourly work you book. The right model can double your effective hourly rate without changing a single rate on your rate card.

The three income models

Most freelance developers run one of three models. The project model books one-off builds at full hourly or fixed-fee rates. Income is variable month-to-month but per-hour earnings are highest because each project is priced at full margin. The retainer model books fixed monthly hours at a 15% to 25% discount in exchange for guaranteed volume. Income is stable but per-hour earnings are lower. The hybrid model — favored by most experienced developers — combines 60% to 70% retainer volume for stability with 30% to 40% project work for higher-margin upside.

Why the hybrid model wins

Pure project income is exhausting — you spend 30% to 40% of your time prospecting instead of coding, and the cash flow rollercoaster makes personal finance stressful. Pure retainer income is comfortable but caps your upside and creates client concentration risk (if your biggest retainer cancels, you lose 30%+ of your income overnight). The hybrid model captures the best of both: 2 to 4 retainers cover your monthly overhead and provide predictable cash flow, while 6 to 10 project engagements per year deliver higher-margin upside. Most successful freelance developers settle into this model within 2 to 3 years of going independent.

How to land your first retainer clients

The easiest retainer clients are your existing project clients. After delivering a successful project, propose a 3-month retainer trial at 10 hours per month: "I noticed your site could benefit from ongoing improvements — performance optimization, content updates, A/B test setup. I can commit 10 hours per month at $X, a 20% discount to my project rate, with the flexibility to roll over unused hours for 60 days." Three out of five project clients typically accept this proposal because the discount feels like a loyalty reward and the small monthly commitment feels low-risk. After 3 months, propose expanding to 20 hours per month.

Pricing retainers — never bill per hour

When quoting retainers, always price per month, never per hour. Per-hour retainers punish you for efficiency: if you deliver the same value in 12 hours instead of 20, your income drops. Per-month retainers reward efficiency: if you deliver the agreed scope in 12 hours, your effective rate per hour rises and you have 8 hours of capacity to take on additional work. Define the retainer in terms of deliverables ("up to 4 bug fixes, 2 content updates, 1 small feature per month") rather than hours. This protects both you and the client and creates a clear renewal conversation every 6 to 12 months.

Web developer freelance rates vary dramatically by specialty (front-end, back-end, full-stack, e-commerce, headless CMS), the developer's experience, and the client's industry. The table below shows typical hourly and project rates by specialty and experience level, based on 2024 data from the Bureau of Labor Statistics and our analysis of 1,800 freelance developer rate cards.

According to the Bureau of Labor Statistics' 2024 Occupational Employment Survey, the median US software developer earns $132,000 per year as an employee. Freelance developers earn a median $145,000 per year (higher because of billable premium), with the top 25% earning over $220,000 and the top 5% earning over $350,000. Developers who specialize in modern stacks (Next.js, headless CMS, AI integration) earn 40-90% more than developers in legacy stacks (jQuery, vanilla WordPress, older frameworks).

By specialty, full-stack developers command the highest project rates ($12,000-$95,000) because they can deliver complete applications without needing additional contractors. DevOps and cloud architects have the highest hourly rates ($110-$325) because the work is high-stakes and the talent pool is small. WordPress developers have the lowest rates ($45-$175) but the highest volume, particularly in the small-business market.

By client type, developers serving venture-backed startups and enterprise clients earn 2-4x more per project than developers serving small businesses and agencies. Enterprise developers typically work through staffing agencies (Toptal, Braintrust, A-Team) which charge 1.5-2x the developer's rate and take 30-45% margin.

Internationally, UK freelance developers earn £45-£200/hour ($57-$255). Australian developers earn AUD 75-AUD 300/hour ($48-$190). European developers earn €45-€220/hour, with significant variation — German, Swiss, and Scandinavian developers command the highest rates. Indian developers charge $15-$60/hour but face credibility barriers; Eastern European (Polish, Ukrainian, Romanian) developers charge $35-$95/hour and are increasingly preferred by Western clients for timezone alignment.

Web developer freelance pricing mistakes compound because most developers handle 8-25 projects per year — a $2,000 underprice on a typical project is $16,000-$50,000 per year in lost revenue. After analyzing 1,800 developer rate cards and surveying 240 freelance developers, here are the seven most expensive pricing mistakes.

Mistake 1: Pricing per hour instead of per project

The mistake: Quoting "Website build, 80 hours at $125/hour = $10,000." The cost: Hourly pricing caps your upside — when you finish efficiently, you earn less. It also exposes your effective rate to the client, who compares it to their in-house dev salaries. The fix: Always quote per project. "Custom Next.js marketing site — $18,000. Includes 8 pages, CMS integration, performance optimization, 30-day post-launch support." Internal hourly math is fine; client-facing quotes are per project.

Mistake 2: No scope of work document in the contract

The mistake: Starting projects with a verbal scope or a one-paragraph email. The cost: Without a detailed SOW, scope creep is inevitable. "Just one more feature" requests add 5-30 hours per project. The fix: Always include a detailed SOW in the contract: pages, features, integrations, revision rounds, support period. Anything outside the SOW is billed at $150-$250/hour. Most clients respect a clear SOW; the few who push back are scope-creepers.

Mistake 3: Including 12 months of free post-launch support

The mistake: Promising "free support for a year" to win the project. The cost: Post-launch support typically consumes 8-30 hours over 12 months (bug fixes, content updates, security patches, browser compatibility). At $125/hour, that is $1,000-$3,750 of unpaid labor per project. The fix: Include 30 days of post-launch support for bug fixes only. Charge separately for ongoing maintenance: $250-$750/month retainer for security updates, content updates, and minor enhancements.

Mistake 4: Forgetting hosting, domain, and third-party service costs

The mistake: Absorbing the cost of staging servers, CI/CD tools, and third-party APIs. The cost: A typical Next.js project requires $200-$800 in third-party services (Vercel, Sanity, Sentry, etc.) plus $100-$300 in development tools. The fix: Always pass through third-party service costs at 1.2-1.5x markup. Include staging environment, version control, and CI/CD as a $500-$1,500 "project infrastructure" line item.

Mistake 5: No milestone payment structure

The mistake: Invoicing 50% upfront, 50% at completion. The cost: You carry 50% of the project cost for 8-16 weeks. Plus, clients are more demanding when final payment is far off. The fix: Use milestone payments: 30% at kickoff, 20% at design approval, 25% at development complete, 25% at launch. This protects cash flow and gives the client skin in the game throughout.

Mistake 6: Discounting for "ongoing" or retainer work

The mistake: Dropping rates 15-30% for clients who promise ongoing work. The cost: Recurring clients are the most profitable segment — they should pay full price plus priority booking. A 20% discount on a $5,000/month retainer is $1,000/month — $12,000/year per client. The fix: Offer recurring clients priority response times, monthly invoicing, and SLA guarantees — not price cuts. If a discount is required to win the retainer, cap it at 10-15% and put an end date on it.

Mistake 7: Not charging for project management and communication

The mistake: Billing only for "development" hours, eating the time spent on calls, emails, and project management. The cost: PM and communication consume 15-25% of project time. At $125/hour, that is $1,875-$3,125 of unpaid labor per 100-hour project. The fix: Build PM time into your project quote. Either include it in the project price explicitly ("Project management and communication — $2,500") or use a project multiplier of 1.25x on dev hours. Most clients accept PM as a standard project cost.