Custom Software
Begin With a Good Contract

In our last article, we provided 3 steps to setting yourself up for a successful software development project.  Today we continue by providing further information on the first step: a good contract.
A good contract is an agreement: it allows you, the client, to determine how you will communicate with your vendor and what you can expect. This document establishes what you'll get, when you'll get it, how much you will pay and when you will pay it.
From a vendor perspective, a contract should include specifically what work will be done, and over what time period. For example, will the developer service you only through product creation, or will ongoing maintenance be provided? 
On the client side, a contract should include what information the vendor needs to begin and to continue the project. For instance, does your developer require certain documents or details to create the right product? A contract holds you accountable and keeps you organized: you'll get the right points to the developer on schedule.
Should the project go astray, you or your vendor can point to the contract and get back on track. Good contracts lay out terms of payment. How much? Who pays? When is it due? Tax responsibilities? And what are the consequences if payment is late? Contracts should answer all these questions.
And a contract sets a timeline for product milestones, delivery and ownership. When can you expect the final creation? At what point is the contract complete? As a client, ensure that ownership is clearly stated: you, not the developer, should own that custom code. This keeps your new product safe, and keeps the code out of the hands of your competition.
A good contract ensures confidentiality for both parties. Critical information will likely be passed back and forth; a contract keeps private details private. 
Since both your reputation and the vendor's matter, the contract should spell out liability. Should either party step on the wrong side of the law, a contract ensures that won't reflect back to you. 
Especially after months of collaboration, a personnel non-solicitation clause is significant. This keeps vendors from snagging your employees and protects your human resources investment.
Although it's tempting to quickly sign, seal and deliver, read the entire document. If the contract doesn't match conversation, discuss discrepancies now. In some cases, request that your legal counsel review the contract too.
A good contract keeps both parties out of court, saving time and money. If disputes arise down the road, simply go back to the contract and resolve the issue. Then, both parties can proceed as expected in an agreeable way and without costly and disruptive legal action.
Upon review, sign and keep the contract on file. Be sure both you and your developer have signed copies.
A solid contract will include both your responsibilities and the responsibilities of the web developer. Project scope, timeline, payment schedule and terms of service should be outlined.
Sound contracts set the stage for the right end result.