Software Licensing Disputes: When Code Ownership Gets Messy

A startup founder in Santa Monica called me last year with a problem that’s becoming painfully common along Silicon Beach. His company had hired a freelance developer to build the core backend of their SaaS product. No written IP assignment agreement. The developer had been paid well, the product launched, and six months later the developer forked the code and started a competing service from a co-working space in Playa Vista.

The founder assumed he owned the code because he paid for it. He was wrong.

I’m Evan Dotta, a partner at Mister Wolf, P.C. We represent tech companies, software developers, and creative businesses in intellectual property disputes across Los Angeles. Code ownership fights are some of the messiest IP cases I handle, and they almost always trace back to the same problem: nobody put the deal in writing before a single line of code was written.

I’ll walk you through who actually owns software under federal and California law, how licensing disputes escalate, and what you can do right now to protect yourself.

Who Owns Software Code Under Copyright Law?

The Default Rule

Copyright protection for software is automatic under 17 U.S.C. Section 102. The moment a developer writes original code and saves it to a file, copyright attaches. No registration required. No notice required. The code belongs to the person who wrote it.

That’s the default. And for most small companies and startups, it’s the rule that gets them in trouble.

If your employee writes code as part of their job duties, the code is a “work made for hire” under 17 U.S.C. Section 101, and your company owns the copyright automatically. If an independent contractor writes the code, the default flips. The contractor owns it unless one of two things happens:

1. The work falls into one of nine specific categories listed in the Copyright Act AND there’s a written agreement signed by both parties designating it as a work made for hire, OR
2. The contractor has assigned the copyright to you in a written, signed agreement

Software doesn’t fit neatly into any of the nine work-for-hire categories for independent contractors. Those categories include contributions to collective works, parts of motion pictures, and translations. So option one almost never applies to code. You need a written assignment.

The Silicon Beach Problem

Los Angeles’s tech corridor, Santa Monica, Venice, Marina del Rey, Playa Vista, El Segundo, has a contractor problem. Companies at every stage rely heavily on freelance and contract developers. Pre-seed startups in WeWork spaces and Series B companies in the Brickyard all work with contractors. According to the Bureau of Labor Statistics, the LA metro area employed over 110,000 software developers in 2024, and a significant percentage work as independent contractors or through staffing agencies.

The combination of California’s ban on non-compete agreements (Business and Professions Code Section 16600) and the gig-heavy structure of the LA tech scene means developers move between companies constantly. If the IP assignments aren’t locked down, the code goes with them.

Does Your Developer Agreement Actually Transfer Ownership?

Assignment vs. License

This distinction destroys companies. An assignment transfers ownership. A license grants permission to use, but the other party keeps ownership.

If your agreement says “Developer grants Company a perpetual, worldwide license to use the software,” you don’t own the code. The developer does. They’ve given you permission to use it. They can license the same code to your competitors. They can sell it. They can build on it.

An assignment says something like “Developer hereby assigns to Company all right, title, and interest in and to the Work, including all copyrights.” After that, the developer has no more rights to the code than a stranger does.

I’ve reviewed hundreds of developer agreements for LA tech companies. At least a third use licensing language when the company intended an assignment. The developer’s template said “license,” the founder didn’t read it, and nobody caught it until a dispute.

Pull out every developer agreement your company has signed in the last three years. Search for the word “assign.” If you don’t find it, you may not own the code. Get this reviewed by an IP attorney before a dispute forces the issue.

What Happens When Open Source Compliance Goes Wrong?

GPL and Copyleft Obligations

Open source software is not free-as-in-do-whatever-you-want. Every license comes with conditions, and some can blow up your entire proprietary codebase.

The GNU General Public License (GPL) is the most aggressive of the major open source licenses. If you incorporate GPL-licensed code and distribute it, the GPL requires you to release your entire work under the GPL too. That means open-sourcing your code. For a SaaS company built on proprietary code, that’s an existential threat.

