NAN - Fotolia

Learn the basics of freelance developer agreements

Developer work agreements protect both the client and the freelancer, and they ensure that the code meets expectations. Each side should pay attention to these contract clauses and technicalities.

As software projects jam up the pipeline, each one vital to business operations or revenue generation, development teams get stretched to the limit, and they can be starved of essential skills or talent. Projects hit delays and quality issues, prompting organizations to alleviate the problems with freelance developers. Freelance developers are not employees, and the relationship between an enterprise and a contract worker can be complex. Enterprises typically spell out the details of freelance developer agreements in a written work contract. Whether you're a software developer looking for an assignment, or a manager seeking to engage a contractor, familiarize yourself with the essentials of a freelance developer contract and its common caveats.

Agreement basics

While the verbiage and terms of any work agreement vary, the goals are to set expectations of the work; define each side's responsibilities; establish the interactions between each party; and outline important topics, such as schedules, delivery and payments.

Work agreements protect the interests of both parties. The stipulations in them can prevent an engagement from moving forward or helps each party know when the work is done in a satisfactory manner.

Work definition

The definition, which contains the most important parts of a freelance developer contract, outlines the anticipated work or services. A software developer's work definition might include:

  • a description of the project or task that details what the software will do;
  • a list of the development languages to be used; and
  • any testing and expected compatibilities, such as operating through Firefox or other web browsers.

When the project is extensive or complex, the definition in freelance developer agreements can reference related documents that detail the project. When the enterprise provides details, it is a statement of work or a software requirements specification. When a developer makes a pitch for work, the document is often called a project proposal.

Detailed and tangible results are vital in a definition. When the definition is too broad, the two sides can struggle to articulate when the project is actually done. Consider including data sources, testing goals, metrics or other details for clarity. If a project should create image recognition software, the enterprise might provide the image data used to develop and test the software. Similarly, software that must process a certain amount of image data over time might include stipulated goals, such as images per second or megabytes of image data per second, in the details of the contract.

Contract developers and business managers can also stipulate tasks that are outside the bounds of the work, such as if the software is not intended to support a particular web browser, or if the developer doesn't need to supply certain tools or data. These explicit exclusions speed testing and help avoid confusion.

Finally, the definition of work should also include a change clause to address scope creep. Requirements and goals can change mid-project, and each change adds work for the freelance developer. However, payment is often fixed, so additional work means less profit for the contractor. A change clause helps ensure that the developer is fairly compensated and receives enough additional time for work incurred as the employer requests changes.

Work reporting

While a freelance developer could operate at a client's facilities, they commonly work off site. As a result, regular communication and progress reporting are important elements of their contracts.

With progress reporting, a client might require the freelance developer to submit regular written updates outlining the project's status, issues encountered, previous issues resolved and upcoming tasks or goals. Reporting can also include regular deliverables, such as the current build of the software, for examination and evaluation. If the project involves multiple components, the freelancers can complete the individual components that make up the deliverables, which get submitted by predetermined deadlines throughout the project's duration.

Written reporting seems like busywork, but it ensures developer accountability and gives the client an opportunity to provide feedback or approval. This correspondence helps keep the project on track and addresses any problems before the schedule is derailed.

How often do you need reports? Typically, weekly, but the frequency can differ depending on the size and scope of the project. Strike a reasonable balance for reporting between control and micromanagement.

Reporting should also clarify a point of contact between the contractor and the client -- one always-available person. That person is especially important if the freelance development firm employs numerous developers. All communication between a client and contractor should flow through this connection to eliminate the possibility of conflicting signals from the client, in which various stakeholders communicate different -- possibly contradictory -- requests. The client's project manager can provide the single source of truth for the project needs.

Work agreement technicalities

A freelance developer contract routinely includes numerous technicalities. These clauses are not directly related to the project at hand, but they can still seriously affect the engagement.

The definition of independent contractor status is a simple yet important clause, as it differentiates a freelancer from an employee with payroll tax overhead and benefits. This clause enables a freelance developer to make business deductions related to the project and otherwise function as an independent business.

