The static contract clauses


The static contract clauses are the clauses that remain unchanged for the duration of your relationship with the client.

Parties

Most contracts start out with a clause that lists the legal names of the parties entering into the contract. This clause also lists the short hand notation that will be used to reference the legal names of each party throughout the rest of the contract. For instance, the case where Adams, Borup & Schummer, Inc will be providing consulting services to Hentzenwerke Publishing. This clause often reads as follows :

 This Software Development Agreement ("Agreement") is entered into as of the xx  day of Month, 20xx between: Lindsay-Adams Consulting, 444 Spruce Street,  Anytown, OH 44444 (hereafter referred to as "Client") and Borup & Schummer,  LLP, 123 North Main Street, Mytown, MI 48000 (hereafter referred to as  "Developer")  

Ongoing support

The ongoing support clause describes what support will be provided to the client after the system and/or code is delivered. It should define the differences between a bug fix and an enhancement, whether the client gets charged for them, and include a method for reporting bugs and requesting enhancements. This clause can also state if training is included or if it is an extra fee. You must also define what constitutes training.

Be sure to include the response time the client can expect when calling about a bug or problem after the project is complete. If no call is received for 4 months, they should not expect an immediate response. We ‚ ve seen cases where we deliver a much needed piece of software, bust our you-know- whats to get it to them, only to find out they didn ‚ t touch it for six months and now they want us to jump through hoops to fix bugs. We are six months out of touch with that project and knee-deep into another, it is going to take time to get back into their project. This is also the same reason why a time period for free bug fixes should be included.

Testing timeframe

Our clients always seem to want the software to be developed yesterday . They don ‚ t often give us enough time to develop an application let alone time for testing it. Many developers include a clause that lets the client know that the 30, 60, or some defined number of days after the new application is installed at their site are testing days. Adding this type of clause to a contract is left to your discretion. We recommend adding this clause and especially recommend it when the client seems to be very impatient.

What is a Bug?

One of the biggest reasons for misunderstandings and conflicts between Clients and Consultants is what constitutes a bug. Put your definition in the contract. We define a bug as an operation that does not perform as specified in the written specifications and/or change orders or an error that causes the program to stop and display an error message that says, ‚“An application error has occurred. ‚½ See Figure 4 for an example. The bug must also be reproducible.


Figure 4. Sample of a Fatal Error Message for a Bug

You might also want to include your bug reporting process. It may be as simple as attaching your bug reporting form to the contract and explaining to the client how to use it. It could be as elaborate as an Internet form the client needs to fill out every time a bug is found. No matter what format you choose, you need to provide the client with the steps for reporting bugs and how you will notify the client when a bug is fixed.

Many clients argue about paying for the bugs considered something not performing as specified. Developers have to make many decisions about developing applications that meet the client ‚ s specifications and it is impossible to document all the possible scenarios in the written specification. We include in the contract that we reserve the right to make the judgments about these types of bugs.

Reproducibility is the key here. If the developer sits with a client for a few hours and can ‚ t get the error to occur again, that time is billable.

What is an Enhancement?

Enhancements and bugs are often confused by clients. That is why it is good to define these items separately in the contract. An enhancement is a request from the client that falls outside of the project ‚ s scope. Usually it ‚ s the report they forgot to tell you about or the one little piece of information Bob from Marketing left out of the original specification. The client needs to know these ‚“little ‚½ pieces aren ‚ t as little as they might think. You need the client to know you have a process for dealing with enhancements in the form of an Enhancement Request. The Enhancement Request form should be referenced in the contract as an additional attachment (ex. Attachment D).

The Enhancement Request process should be explained as fully as possible. Because they fall outside of the original scope of the project, they could be treated as a new project with a new set of costs and deadlines. Or they could be included with the client realizing there will be additional costs and changed deadlines.

What is Training?

Be sure to define what constitutes training. Does the system you are developing require an elaborate 5 ‚ day, ‚“How to use the system course? ‚½ Is it a one day, quick overview for the entire shipping department or whenever the client installs it on another user ‚ s system, you ‚ ll be required to train the new user at that time? You can choose from many training options. You need to think about the system you are developing for the client and decide if training will be handled separately or as part of the initial contract.

