You landed your first client. Congratulations — now the real work begins, and it has nothing to do with writing code or designing screens.
The gap between "we're interested" and "invoice paid" is where most freelancers bleed out. Scope creep, vague deliverables, awkward payment chases, clients disappearing after you delivered. I've watched talented developers lose thousands of dollars not because they couldn't build the thing, but because they never built the system around the thing.
Here's the complete operational kit.
The Contract Is Not a Formality — It's Your Scope Document
New freelancers treat contracts like legal boilerplate they copy from a Google search. That's wrong. Your contract is the single most important product spec you'll write.
A solid freelance contract for a dev project needs exactly these six clauses:
1. Scope definition with explicit exclusions. List what you will build. Then list what you will not build. "Responsive design for desktop and mobile" — does that include tablets? "API integration" — does that include the client's authentication layer? Write it down. Every ambiguous assumption costs you unpaid hours.
2. Revision rounds. "Two rounds of revisions" means two cycles of consolidated feedback, not two comments per week indefinitely. State this explicitly.
3. Payment schedule tied to milestones, not trust. A 30/40/30 split works: 30% upfront before any work starts, 40% at a defined midpoint deliverable, 30% on final delivery. Never start without the first payment clearing.
4. Kill fee. If the client cancels after work has begun, they owe you a percentage of the remaining contract value. Standard is 25-50%. Without this clause, a canceled project is pure loss.
5. IP transfer conditional on full payment. The code, designs, or deliverables remain your intellectual property until the final invoice is paid in full. This one clause eliminates most payment disputes.
6. Communication protocol. Specify your response time (e.g., 24 hours on business days), your preferred channel (email, not WhatsApp at midnight), and what constitutes an "urgent" request worth a rush fee.
Use a service like HelloSign, DocuSign, or the free tier of PandaDoc to send contracts for digital signature. Never start work on a verbal agreement.
The Onboarding Call That Prevents 80% of Problems
Before you write a single line of code, run a structured kickoff call. This is not a casual chat — it's a 45-60 minute working session with an agenda you send 24 hours in advance.
Your kickoff agenda:
- Project goals (10 min): What does success look like in 90 days? Not features — business outcomes. "Reduce checkout abandonment by 15%" is better than "rebuild the cart page."
- Stakeholders and decision-makers (5 min): Who approves work? Who provides feedback? Establish one primary contact. Multiple feedback channels are how scopes explode.
- Technical context (15 min): Existing stack, access credentials needed, third-party integrations, hosting environment. Document everything in a shared doc immediately.
- Timeline and availability (10 min): When can they review? Are there blackout periods (vacations, product launches)? Agreed delivery dates go into the contract.
- Communication norms (5 min): Reiterate what's in the contract. Make it conversational, not confrontational.
Record the call (with consent) and share a written summary within 24 hours. This summary becomes your project north star when "that's not what I asked for" conversations happen later.
The Client Portal: Your Anti-Chaos Infrastructure
Sending deliverables over email is how projects lose track of context, version history, and accountability. Even for a small engagement, set up a minimal client portal on day one.
A free Notion workspace with three pages covers 90% of use cases:
- Project brief (scope, timeline, contacts)
- Deliverables log (what was sent, when, current status)
- Feedback tracker (open items, decisions made, who owns what)
Share the link in your kickoff summary. Update it after every significant interaction. When a client says "I never approved that change," you have a timestamped record.
For projects over $3k, consider a lightweight PM tool like Linear (for dev work) or a shared Trello board. The tool matters less than the habit of documenting decisions in a single place.
Invoicing Without the Awkward Chase
Late payment is the freelancer tax nobody talks about. The fix is process, not assertiveness.
Send invoices through a tool that sends automatic reminders: Wave (free), Bonsai, or HoneyBook. Set reminders at 3 days before due, on the due date, and 3 days after. The automation removes the emotional charge from payment follow-up — it's just the system doing its job.
Your invoice should include:
- Invoice number and date
- Project name and milestone description
- Payment terms (Net 7 or Net 14 — not Net 30 for freelancers)
- Accepted payment methods with specific instructions
- Late fee clause (1.5% monthly on overdue balances)
Send the invoice the moment you hit a milestone, not at the end of the month. Delayed invoicing signals that payment isn't a priority to you — which tells the client it doesn't need to be a priority for them.
Scope Creep: The Tax You're Voluntarily Paying
Scope creep is not a client problem. It's a pricing and process problem. Clients ask for more because the system allows it for free.
When a request falls outside the contract, you don't say no — you say yes with a price:
"That's doable. It's outside the current scope, so I'll put together a change order. Should be about X hours at my standard rate. Want me to draft it?"
Keep a change order template ready. It should take you five minutes to fill out. It includes: description of the additional work, estimated hours, rate, revised timeline impact, and a signature line.
The client who respects your process will sign it. The client who fights it is telling you something important about every future engagement.
One red flag to watch early: clients who ask for "just a quick thing" before the contract is signed. That behavior scales.
Retention Starts at Offboarding
The clients who hire you again — and refer you to others — aren't just satisfied with the work. They feel handled. Offboarding is your last impression and your next sale.
At project close:
- Deliver a final handoff document: what was built, how it works, credentials, known limitations
- Schedule a 15-minute close call to walk through the deliverable
- Send a brief follow-up email 30 days later checking in on how things are going
- Ask for a testimonial at the 30-day mark, not immediately at delivery
That follow-up email costs you ten minutes and has a direct conversion rate into repeat work. Most freelancers skip it entirely.
The system above took me several engagements and a few painful lessons to assemble. I compiled everything into a practical guide: First Client Onboarding & Contracts Kit — templates, scripts, and the full workflow ready to use on your next project.
The work is the easy part. Build the system once, and everything around the work stops being painful.