"They built everything we asked for. But we don't own any of it."
Last month, a fintech founder reached out after burning $140,000 on an agency build. The app launched on time. It worked. But when she tried to raise her seed round, her legal team flagged the development contract: under the IP ownership clause, copyright didn't transfer until all invoices were paid — and there was a disputed change request still outstanding. Technically, she'd raised money on a product she didn't own.
This is the third time I've heard a version of this story in the past six months. And honestly? It's not her fault. The contract looked fine to her. The agency is professional. No one did anything wrong — except that no one technical read the contract before she signed it.
That's exactly what a fractional CTO is for.
The Contract That Almost Killed Her Round
Here's what the clause actually said: "Intellectual property in all deliverables shall vest in the Client upon receipt of all outstanding invoices and final acceptance of the deliverables."
Sounds reasonable, right? The problem is "all outstanding invoices." The agency had issued a change request for $8,000 worth of work the founder thought was in scope. That dispute was never resolved. So legally, the agency still owned the product.
This happens more than you'd think. I've seen it play out in three distinct ways:
Pattern 1 — The Disputed Invoice: A change request is contested. The invoice remains open. IP transfer is blocked until it's resolved. Founders find this out during due diligence, not before.
Pattern 2 — The Proprietary Lock-In: The agency builds on custom tooling only they support. The product works, but no other developer can maintain it without relearning a proprietary system. Leaving the agency means rebuilding from scratch.
Pattern 3 — The Missing Acceptance Criteria: The contract says the agency will "complete the application as described in the specification." No definition of done. No test criteria. The agency says it's done. The founder says it isn't. There's no contract to resolve it.
In all three cases, the founder paid full price. They just didn't get what they thought they were buying.
About to Sign an Agency Contract?
Don't sign it without a technical review first. A 30-minute call can save you months of legal headaches and tens of thousands in rework costs.
Get a Contract Review →What Bad Contracts Actually Look Like
I've reviewed dozens of agency contracts in the last two years. The dangerous ones don't look dangerous — that's the problem. They look professional. They have structured payment terms, professional formatting, and sensible milestone language.
The risk is buried in the technical clauses that most founders don't know to read:
IP Ownership — The Biggest Risk
The question isn't whether there's an IP clause. Every contract has one. The question is when ownership transfers. "On receipt of all payments" is bad. "On receipt of each milestone payment" is good. "As work is created (work for hire)" is best.
I've seen contracts where the IP transfer was conditional on acceptance criteria that were never defined. The agency could dispute acceptance indefinitely — and technically retain ownership the whole time.
Typical cost to rebuild or legally contest ownership when an IP clause is triggered against a founder
Acceptance Criteria — The Silent Trap
An agency contract that doesn't define acceptance criteria is a contract without a finish line. When the founder says "this isn't done," the agency says "yes it is." And both parties are technically correct, because no one defined what "done" meant.
What acceptance criteria should look like: "User authentication is complete when all test cases in Appendix B pass and load time is under 2 seconds on a 4G connection." Not: "The feature meets the requirements described in the brief."
Technology Lock-In — The Slow Burn
This one doesn't bite immediately. The product launches, it works, everyone's happy. Then six months later, the founder wants to add a feature. They hire a developer. The developer looks at the codebase and says: "I can't work with this. It's built on a custom framework I've never seen."
The agency built on proprietary tooling. The contract never required standard technology choices. Now the founder is stuck — either go back to the original agency at whatever rate they choose, or pay to rebuild. I've seen this cost $80,000 to fix.
What We Review Before Any Client Signs
When a client brings us an agency contract to review, here's what we actually look at — in order of importance:
1. IP ownership timing. When does ownership transfer? What triggers the transfer? What could block it? If it's "on receipt of all payments," we negotiate to milestone-based transfer before they sign.
2. Acceptance criteria completeness. Is there an appendix with specific, testable criteria for each deliverable? If not, we require one before the contract is finalised. We write the criteria ourselves if needed.
3. Technology stack specification. What tools, frameworks, and platforms will the agency use? Is this specified in a technical appendix? If the agency is using anything proprietary or unusual, we ask why. If they won't tell us, we advise against signing.
4. Handover requirements. What does the client receive at the end? Source code — yes, but does it include version history? Documentation? Credentials for all third-party accounts? A transition period? Contracts that are vague on handover almost always result in incomplete handovers.
5. Warranty period and defect definition. How long is the warranty? What counts as a "defect"? A 90-day warranty that only covers crashes is almost worthless. We push for 90 days covering anything that doesn't meet the accepted specification.
Time investment: A thorough contract review takes 4–8 hours of technical reading and negotiation. That's roughly $2,000–$4,000 in fractional CTO time. Compared to the average cost of a bad contract dispute ($50K+), the ROI is obvious.
What Happened With the Fintech Founder
We got involved two days after she flagged the issue to her investors. Here's what we found:
The disputed change request was $8,000. The agency wasn't being malicious — they genuinely believed the work was out of scope. The founder genuinely believed it was in scope. Neither of them had documented it clearly enough at the time.
We reviewed the original specification, the change request, and the contract. Our read: the work was ambiguous enough that it could go either way. The agency had a legitimate case; so did the founder.
Rather than pursue a legal dispute (which would have cost far more than $8,000 and delayed the funding round by months), we negotiated a settlement: the founder paid $4,000, the agency agreed to an immediate IP transfer, and both parties signed a deed of assignment to clean up the record.
The founder's round closed three weeks later. But she lost three weeks of momentum and paid $4,000 she shouldn't have had to pay — all because no one reviewed the contract before she signed it.
Already Signed? Let's Look at It.
If you're mid-project and something feels off — scope disputes, IP concerns, a handover that's going wrong — we can review what you've got and tell you where you stand.
Talk Through Your Situation →30 minutes • No obligation • Honest feedback
Your Options When Working with Agencies
Here's how I see it when founders are considering agency work:
Option 1: Review the contract yourself. You can do this if you know what to look for. The IP ownership clause, acceptance criteria, technology stack specification, and handover requirements are the four sections that matter most. If you're not sure what you're reading, get help.
Option 2: Hire us for a contract review only. We'll review the contract, flag every risk, suggest specific language changes, and attend one negotiation call with the agency's technical lead. This is typically $2,500–$4,000 and takes 3–5 business days. It's the best money a founder can spend before a $100K+ agency engagement.
Option 3: Hire us as your ongoing fractional CTO. At $10K–$15K per month, we handle everything: contract review, milestone oversight, code quality reviews, technical communication with the agency, and handover management. For projects over $150K, this pays for itself in avoided disputes and rework alone.
What's not an option — at least not if you want to keep control of your product — is signing an agency contract without anyone technical reading it first. I've seen what happens when founders find out after the fact. It's expensive, it's stressful, and it's almost always avoidable.
Don't Sign Until Someone Technical Has Read It
If you're evaluating an agency or about to sign a development contract, let's talk. I'll tell you exactly what I see and what I'd change — no fluff, no obligation.
Book a Contract Review Call →30 minutes • No obligation • Honest feedback