Don ‚ t forget about the extra time and cost to put the training course together. Is this part of your hourly rate? Does your project quote include training costs? You want to make sure the client knows that with a custom application custom training costs apply.

If you don ‚ t want to include training at all make sure you specify in the contract that training is NOT included.

Ownership ‚ who owns what?

U.S. Copyright laws specify that the consultant retains the copyright for anything developed for a client as an independent contractor. Transfer of copyrights to the client must be specifically assigned. Typically clients are not aware of this and assume copyright ownership. By specifying explicitly who owns the code in a contract or other written and signed document, misunderstandings that can develop around this issue are avoided. One of the best ways we have found to help the client understand who owns the code is to include the list of five types of program code as part of the ownership clause in a contract.

The five types of program code

‚“Code ‚½ refers to program code, design surfaces, and other objects such as libraries and classes needed for complete generation of an executable.

Previously developed generic code

Previously developed generic code is code that is part of a consultant ‚ s standard foundation already in existence. It could be a set of class libraries for the ‚“generic ‚½ pieces of applications. Examples are a re-indexing routine to improve data access performance, an automated backup routine, or an error logging routine.

Specifically developed generic code

This is generic code developed while working on a specific client ‚ s application that didn ‚ t previously exist in the consultant ‚ s code or class libraries. An example of this is a generic routine that creates MS Word documents from the client ‚ s data. This functionality does not currently exist in the consultant ‚ s class library, but would become part of the library upon development.

Non-competitive custom code

This is code developed while working on a specific project that could be applied in applications developed for other clients without infringing on the Client ‚ s intellectual investment in the applications. An example of this is a custom vendor recovery calculation for a tractor trailer manufacturing industry application that can be used if you create applications for a recreational vehicle manufacturer.

These first three types of program code define your set of intellectual property. It will continue to evolve as you move from project to project. This set of code is your competitive edge. This is what makes you better, stronger, and faster than your competitors and why you can complete the project in four months instead of twelve months saving the Client tens of thousands of dollars. If you assign the Client copyright to this set of program code it means you have to re-create this code over from scratch for each new client you get or the client has to pay big for the transfer of exclusive rights to these program code types. We think they complain now.

Custom code for client only

This is code, algorithms, or interfaces developed by the Consultant or by the Client that gives the Client a competitive edge or compromises proprietary knowledge on the part of the Client. An example of this would be calculations used by a stockbroker to indicate stock buys and sells.

This is the answer to ‚“I ‚ m paying you mega bucks, what do you mean I don ‚ t own the code? ‚½ This is the code the Client owns and maintains copyright to. You can ‚ t use this code in any of your future projects. It would be copyright infringement and the client has grounds to sue you.

Third party tools

Many developers use third party tools when developing applications. These tools are the property of the third-party company. The third-party is the copyright holder of the tool and sets the licensing restrictions in which the Consultant can use and distribute the third-party application. The Consultant must notify the Client when the Consultant uses third-party applications because the Client must also comply with the third-party licensing restrictions.

Framework users must be upfront with their clients that they are using a framework and they can ‚ t possibly take ownership of any of this code. Frameworks give consultants a competitive edge by cutting down development time and reducing the overall cost of the project to the client. Framework providers have given developers permission to create derivative works of their framework, so any new methods we add can be copyrighted by the developer or by the client.

Source code options

Now that ‚“who owns the code? ‚½ has been clarified, a decision should be made as to what rights the client has to the application and the application ‚ s source code. This is also known as licensing.

What are my licensing options?

Give all rights to the application and the application ‚ s source code to the client. This means the client can resell the code and prevent the consultant from using it. If this option is selected, all of the ‚“generic ‚½ code and libraries used in the application need to be re-written. The client can sue the consultant if they find out the consultant is still using code that now belongs to the client. This is the option most clients think they should have, but it is the most costly option because of the need to recreate all of the generic routines for their project or start from scratch on the next project. Either way the client is going to pay dearly for this option.