The Software Freedom Conservancy and the Free Software Foundation have actively enforced GPL violations. In 2024, the Conservancy’s ongoing enforcement efforts resulted in multiple compliance settlements with companies that had incorporated GPL code into proprietary products without releasing their source.

How LA Startups Get Into Trouble

The pattern I see most often: a developer pulls in an open source library to solve a problem. Database connector, parsing tool, UI component, it doesn’t matter. The developer knows it’s open source and assumes “free to use.” They don’t check the license. It’s GPL. It gets baked in. The company raises a Series A. During due diligence, an investor’s legal team runs a software composition analysis and finds the GPL dependency.

The company now has three options: rip out the code and rebuild, negotiate a commercial license from the author (if they’ll do it), or disclose the issue and hope the investor doesn’t walk. Often they do.

The Linux Foundation’s 2023 survey found that 96% of codebases contained open source components, and 76% had at least one license conflict. This isn’t a theoretical risk. It’s near-certain if nobody is paying attention.

Run a software composition analysis on your codebase today. Tools like FOSSA, Snyk, and Black Duck scan your code and identify every open source component and its license. If you find GPL code in a proprietary product, address it with a Los Angeles intellectual property lawyer before your next funding round.

Can Your Employer Claim Ownership of Code You Wrote on Your Own Time?

California Labor Code Section 2870

California gives employees stronger protection for personal inventions than almost any other state. Labor Code Section 2870 says that any invention an employee develops entirely on their own time, without using the employer’s equipment, supplies, or trade secret information, belongs to the employee if:

1. The invention doesn’t relate to the employer’s business or actual/demonstrably anticipated research and development, AND
2. The invention doesn’t result from any work the employee performed for the employer

This protection is mandatory. An employer can’t contract around it. If your employment agreement includes an invention assignment clause (and most tech company agreements do), California law requires the agreement to include a notice of Section 2870’s protections. Any assignment provision that doesn’t carve out Section 2870 inventions is unenforceable to that extent.

The Gray Zone

The problem is the “relates to” test. If you’re a backend engineer at an ad-tech company and you build a side project involving ad targeting, your employer has an argument that it relates to their business. Even if you used your own laptop and worked from home.

I’ve handled disputes where the line was genuinely unclear. An engineer at a health tech startup built a fitness tracking app on his own time with personal devices. His employer made healthcare software. The employer claimed the fitness app related to their “health technology” business. We disagreed. The fitness app tracked exercise metrics. Their product managed insurance claims. Different industries, different tech, different users.

The case settled, but both sides spent serious money. If you’re working on a side project as an employee, keep records showing you used only personal resources and that it’s distinct from your employer’s business.

What Are the Most Common SaaS Licensing Disputes?

Scope of Use Fights

SaaS licensing disputes usually start with ambiguity in the agreement. The licensee thinks they can do X. The licensor thinks the license only covers Y. Nobody reads it until there’s a problem.

Common flashpoints include:

User count overages. The license allows 50 seats. The company gives access to 200 employees. The SaaS provider audits, discovers the overage, and demands back-payment at full list price per seat. These disputes can involve six or seven figures for enterprise software.

Derivative works. A licensee builds custom integrations, APIs, or extensions on top of the licensed software. Who owns them? If the agreement is silent, copyright law says the person who created the derivative work owns the new expression. But they need a license to the underlying work to use it. That creates messy co-dependency.

Data ownership. SaaS platforms process customer data. If the relationship ends, who owns the data and the analytics derived from it? The agreement should answer this. Often it doesn’t.

Non-compete restrictions. Some SaaS licenses restrict the licensee from using competing products. In California, these face scrutiny under Section 16600’s broad prohibition on restraints of trade. A license that prevents a business from switching providers may be unenforceable.

The Litigation Path

SaaS licensing disputes in LA typically land in the U.S. District Court for the Central District of California if there’s a federal question (like a copyright claim). Contract-only disputes go to Los Angeles Superior Court.

