Free template · 2025

Freelance developer contract for India.

No contract means the developer owns your code. Here's everything your freelance contract needs — the IP clause, payment milestones, and the tax rule most founders don't know about.

Quick answer

A freelance developer contract in India must include: scope of work, milestone-based payment, explicit IP assignment (without it, the developer owns your code), TDS withholding rules, confidentiality, term and termination, and Indian governing law. Most founders skip the IP clause — and discover during diligence that they don't legally own their product.

Generate your contract free →

What goes wrong without a proper freelance developer contract?

Developer owns your product
Indian copyright law defaults to creator ownership. No written IP assignment = the developer owns the code they wrote for you. This blocks fundraising.
Scope dispute mid-project
Verbal agreement on 'what we're building' is remembered differently by both sides two months in. Written scope with an acceptance process prevents this entirely.
Tax notice for missing TDS
Companies must deduct TDS on freelancer payments above ₹30,000. Most first-time founders don't know this. The Income Tax department does.

What to include

What must every freelance developer contract include?

1
Exact scope of work
List every deliverable. Not 'build a mobile app' — but 'build iOS and Android apps with the features listed in Appendix A, to the acceptance criteria agreed in writing.' Vague scope is the #1 cause of freelance disputes.
2
IP assignment
Under Indian copyright law, the developer owns the code they write — not you — unless they assign it in writing. This is the most important clause. Add: "All code, designs, and deliverables created under this agreement are assigned to [Company] upon full payment." Without this, you don't actually own your product.
3
Payment terms and milestones
Break payment into milestones tied to deliverables. Example: 30% on contract signing, 40% on staging deployment, 30% on final delivery. This protects you (don't pay everything upfront) and the developer (don't wait until the end for everything).
4
What counts as acceptance
Define how you'll decide the work is 'done.' A review period (e.g., 7 days to raise issues), a list of acceptance criteria, and what happens if you don't respond. Without this, disputes about 'is this complete?' are unresolvable.
5
TDS clause
Under Indian tax law, you must deduct TDS (typically 10% under Section 194J) on payments to developers if the payment exceeds ₹30,000 per contract. Document this in the agreement so both sides know what to expect.
6
Confidentiality
The developer sees your product, codebase, and sometimes your customers. A confidentiality clause that survives the engagement (2+ years) protects your business information.
7
What happens mid-project if things go wrong
Cover: what if the developer goes quiet? What if you need to cancel? Who owns work-in-progress code? A termination clause with notice (7–30 days) and clear IP transfer on payment makes exits clean.

What does a simple milestone payment structure look like?

This works for most projects. Adjust the percentages based on project size and trust.

MilestonePaymentWhy
Contract signed30%Commits both sides to the engagement
Staging / beta delivery40%Rewards real progress
Final delivery + acceptance30%Incentivizes quality completion

What to avoid

What mistakes do founders make with freelance dev contracts?

✗
No IP clause — the developer owns your code
This happens constantly. A startup pays a developer ₹3 lakhs to build their MVP, no written agreement, and the developer technically owns all that code. During investor diligence, the founder can't demonstrate clean title to the product. This is fixable — but only with a signed agreement (or a retroactive assignment).
✗
Paying 100% upfront
Once paid in full, the developer has significantly less incentive to fix bugs, meet timelines, or respond to change requests. Use milestone-based payments tied to deliverables. This isn't distrust — it's standard professional practice.
✗
Vague scope, then scope creep, then dispute
"Build a marketplace app" expands endlessly. Define scope in writing before starting. Create a process for handling changes (a simple email confirmation is enough). When scope grows without documented agreement on payment, both sides end up resentful.
✗
Forgetting TDS, then getting a tax notice
Many first-time founders don't know about TDS on contractor payments. The Income Tax department does. Deduct, deposit, and issue Form 16A to the developer. It's the developer's money — it's credited to their tax account. Not doing it triggers penalties for you.
✗
No acceptance criteria — and then endless revision rounds
If the contract says 'work is complete when the client is satisfied,' the client is never satisfied and the developer never gets paid. Define acceptance criteria upfront. A time-bound review period (7–14 days) with specific criteria is fair to both sides.
✗
Using a US freelance contract template
US templates specify US jurisdiction, US tax rules, and US legal standards. For an Indian startup hiring an Indian developer, these are useless. Always use Indian-law contracts with Indian city jurisdiction.

Related guides

Contractor agreement→Consultant NDA→Mutual NDA India→

FAQ

Common questions

Yes. It's a service contract governed by the Indian Contract Act, 1872. Once signed by both parties, it's binding. It's also your primary document for IP ownership, tax compliance (TDS), and dispute resolution.

For most freelance development engagements — mobile apps, web apps, dashboards, integrations — yes. A signed contract with IP assignment, scope definition, payment terms, and TDS clause covers the key legal and commercial risks. For complex, multi-year projects or large payments, a legal review is worth it.

The developer does. Under the Indian Copyright Act, the creator of original work owns it unless there's a written assignment. No contract = developer owns your product.

Neither extreme. Milestone-based payments tied to deliverables work best for both parties. A common structure: 30% on signing, 40% on staging delivery, 30% on final acceptance. Adjust based on project size and relationship.

Section 194J applies to professional/technical services — 10% TDS. Section 194C applies to work contracts — 1-2% TDS. Which applies depends on the nature of work. When in doubt, 10% under 194J is the safer approach. Consult your CA for specific guidance.

Your contract should include a delivery timeline and specify what happens on delays — typically, you can terminate and get a refund of unearned amounts, or you can claim damages if delay causes measurable loss. Without a contract, proving loss and enforcing it is much harder.

For foreign freelancers, different tax rules apply (Form 15CB/15CA for payments above certain thresholds) and currency regulations under FEMA may be relevant. You'll need a cross-border contract with appropriate governing law clauses.

Open-source and third-party components have their own licenses. Your contract should require the developer to disclose all third-party components used and ensure they're properly licensed for commercial use. This is especially important for software you'll sell or fund-raise on.

Last updated:

Freelance contract ready in 2 minutes.

Firmly generates freelance developer contracts with IP assignment, milestone payments, TDS clauses, and Indian jurisdiction built in.

Try it free →