What you'll learn

By the end of this you'll know what you actually need to get started as a freelance developer — not a business plan, not a personal brand strategy, but the minimum viable setup to take on a real project, deliver it, and get paid. You'll also know the mistakes that make first-time freelancers expensive clients to themselves.

This is for starting, not optimizing. Once you have a few projects under your belt, the optimization conversation changes.

Who this is for

  • Developers who want to freelance but feel like they need to "set everything up" before taking on work
  • Employed developers thinking about going independent and not sure what's actually required
  • Career-changers who've built their skills and want to see if they can get paid before looking for a full-time role

You can skip this if you're already established as a freelancer and looking to scale — this is a first-project guide, not a growth-stage playbook.

What freelancing is for developers

Plain English: freelancing means you find someone who needs software built, agree on scope and price, build it, and invoice them.

Half the job is not code — it is sales, scoping, and getting paid. The starter path ignores LLCs and personal brands until you have one delivered project and one testimonial.

Prerequisites

You should be able to build a small web app or landing page without daily hand-holding — roughly "I can ship a five-page marketing site with a contact form." You also need:

  • A bank account and a way to invoice (Stripe, PayPal, or Wave)
  • One portfolio piece or GitHub repo to link
  • Comfort saying your rate out loud to another human

If you cannot demo anything yet, spend two weeks on one portfolio project before pitching clients.

Setup from zero

Step 1 — Publish linkable work

Put your best project on GitHub with a README: what it does, stack, how to run locally, screenshot or live URL. Optional: one-page portfolio site that links to it. Clients hire from links, not promises.

Step 2 — Draft a one-page SOW template

Before pitching, write a scope template (see Working examples). Fill in project name, deliverables, exclusions, timeline, price, revision rounds. Sending scope before coding prevents most freelance horror stories.

Step 3 — Tell ten people you are available

Email or message ten people in your network with one sentence: what you build, who it is for, and that you are taking projects. Most first clients are one degree away, not from Upwork rankings.

Little tip: set a floor rate on paper before your first call. "I will not go below $X/hour or $Y project" written down beats negotiating against yourself live on Zoom.

The mental model

The mental model for freelancing as a developer is: you are selling a service, not your time.

Most developers who start freelancing price themselves hourly because it feels the most honest — you're paid for work, and hourly is how work is measured. But hourly pricing puts the client in the position of watching the clock and you in the position of justifying every hour. It creates incentives that don't serve either party well: you're penalized for efficiency, and the client has no fixed cost to budget against.

Project-based pricing is harder to set at first, but it aligns incentives better. The client knows the cost. You know your scope. When you finish faster because you've gotten better, you earn more per hour without discussing it.

The shift isn't about extracting more money — it's about framing the relationship as "here's what we're building together" rather than "here's how many hours I worked." That framing change affects how clients treat the work, how you scope it, and how you have conversations when something takes longer than expected.

Key terms

Scope creep — the gradual expansion of a project beyond what was originally agreed on, usually through small requests that each seem reasonable. The fix is a written scope document that both parties agree to before work starts.

SOW (Statement of Work) — a document describing what you'll build, what you won't build, how many revisions are included, and the timeline. Doesn't have to be long. Does have to exist.

Net-30 — payment terms where the client pays within 30 days of invoice. Common in professional services. As a new freelancer you may want to negotiate shorter terms or partial upfront payment to reduce cash flow risk.

Retainer — an ongoing paid arrangement where a client pays a fixed monthly fee for a defined amount of work or availability. More predictable than one-off projects; requires a client relationship solid enough to commit both ways.

Portfolio — the collection of work you show prospective clients. At the start, this is your GitHub and any public projects. It does not have to be polished or impressive — it has to exist and be linkable.

Step-by-step

Step A — Make your work linkable

A GitHub profile with described projects is the minimum. A one-page portfolio is better. You need something a client can open without you forwarding files.

Step B — Write a simple SOW template

Draft a one-page scope: deliverables, exclusions, timeline, price, revision rounds. Clients who push back hard on clear scope are showing you how the project will go.

Step C — Set your rate

Estimate hours × rate + 30% for non-billable time. Check market pricing for similar projects. Pricing below floor for first clients is an investment in social proof — know which game you're playing.

Step D — Find your first client

Tell people you know. Post specifically on LinkedIn ("I build React landing pages for small businesses"). Cold outreach with a specific fix ("your contact form errors — I can repair for ~$X") beats generic pitches.

Little tip: your first project will almost certainly come from someone you already know or someone one degree away. Tell the people around you that you freelance. This is uncomfortable for developers who prefer to let the work speak for itself — but the work can't speak if no one knows to look at it. A single sentence ("I'm taking on web development projects if you know anyone who needs a site or app built") sent to ten people in your network will produce more leads in a week than a month of optimizing your LinkedIn profile.