Client gets the right to use the application and the application ‚ s source code along with the right to use and modify it for their business, but the Consultant reserves the right to sell it to others as well as reuse it. This is the most common option. The consultant reserves the right to reuse the source code repeatedly enabling him to provide feature-rich, robust, and error-free functionality at an inexpensive price. If this option is chosen , it must be stipulated somewhere that bugs are no longer free to fix because the original source code has been altered . This option also gives the client permission to create derivative works of the original code. This means they can have their own staff or outside sources modify the code. These individuals are not permitted to use the code outside the client ‚ s business. Should it be found the source code is being used other than for the client, a determination of whether or not to pursue a lawsuit for copyright infringement must be made.

Client gets the right to use the application with the option of purchasing the application ‚ s source code. The purchasing option of this licensing option can be performed two ways. The first way is the consultant charges the client a fee to obtain the source code and gives the client permission to create only derivative works. The client does not get exclusive rights to the source code. For those who have been developing FoxPro applications since FoxPro 2.x, SBT comes to mind. SBT gave us the option of just purchasing their product, but if you needed to customize anything, they offered the source code for a fee. SBT maintained exclusive rights and gave us permission to create derivative works.

The second purchasing option occurs after the application has been developed and paid for by the client. The client likes the application so well they simply must have exclusive rights to the source code. In this case, the consultant charges the client a fee high enough so the consultant can ‚“retire. ‚½ Why so much? Because it took you a long time to develop your base set of code libraries. If you choose to continue developing applications it ‚ s going to be a while until you are productive again. You will need a reserve to sustain you until you are
‚“back in business. ‚½ This code is your company ‚ s biggest asset. The client in essence wants to ‚“buy out ‚½ your company. So the amount you charge should be significant. Depending on where you are in your career this could be your chance to retire.

Give Client the right to use the application ‚ s source code but negotiate a royalty or other payment should the client choose to resell the system. This could be an option if the client has multiple offices and wants to sell the system to them. The consultant owns the code, and therefore has some say on how it is distributed and used. The client can be given a license to use and sell the system and also allow the consultant to retain royalties from sales profits.

Don ‚ t give the application ‚ s source code to the Client. Put the code in software escrow just in case something happens to the consultant.

The paragraphs below demonstrate the use of Source Code option two. The rights of each party have been clarified.

 "In order to provide Consultant with the flexibility needed within their  business but at the same time provide Client with protection for the investment  made in custom application development, Consultant retains all copyright and  patent rights with respect to materials described in the first three areas, and  grants to Client a permanent, non-exclusive license to use and employ such  materials within their business.   Consultant assigns all copyright and patent rights with respect to materials  that fall under the fourth area to Client upon full payment. Modules or  routines that fall under the fourth are will be designated as such in the  Functional Specification and a specific copyright notice indicating such rights  and ownership will be placed in the header of said modules and routines. Items  that fall under the fifth area remain the property of the third-party company,  but Consultant will supply Client with information necessary to license said  tools, foundations and other elements should Client desire to do so."   [1]  

The Client has been granted a non-exclusive license to use the application in their business. The Developer has given the Client permission to create derivative works and install the application on any computer within the Client ‚ s business.

Confidentiality

The Confidentiality/Nondisclosure clause answers the question: ‚“Will any of my confidential material be disclosed to my competitors or unauthorized persons? ‚½ This clause specifies what is considered confidential and binds the parties not to disclose any confidential material.

Most of us assume this clause is here to benefit the client, but it actually protects the developer as well. For the developer this clause prevents the client from giving any specifications, code, or proprietary libraries to a competitor. The client wants it to prevent the developer from revealing information about a new product, method, or company strategy to a competitor, the press, or the general public.

This clause sometimes stands as a contract on its own as a Confidentiality Agreement. The Confidentiality Agreement is the initial document presented to the client. This shows the client they are safe to disclose particulars about the proposed job. The developer may be sharing tools and trade secrets with the client also covered by the confidentiality agreement. Protections covered by the agreement should be in place so both parties are assured that information disclosed will not be disclosed to any competitors if the parties decide not to work together. Don ‚ t be surprised if the client has a confidentiality agreement waiting for the consultant to sign. If they do, watch out for overly broad wording that limits the developer ‚ s ability to work for the client ‚ s competitors. Broad definitions of confidential material and wording that keeps the developer from using generic code for new clients is common.

