Red Flags in IT and Development Contracts

A Fort Walton Beach developer signed a contract to build a custom inventory system. The contract said work product would be "licensed to the client." After the project ended, the developer decided the software was worth licensing to other businesses. The client had no recourse—the contract said "licensed," not "owned."

The client had paid $120,000 for software they couldn't modify, couldn't sell, and couldn't prevent others from using.

That's not a contract problem. That's a contract design problem.

The contract problem

IT contracts are written by IT companies. They reflect what IT companies want. Your signature means you agree to their terms, whatever they are.

Most SMB owners don't read contracts closely. Many sign what they're given. Some discover problems years later when they try to leave or modify something.

The goal isn't to find a perfect contract. It's to identify clauses that create serious problems—and decide if you can live with them.

Red flags in MSP and service contracts

Auto-renewal without adequate notice

Watch for: Contracts that renew automatically unless cancelled within a narrow window (30-60 days), with renewal happening months before the notice deadline.

The problem: You forget to cancel. You're locked for another year. Maybe two.

Ask: When does it renew? How far in advance do I need to cancel? What notice will you send?

Termination fees that exceed actual costs

Watch for: Termination fees that seem arbitrary—"$5,000 early termination fee" with no explanation of what that covers.

The problem: Leaving costs thousands even if they do nothing. This creates artificial lock-in.

Ask: What does this fee cover? Is it negotiable? What would actual costs be if we left early?

Liability caps that don't cover your exposure

Watch for: Liability caps equal to your monthly fees or annual contract value.

The problem: If their mistake costs you $100,000 in damages and their liability cap is $20,000, you're out $80,000.

Ask: What's the liability cap? Does it cover consequential damages? Can we increase coverage?

"We reserve the right to update terms"

Watch for: Clauses that let the vendor change contract terms unilaterally.

The problem: They can change pricing, scope, or terms after you sign.

Ask: Can you change terms after signing? What's the process? Can we terminate if changes are unacceptable?

Unclear ownership of your data

Watch for: Contracts that say data is "managed by" or "stored by" the vendor without clear ownership language.

The problem: You might not legally own your own data. Getting it out might be complicated.

Ask: Who owns the data? What happens to it if we cancel? Can we export everything?

No clear exit process

Watch for: Contracts that describe what happens during the term but are silent on how to leave.

The problem: When you want out, you don't know the process. The vendor can make it difficult.

Ask: What's the exit process? What will I receive when I leave? How long does it take?

Red flags in development contracts

"Work for hire" vs. ownership confusion

Watch for: Contracts that say work is "work for hire" or "licensed to client" without clear ownership transfer language.

The problem: You paid for it, but you don't own it. You can't modify it, resell it, or prevent them from using it elsewhere.

Ask: Who owns the code? Do we get the source code? Can we modify it? Can you use it elsewhere?

Unlimited revision clauses

Watch for: Contracts that promise "unlimited revisions" or "we'll keep working until you're happy."

The problem: No defined scope. Projects that never end. Disputes over what's included.

Ask: What's the scope? How many revision rounds are included? What happens if we exceed that?

Vague acceptance criteria

Watch for: Contracts that define "completion" vaguely—"client satisfaction," "commercially reasonable," "to the satisfaction of the client."

The problem: The developer thinks they're done. You don't. There's no objective standard to measure against.

Ask: What exactly constitutes acceptance? How do we test it? What's the process if we don't accept?

No warranty or limited warranty

Watch for: Contracts with no warranty, or warranties that expire quickly (30 days).

The problem: Things break. If there's no warranty, you pay to fix problems that existed at delivery.

Ask: What's the warranty period? What does it cover? What happens after warranty expires?

No provisions for code escrow or source access

Watch for: Custom software with no plan for what happens if the developer disappears.

The problem: The developer stops supporting the software. You have a system nobody can maintain.

Ask: What happens to the code if you close or can't continue? Is there escrow? Do we get source code?

Red flags that appear in both

Restrictive non-competes

Watch for: Contracts that restrict you from hiring their employees or working with their competitors.

The problem: You might not be able to hire the best person for your internal IT role.

Ask: Can we hire your employees? Can we work with other vendors in your space?

Mandatory arbitration in their location

Watch for: Arbitration clauses that require proceedings in a specific city—usually theirs.

The problem: If you have a serious dispute, you have to enforce it where they are, not where you are.

Ask: Where are disputes resolved? Is there flexibility?

Assignment clauses without consent

Watch for: Clauses that let the vendor assign the contract to another party without your approval.

The problem: You sign with Company A. Six months later, Company B owns the contract. You have no say.

Ask: Can you assign this contract? Would we be notified? Could we object?

NDAs that last forever

Watch for: Non-disclosure agreements with no expiration.

The problem: You can never discuss what went wrong, even years later.

Ask: How long does confidentiality last?

What to do when you find red flags

Don't panic. Every contract has some unfavorable terms. The question is whether the problems are problems you can live with.

Prioritize. Some clauses are worse than others. A liability cap that's slightly low is different from a clause that says they own everything you create.

Negotiate. Most contracts are negotiable, especially for larger deals. If they won't budge on a critical issue, that's information.

Get it in writing. If they agree to modify something verbally, get it in writing in the contract. Verbal modifications aren't worth the paper they're printed on.

Walk away if necessary. Sometimes the best decision is to not sign. A contract with too many problems isn't worth the relationship.

What it costs

Having an attorney review: $500-$3,000 for a standard IT contract. More for complex development deals.

Not reviewing: Unknown but potentially very large. A bad contract can cost far more than a legal review.

Questions to copy/paste

Ask about any concerning clause:

• "Can you explain what this clause means in practice?"
• "Has this clause ever caused problems with a client?"
• "Is this negotiable?"
• "What happens to us if this clause is enforced?"
• "Can we add specific language to address our concern?"

Ask before signing anything:

• Who owns the work product when you're done?
• What's the exit process and what does it cost?
• What's your liability cap, and does it cover our damages?
• Can you change terms after we sign?
• What happens to our data if you close or we leave?

The bottom line

Every contract favors the party that wrote it. That's not malicious—it's just business.

Your job isn't to find a perfect contract. It's to find one whose problems you understand and can accept.

Read everything. Ask questions. Get help when it's significant. And remember: a salesperson's promise means nothing. The contract is the agreement.