How Much Should You Charge? How to Price Your First Software or Web Project

Watch the 2-minute video:

Your first real client just said yes. A full booking website, your own project. You’re happy, and then they ask: “So… how much?”

And your mind goes blank.

Every new developer hits this moment. The good news: pricing isn’t magic. It comes down to two questions:

How much work is it? (estimating)
How do you charge for it? (the pricing model)

Answer them in that order, then protect yourself with a contract and a payment schedule.

Part 1: Estimate the work

1. Lines of code (LOC / KLOC) and COCOMO

The classic way to size software is to count lines of code (LOC). One thousand lines is one KLOC.

In 1981 Barry Boehm published COCOMO (the Constructive Cost Model), which turns a size in KLOC into effort. The basic formula for a small, familiar (“organic”) project is:

Effort (person-months) = 2.4 x KLOC^1.05

COCOMO II (2000) refined it with cost drivers such as team experience, tools and reliability.

Why it’s not your best tool as a freelancer:

You must guess the number of lines before you write them.
Line counts change a lot with the language, framework and coding style. A Laravel or Next.js app does a lot in few lines.
With frameworks and AI code tools, more code doesn’t mean more value or more work.

It’s worth knowing (it shows up in exams, big companies and government contracts), but for a client website you need something more practical.

2. Work breakdown (per module): the method to use

Split the project into modules and give each one hours. For our clinic booking website:

Module	Hours
Design (UI, responsive)	12
Login and accounts	8
Booking (calendar, slots)	20
Admin dashboard	16
Payments	10
Testing and launch	10
Total	76

Then add 20 to 30% for surprises: unclear requirements, client feedback rounds, bugs, deployment issues. There are always surprises.

76 h x 1.3 = about 100 hours.

Tip: three-point estimates. If you’re unsure about a module, estimate it three ways: optimistic (O), most likely (M) and pessimistic (P), then use the PERT formula:

Estimate = (O + 4 x M + P) / 6

For the booking module: (14 + 4 x 18 + 34) / 6 = 20 hours.

3. Analogous estimating (compare a similar project)

Built something similar before? Use it as your ruler. If last year’s gym booking site took 90 hours, a clinic booking site with a similar feature list is probably close to that, adjusted for the differences (payments, extra roles, more pages).

This is called analogous estimating. It’s fast and gets more accurate with every project you track, so log your real hours on every job.

4. Function points

Instead of lines, function point analysis (Allan Albrecht at IBM, 1979; now an IFPUG standard) measures what the user sees and does: screens, inputs, outputs and reports, inquiries, and the data files the system keeps. Each item gets a weight by complexity, and the total is turned into effort using historical data.

It’s language-independent, so large companies and governments use it in contracts. For a freelancer it’s useful as a checklist: counting every screen, form and report makes sure nothing is forgotten in your breakdown.

Part 2: Choose how to charge

Hourly (time and materials)

The client pays for the hours you actually work. To set your rate:

Hourly rate = (monthly income goal + business costs) / billable hours per month

Example: you want $3,000 a month, your costs (laptop, software, hosting, internet, taxes set aside) are $300, and you can bill about 100 hours a month:

($3,000 + $300) / 100 = $33, rounded to $35/hour

Billable hours are always fewer than working hours, because you also spend time on emails, meetings, learning and finding clients. Plan on billing 50 to 70% of your time.

Best for: unclear or changing scope.

Fixed price

One number for a locked, written scope. The client knows the cost upfront, and you carry the risk if the estimate is wrong. That’s why the buffer matters. Anything outside the scope becomes a change request with its own price.

Best for: clear scope you’ve estimated with a work breakdown.

Value-based

The price follows the value the project creates for the client (more bookings, hours saved, new revenue), not your hours. If an online booking system brings a clinic $2,000 more each month, a $5,000 price is easy for the client to accept.

Best for: experienced developers and projects with a clear, measurable business impact.

Retainer

A monthly fee for an agreed block of support and maintenance after launch: updates, backups, small changes, security fixes. It gives you steady income every month.

Best for: after launch.

Quick guide: which one?

Situation	Model
Scope is clear	Fixed price
Scope is unclear	Hourly
Big business impact	Value-based
After launch	Retainer

Part 3: Send the quote

Our example becomes a simple quote:

Quote #001: Clinic booking website
Prepared by: Abd Almouhimen Shamout · mouhimen.dev
Estimate: 100 hours
Rate: $35 / hour
Total: $3,500
Valid for 14 days

Add the module list from your breakdown, what’s included, what isn’t, and the timeline.

Part 4: Get paid safely

Sign a contract. It lists the scope, the timeline, the payment schedule, and how changes are handled.
Take a deposit before you write one line of code. 30 to 50% is common. In our example: 40% = $1,400.
Tie the rest to milestones. 30% ($1,050) at the demo, 30% ($1,050) at launch.
Hand over the source files and credentials after the final payment. Ownership transfers when you’re paid.
New feature? New quote. Scope creep is the fastest way to lose money on a fixed-price job.

Checklist

[ ] Break the project into modules and estimate hours for each
[ ] Add a 20-30% buffer
[ ] Compare with a similar past project
[ ] Pick a model: hourly, fixed, value-based or retainer
[ ] Calculate your hourly rate from your goal, costs and billable hours
[ ] Send a written quote with scope and a validity date
[ ] Sign a contract
[ ] Take a deposit before coding, then milestone payments
[ ] Hand over files after the final payment
[ ] Price every new feature as a new quote

Watch the video:

Sources

COCOMO model overview: https://www.geeksforgeeks.org/software-engineering/software-engineering-cocomo-model/
COCOMO explained: https://medium.com/@rafsan_sadman/cocomo-estimation-understanding-the-constructive-cost-model-e6678ff915e7
What are function points (Total Metrics): https://totalmetrics.com/function-point-resources/what-are-function-points.html
PERT three-point estimate: https://pmstudycircle.com/pert-calculator/
PERT for better estimates (TechRepublic): https://www.techrepublic.com/blog/it-consultant/use-pert-technique-for-more-accurate-estimates/
Software development pricing models (Dreamix): https://dreamix.eu/insights/software-development-pricing-models/
Pricing models in custom software development (Taazaa): https://taazaa.com/?p=12044
Pricing projects as a freelancer or agency owner (Smashing Magazine): https://shop.smashingmagazine.com/2024/08/pricing-projects-freelancer-agency-owner/
Retainer vs project pricing: https://acquaintsoft.com/blog/monthly-retainer-vs-project-based-pricing-python-development
How to set a freelance hourly rate: https://everhour.com/calculators/how-to-set-freelance-hourly-rate
Deposit and milestone payment schedules: https://dev.to/olubunminelson/how-to-structure-a-deposit-and-milestone-payment-schedule-for-fixed-price-freelance-projects-ghj
Milestone payments for freelancers: https://ruul.io/blog/milestone-payments-freelancers