Make sure a period of time is specified for when confidentiality ends. Although as a professional courtesy , it should never end. If either party feels strongly about including a period of confidentiality make sure it is reasonable for both parties. We do quite a bit of work for hospitals and insurance companies and the confidential materials we have access to (patient name and diagnoses, social security numbers , etc.) we feel should remain confidential forever. The business decision made about confidentiality depends greatly on the industry you are contracting with.

Non- Compete

The Non-compete clause answers the question: ‚“How do I know you won ‚ t go work for one of my competitors after this contract ends? ‚½ This clause limits the developer from working for certain types of clients for a period of time after the contract ends. This clause should also include a geographic limit and an industry specific limit. This clause is sometimes a contract of its own. This clause benefits the client by protecting the client ‚ s investment in the system you developed.

Watch out for overly restrictive and unreasonable clauses. A client cannot prevent a developer from making a living. Following is an example of an overly restrictive clause:

  The Developer recognizes that the Client has made a significant investment in 
the development of System. The Developer shall not engage directly or indirectly, or through any corporations or associtions in any business or enterprise which is directly competitive with Client for a period of two years.

The problems with this clause are the time period is too long and there are no geographic and/or industry limits mentioned. Time periods shouldn ‚ t be longer than one year. Who are the corporations and associations that the Client directly competes with? You want the client to be as specific as possible when setting limits. Don ‚ t sign this unless they are willing to provide you with a list. Because no geographic limit is mentioned it could mean any competitor any where. There has to be a limit mentioned.

For instance, you are developing an application that gives your client, The Ford Motor Company, the competitive edge. They may try to limit you from working at any auto manufacturer in Michigan. That is too restrictive. They can ‚ t prevent you from signing a contract with General Motors to do an application. They have to remember you did sign a confidentiality agreement. You can ‚ t approach General Motors with the intent of creating a similar system or divulging the confidential information you learned while at Ford.

Now for a sample of a reasonable Non-compete clause:

  "In addition, Consultant recognizes that Client has made a significant  investment in the development of System, and hereby agrees not to resell,  duplicate, or otherwise infringe on the investment Client has made in the  development of System. This includes not approaching competitors (see  Attachment B) of the Client with the intent of duplicating System."   [2]  

Make sure the Client includes a list of their competitors because you may not be aware of all of them. Using an intention statement releases some of the geographic and industry specific limits and only holds you to the competitors listed in ‚“Attachment B. ‚½

Guarantees

Note ‚  

Thank you to Janet Ruhl for information used in this section.

The guarantee clause defines what recourse the client has if the Developer ‚ s work doesn ‚ t live up to expectations or the project isn ‚ t delivered on time. The Client wants this clause to protect against poor quality work and give incentive to meet target deadlines. You may want to have an acceptable guarantee clause handy in case the Client demands one. Refusing to give a guarantee could cause you to lose the Client and the job.

If the Client supplies a contract with a guarantee clause there are some key points you want to watch out for. Watch out for wording that allows withholding payment for software that remains in the Client ‚ s possession. The client has no right to keep the software if they decide they want their money back. The client ‚ s guarantee clause may have wording penalizing you for problems out of your control such as late hardware delivery or MicroBurst, Inc. ‚ s failure to release a component vital to the completion of your application. Make sure the clause includes a time limit on the guarantee. You don ‚ t want the client coming back to you in two years saying, ‚“It ‚ s not working any more. We want our money back. ‚½ These are just a few things you need to watch for when the client supplies the contract. As always, be sure to read the clause carefully and contact an attorney if you feel it is necessary.

Ok, so what can you include to make a guarantee fair for both you and the client? You can break the project into a set of manageable deliverables. Then specify in the guarantee that the ‚“money-back ‚½ expires after the client has signed-off on the deliverable . The sign-off criteria must be specified in writing. There must also be two-way incentives included. If the client wants to add penalties for late delivery, you should include a clause that provides a bonus for early or on-time delivery.

If both parties have agreed the client gets copyright ownership of the code and the client exercises their right to get their money back, all copyrights to the deliverables to that point revert back to you. Meaning you retain all the rights to resell the application and profit from it. You also have the right to remove deliverables from the client ‚ s premises.