Working examples

Minimal SOW outline you can copy:

Project: 5-page marketing site for [Client]
Included: Home, About, Services, Contact, Blog index; contact form;
          mobile-responsive layout; deploy to client's hosting
Not included: Copywriting, photography, SEO audit, ongoing maintenance
Timeline: 3 weeks from signed scope and 50% deposit
Price: $3,200 fixed
Revisions: 2 rounds on design/content; further changes $95/hr
Payment: 50% upfront, 50% on launch; Net-15 on invoice

Rate floor math example:

Estimated build: 25 hours × $80/hr = $2,000
Non-billable overhead (+30%): $600
Floor price: $2,600 → quote $2,800–3,200 with buffer

Common patterns and when to use them

Project-based pricing — default for defined deliverables (sites, MVPs). Use when the client needs a fixed budget.

Hourly with cap — when requirements are fuzzy but trust is high. Use a not-to-exceed hour limit in writing.

Milestone payments — always for fixed price over $1,000. Use 50/50 or 33/33/33 tied to demo, staging, launch.

Network-first outreach — before paid platforms. Use in weeks 1–8 of freelancing; Upwork is backup, not primary.

Common mistakes

Waiting to have everything ready — the perfect portfolio, the LLC, the CRM. You can start with none of that. Take the project, deliver it, then set up the infrastructure the first project reveals you actually need.

Fixed-price projects with no scope document — this is how freelancers work for weeks beyond what they intended and get paid for the original estimate. Write down what you're building before you start.

Underpricing to get the first yes — there's a version of this that's strategic. There's a version that sets an anchor you'll fight for years. Know the difference and if you're pricing low, make clear it's an introductory rate.

Taking on every project that comes in — some projects are bad fits early. A client who pushes back on a scope document, won't pay any upfront, or can't describe what they want is a learning experience you'll pay for with your time. It's okay to pass.

Troubleshooting

Client won't pay — this is almost always a scope or communication failure before it's a payment failure. Written agreements, milestone payments, and a clear invoice cadence reduce this significantly. For the rare genuine non-payer, a collections letter from a lawyer (many will send one for a flat fee) moves most of them.

Project went way over scope — have the conversation early. "This is going beyond the original scope, here's what I'd need to continue" is much easier at hour 10 than at hour 50. The scope document is your reference point.

Not finding new clients between projects — this is the most common freelance developer problem. The fix is marketing during projects, not after. Whatever outreach you do — LinkedIn posts, referral asks, network check-ins — do it when you're busy, not when you're free.

Checklist

  • [ ] Work is linkable — GitHub, portfolio page, or both
  • [ ] SOW template drafted and ready to send
  • [ ] Rate set with a clear floor and reasoning
  • [ ] Ten people in your network know you're taking on projects
  • [ ] First outreach sent to at least three potential clients

Practice task

Write your SOW template this week. It should fit on one page. Describe a hypothetical five-page marketing website project: what's included (pages, forms, hosting setup), what's not included (copywriting, photography, SEO), timeline, price, and revision policy. The act of writing it forces you to think through the edges of a project before you're in one.

FAQ

Do I need an LLC?
Not to start. The legal and tax question is real and worth sorting out once you have consistent income — a few hours with an accountant and a simple business entity is worth it. But it's not a prerequisite for taking on a first project.

How do I handle taxes?
Set aside 25-30% of every invoice into a separate account. Pay quarterly estimated taxes if you're in the US (the IRS will tell you if you miss this). When in doubt, spend two hours with an accountant. This is a solved problem that developers overthink.

What do I do when I don't know how to build what the client wants?
Say so, estimate the additional time to learn and build it, and include that in the price. Or refer them to someone who does know. Promising something you're not sure you can deliver and figuring it out under pressure is how projects go wrong.

What to learn next

  • Salary negotiation basics — some of the same principles apply when freelancers re-price existing clients or respond to pushback on rates
  • Developer roadmap 2026 — if your skills feel like the limiting factor on the type of projects you can take
  • Resume tips for developers — the same principles for presenting your work apply to freelance portfolios
  • [Developer roadmap 2026](/career/developer-roadmap-2026)
  • [Resume tips for developers](/career/resume-for-developers)
  • [Salary negotiation basics for builders](/career/salary-negotiation-basics)

Takeaways

Freelancing as a developer doesn't require a business infrastructure before you start — it requires the ability to build something, a clear agreement about what you're building, and a way to get paid. Everything else is earned incrementally from those three things.

The two things that derail new freelancers most often: no written scope (leads to unpaid work), and waiting until everything is ready (leads to not starting). Fix those two and the rest is problems you can solve one at a time.

If you remember only one thing: write a scope document before you start every project. It doesn't matter if the client is a close friend or a big company. The document protects both of you, and the act of writing it forces clarity that the verbal conversation almost always leaves out.