Freelance developer agreements should clearly detail payment terms, whether the work is based on an hourly wage, a single fixed amount or a regular retainer. Outline all of the elements involved in contractor payment. When a project is priced as a single fixed amount, for example, the organization might issue a down payment, then provide additional payments at major project waypoints, and perhaps a final payment upon completion. If the project is priced as an hourly cost, the terms should outline the invoice frequency and time-to-pay. Additional terms might include kill fees if the project is terminated, interest for late payments, bank fees and currency conversion fees.

Additionally, software projects create intellectual property and require nondisclosure agreements. Here are a few general rules to keep in mind:

  • any party that provides intellectual property retains ownership of it;
  • any party that receives intellectual property, shared with them as part of the work being performed, protects -- does not disclose -- it; and
  • any intellectual property that a developer creates for a client is transferred to that client upon full payment of the final invoice, unless otherwise agreed upon.

It's tricky to work with intellectual property, as any freelance developer inevitably learns things in the course of the work they perform. It's practically impossible to avoid applying that learned knowledge to future work.

So, freelancers must ensure that there are exceptions to intellectual property terms that differentiate confidential information from factors such as prior knowledge, public knowledge and knowledge developed independently. Some freelance developer agreements attempt to insert aggressive non-compete clauses that prevent contractors from doing similar work for other clients, sometimes over several years. Contract workers often strike such clauses or refuse to take work that require them.

The last technicality involves termination of the contract. Contracts can expire when the project and payment are complete, or a retainer-based agreement might expire after 12 months but can be renegotiated and renewed. However, termination can also occur for nonpayment or a breach of contract terms, like failure to meet deliverable deadlines. While many terms of a work agreement are specific, the termination terms of a work agreement are often broad and bilateral, which allows both parties to exit the contract with relative ease.

Legalities to keep in mind

A freelance developer contract should include a set of legalities, typically liability, arbitration, severability and governing law.

Liability clauses address legal claims and exposures that might arise as a result of software creation and use. Freelance developers often include clauses that protect them from damages or losses that result from software faults, malfunctions, errors and omissions. Additionally, liability clauses should protect the freelancer from infringements on any intellectual property that the client does not have the rights to use, such as a third-party algorithm that the company didn't license. Conversely, liability clauses protect the client against damages and losses incurred by the freelancer, by limiting the client's obligations to the fees payable under the contract.

A contract must stipulate what happens when things go bad, which brings in the legalities of arbitration, remediation, severability and governing law. Severability means that if any clause of the freelance developer's contract is illegal or unenforceable, the rest of the contract is still valid. The contract should detail the method for dispute resolution. Often, arbitration is the preferred way to address and resolve contractual disputes. Arbitration bodies can deliver binding decisions, usually eliminating costly litigation. If arbitration does not deliver binding decisions, parties can still opt to pursue litigation. A contract should stipulate the location or arbitration committee to address disputes.

A contract can involve parties across legal jurisdictions, including different states, provinces or countries. Laws vary between jurisdictions, so the clause of governing law simply identifies the jurisdiction where the laws govern the contract.

Negotiate upfront

Contracts might include additional terms and conditions, depending on the nature of the project, the scope of the developer's role and the enterprise seeking a contractor. Read the work agreement carefully to understand the implications of each condition.

Don't forget that all contractual agreements are negotiable until they're signed. The party that presents the work agreement probably uses a boilerplate document with default terms and conditions. Yet, the freelance developer does not have to accept a contract as is. Both parties can modify the agreement to establish mutually beneficial terms. Only then should they sign it. If acceptable terms cannot be reached, it might be better to decline -- a bad deal is worse than no deal at all.

Finally, keep in mind that the laws related to freelance work agreements, taxation, intellectual property and other issues -- not to mention the enforceability of work agreements -- vary between U.S. states and countries. Research the specific laws that govern your location and seek the advice of experienced legal counsel before you negotiate or sign a contract.

Dig Deeper on Software development team structure and skills

Cloud Computing
App Architecture