This is a clause that none of us have ever included in our contracts. Why not? Because we usually meet our deadlines and do our best to develop applications that meet our client ‚ s needs. The only way we would include a clause like this in our contracts is if it included twoway incentives and it would need to heavily benefit us to meet it. The problem we see with this type of clause is our customers almost always change their mind and we can guarantee they would want to hold us to this clause despite their change order. We would need some serious cash in the contract to make a guarantee or know we have a ridiculous amount of time to complete the job. There are too many variables that can go wrong.

Client responsibilities

Have you ever had a client promise to get you a test set of data, provide report mockups or calculation sets? Did they get what you requested in a timely manner or at all? This clause lets the client know what their responsibilities are and what happens when they don ‚ t deliver. Many times clients don ‚ t realize they are the cause of their own project delays.

This clause should include a description of what you expect the client to deliver and the penalty for non-existent or late delivery. This could also be a separate clause because you may not know exactly what you are going to need at the beginning of the contract engagement. You could use several of these smaller documents over the course of the project. This clause is one of the clauses that could change per project or per client. You will have to decide if it belongs in the static contract or the dynamic contract.

A sampling of responsibilities we assigned to our clients follows:

  • Client will test the delivered application to verify it meets the requirements in an acceptable timeframe and we provide the timeframe.

  • The client ‚ s subject matter expert or another representative will be available to answer questions that we may have concerning the project.

  • Client will create or provide test scripts.

  • Client will create or provide test data.

  • Client will provide a runtime copy of the existing application, if there is one.

  • Client will provide existing application documentation.

  • Client may need to purchase hardware and software licenses before a certain date.

This is just a sampling of what could be required of the client. If there is some task you would like to assign to your client, make sure you add it to the contract. The client won ‚ t know what they are responsible for unless they are told.

Acceptance clause

The acceptance clause defines the circumstances under which the system will be defined as complete. This allows the consultant to distinguish between the project as defined in the contract and new work that requires a new contract. If the developer works on fixed-bid contracts it should be in writing that if the client changes the specification that was the basis of the fixed rate, the rate must be renegotiated. Sign-off criteria only applies to a system that meets an unchanged project specification.

Contract termination methods

The termination clause defines the terms under which either party can terminate the contract. This clause benefits the consultant in the event of an accident or illness that prevents the contract from being completed. The client benefits should their business needs suddenly change.

Settling disputes

The settling disputes clause defines the mechanism for settling serious disputes. This includes calling on the services of an arbitrator and/or specifying who will pay for a successful lawsuit. The mechanism of choice for most contracts is arbitration. Arbitration is the process where the parties in a dispute submit their differences to the judgment of an impartial person or group appointed by mutual consent . It can solve disputes in a less expensive and timelier manner. Be sure to select arbitrators familiar with software development issues. Watch out for client- supplied wording in the contract that makes the consultant liable for frivolous suits filed by the client. The decision of an arbitrator is final and not subject to appeal . The goal as a consultant is to keep disputes from occurring. This is done through effective communication with the client for all phases of the project.

Severability

According to Webster, this means ‚“capable of being severed or separated. ‚½ So what does this clause add to the contract? Say for instance you just presented your client with a 60-clause contract and one clause is poorly worded, invalid, or redundant. Does that mean the entire contract is poorly worded, invalid, or redundant? No. This clause states that the clause in error does not affect the validity, legality, or enforceability of the other provisions of the contract.

Extension conditions

The extension conditions clause is mostly used in hourly rate situations. It specifies whether the same rate and other terms will apply to new contracts made within a specified time period. This benefits the client by protecting against rate hikes in the middle of a project. This clause is common in client-supplied contracts. If the consultant finds the terms acceptable, usually they aren ‚ t worth fighting over.

Governing law

Governing laws decide which state ‚ s laws will be used to uphold the contract. This is not an issue if the developer and the client are located in the same state. However, if the client is in a different state or has offices in several states where applications will be deployed there is a need to determine which state ‚ s laws govern the contract. Some states are more computer developer friendly than others. A computer law attorney should be able to help determine which states are more favorable.

[1] Hentzen, Whil, The Software Developer ‚ s Guide, Third Edition, pg. 201-202

[2] Hentzen, Whil, The Software Developer ‚ s Guide, Third Edition, pg. 203




Deploying Visual FoxPro Solutions
Deploying Visual FoxPro Solutions
ISBN: 1930919328
EAN: 2147483647
Year: 2004
Pages: 232

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net