The Central District has judges with real experience in software disputes. Judge George Wu, for example, has handled multiple software licensing cases. The court understands the technology, though many SaaS disputes get sent to arbitration; there’s usually an arbitration clause buried in the terms of service.

How Do You Protect Code Ownership Before a Dispute Starts?

For Companies Hiring Developers

The fix is straightforward. It just takes discipline.

Written IP assignment agreements for every contractor. Not a license. An assignment. Transfer all intellectual property rights in the work product, including copyrights, patents, trade secrets, and related rights. Have them sign before they write code.

Employment agreements with invention assignment clauses. Include a broad invention assignment covering all work created during employment. Include the required Section 2870 notice. Make it a condition of employment.

Contributor license agreements for open source. If your engineers contribute to open source, make sure they’re not accidentally assigning or licensing your proprietary code. A CLA clarifies IP rights in contributions.

Code audit and documentation. Keep clear records of who wrote what, when, and under what agreement. Use Git religiously. If a dispute comes up, your commit history is evidence.

Open source policy. Create a written policy on which open source licenses are approved. GPL and AGPL require executive approval. MIT, Apache 2.0, and BSD are generally safe for proprietary use but still have conditions.

For Developers and Freelancers

Read what you’re signing. If a client’s agreement includes a broad IP assignment, you’re giving up ownership of everything you create. That may be fine if the compensation reflects it. If you’re signing away code for a flat fee and the client builds a billion-dollar product on it, you have no legal claim to any of that value.

Carve out pre-existing IP. If you’re bringing existing code, frameworks, or libraries into a project, make sure the agreement excludes your pre-existing IP from the assignment. Grant the client a license to use your pre-existing IP, not an assignment.

Keep records of your independent work. If you’re developing side projects under Section 2870, document when you worked on it, what equipment you used, and how it differs from your employer’s business.

What Role Does California Play in National Software IP Disputes?

Why LA Courts Matter

California has outsized influence on software IP law. The Ninth Circuit has issued key decisions on software copyright, open source licensing, and the Computer Fraud and Abuse Act.

Oracle America v. Google (which went to the Supreme Court in 2021) started as a case about whether APIs are copyrightable. The Supreme Court ruled in Google’s favor on fair use, but the case reshaped how the software industry thinks about code reuse and interoperability.

The Central District of California handles a heavy docket of software disputes. Companies along Silicon Beach, Downtown LA, and the San Fernando Valley regularly litigate code ownership, licensing, and trade secret cases here.

For startups and tech companies in Los Angeles, the local legal infrastructure matters. Judges, attorneys, and expert witnesses in this market understand software technology. That’s an advantage when your case depends on explaining the difference between an API call and a derivative work.

What Should You Do Right Now if You’re in a Code Ownership Dispute?

Stop using the disputed code if you’ve been told to stop. Continuing after a cease-and-desist letter converts an honest mistake into willful infringement, which can triple your damages under the Copyright Act (17 U.S.C. Section 504(c)). If you’re facing a DMCA takedown, see our guide on how to file and respond to DMCA takedowns.

Preserve all communications with the other side. Emails, Slack, texts, GitHub comments, contract drafts. Don’t delete anything. Spoliation of evidence in federal court results in sanctions and adverse inference instructions to the jury.

Gather your agreements. Every contract, every amendment, every email about ownership or licensing. Organize them chronologically. Your attorney needs the full paper trail.

If you’re approaching a funding round, deal with code ownership questions now. Investors’ lawyers will find these issues during diligence. Fixing them after a term sheet, under time pressure and with the other side knowing you need a resolution, puts you in the weakest negotiating position.

At Mister Wolf, P.C., we handle code ownership and software licensing disputes for companies across the LA tech corridor. If you need to recover code from a contractor who won’t assign it, defend against a former employer’s overreach, or clean up your IP portfolio before a funding round, call us. Describe the situation. We’ll tell you exactly where you stand and what it takes to fix it.