Dev Contract Gotchas: 7 Clauses That Cost Founders Millions

You're excited. You found a dev agency that can build your product. The price seems reasonable. You're ready to sign. Then you flip to page 7 of the contract, buried in the terms and conditions, and realize: the developer owns your code. Not you. Them.

Software development contracts are where fortunes are made and lost. I've seen founders sign agreements that locked them into paying forever, handed over IP rights they didn't know they'd lost, and discovered exit costs that made it impossible to switch vendors. Every clause has a reason—and most of them favor the developer, not you.

I'm going to walk you through the seven contract gotchas that matter most. You don't need to be a lawyer to understand these. You just need to know what to look for—and what to push back on.

IP Ownership Buried in Fine Print

You get the contract. You skim it. You see the fee ($45,000) and the timeline (3 months) and you're ready to sign. Then your lawyer—who you hired at the last minute because you had a bad feeling—points to a clause on page 8:

What just happened: You paid for custom code but don't own it. The developer owns it. You can't sell the product. You can't transfer the code to a new developer. You can't even modify it without permission. You've built a business on someone else's intellectual property.

What to demand instead: Full IP transfer. "All custom software, code, documentation, and work product developed for Client shall be owned exclusively and in perpetuity by Client." No exceptions. No loopholes.

Reality check: The developer might have off-the-shelf frameworks and libraries they use (React, Node.js, databases). They keep ownership of those. But anything custom-built for your product belongs to you.

"Time and Materials" with No Cap

The contract says "time and materials." You budget for $30,000. The developer charges for every hour worked, every tool used, every revision. At the end, the bill is $78,000. You have no recourse because the contract has no spend cap.

Why this matters: "Time and materials" is blank-check spending. The developer has no incentive to be efficient. They make more money the longer the project takes. Scope creep becomes your problem to pay for. You asked for "some revisions" and suddenly you're on revision 47, each one billable.

This model only works if you have absolute trust and extreme clarity on what "done" means. Most founders don't have either. You end up paying far more than you expected for far less than you hoped.

What to demand: A fixed-price contract with clear scope. If you use time and materials, set a hard cap (e.g., "Not to exceed $40,000 without written approval") and require weekly billing transparency.

Change Orders with Hidden Markups

The scope is locked in. But during development, you realize you need a feature you didn't anticipate. You ask the developer, "Can you add search functionality?" They say yes. They issue a change order for $4,500.

Later, you find out internally the developer estimated it would take 20 hours at $75/hour. That's $1,500 of work. But they marked it up 200% and called it a "change order fee." The contract allows unlimited markups. You're stuck.

Why this matters: Developers use change orders to juice revenue. They know you're committed to the project and can't easily walk away. You need that feature. They know it. They charge accordingly. Without markup limits in the contract, you have no leverage.

What to demand: Define change order pricing upfront. "Change orders will be quoted at the same hourly rate as base scope work (or at a rate not to exceed X%)." Require written change orders before work starts, not invoiced after.

No Source Code Escrow

You've paid $45,000 for a custom application. Development is finished. Everything works. Then the developer goes silent. They stop responding to emails. No warning. You're left with a working app but no source code. You don't own it. You can't modify it. You can't fix it. You're locked out.

Or worse: the developer's business fails. They go bankrupt. The code is never transferred to you because it wasn't in the contract. You've lost everything.

Why this matters: Without source code escrow, you're dependent on the developer forever. If the relationship breaks, you're stuck. If they disappear, you're stuck. The code is a hostage held by someone else.

What to demand: "Developer shall provide Client with complete source code, documentation, and all development tools and credentials. Code shall be placed in escrow and transferred to Client upon project completion and final payment."

Non-Compete That Blocks Your Own Hiring

You're unhappy with the developer. The project is nearly done but quality is terrible. You want to hire someone better to finish and fix things. You check the contract. There's a non-compete clause:

What just happened: You're locked in. You can't hire the developer's team members to complete the work. You can't even hire them for other projects in your company. You're prevented from moving people to better roles. The developer essentially controls your hiring.

Why this matters: Non-competes are supposed to protect the developer's business. They're not supposed to prevent you from building your own team. This clause is about control, not competition. It's predatory.

What to demand: Delete this clause entirely. If the developer insists on non-compete protection, limit it: "Developer may not use Client's proprietary information to compete with Client's business for 12 months." Not "You can't hire our people."

Auto-Renewal with Punitive Exit Fees

The contract has a 12-month term. At the end, you don't renew. Or you forget to cancel. The contract auto-renews for another 12 months. You're charged $12,000. Buried in the fine print is a 30-day cancellation requirement. You missed it. You owe them for another year of work you didn't authorize.

Or worse: you terminate early for poor performance, and there's a 50% penalty on the remaining contract value. You want out. They won't let you out without paying.

Why this matters: Auto-renewal is a trap. It assumes you'll remember to cancel on an arbitrary date. Exit fees are penalties for leaving. Together, they lock you in financially. You can't leave even if you want to.

What to demand: No auto-renewal. Require explicit written consent to renew. If there's an early termination fee, cap it: "Termination fees shall not exceed one month of service fees."

Vague Acceptance Criteria

The contract says the project is complete when "deliverables meet Client's satisfaction." But "satisfaction" isn't defined. The developer delivers something. You test it. It has bugs. You reject it. The developer says, "It's done. It's your problem now." You're in a dispute with no way to resolve it because the contract is vague.

You haven't paid final invoice. The developer is threatening to stop support. You're stuck in a standoff.

Why this matters: Acceptance criteria are the definition of "done." Without clarity, disputes are inevitable. Both sides think they're right. The contract gives you no way to prove otherwise. You end up paying for incomplete work or fighting endlessly.

What to demand: Specific, measurable acceptance criteria. "Project is complete when: (1) All unit tests pass, (2) Code review requirements are met, (3) All documented features work as specified, (4) No critical bugs remain unfixed." Make it objective, not subjective.

Your Contract Negotiation Checklist

Also check what you're actually paying for

Even with clean contracts, bad quotes hide money. Our Quote Checker helps you normalize scope, identify hidden fees, and compare apples-to-apples across developer proposals.

Related Reading

Contracts are where the developer protects themselves at your expense. They've done this a hundred times. They've seen loopholes. They know how to bury dangerous language in "standard" terms.

You don't need a lawyer to understand these seven gotchas. You just need to know they exist and demand better. IP ownership belongs to you. Costs should be capped. Exit should be clean. Source code should be yours. These are non-negotiable.

Before you sign anything, check that contract against this list. If you see one of these gotchas, push back. If the developer won't budge, that's a red flag about who you're working with. The best partners are willing to negotiate fairness.