date
This agreement is made between customer name ("you") of company name located at customer address and developer name ("us") of developer's company located at company address.
You desire to retain us as an independent contractor to develop the name of application (the "application") described in the section, Technical specifications.
We are ready, willing and able to undertake the development of the application and agree to do so under the terms and conditions set forth in this agreement.
The following section briefly describes the individual technologies that will comprise the application. All of the technologies are open source and free to use and modify.
We will build the application with the user interface with Bootstrap. Bootstrap is, according to their website, "the most popular HTML, CSS, and JS framework for developing responsive, mobile first projects on the web." This will minimize time spent designing the user interface since most of it is taken care of by Bootstrap. This allows us to focus on the functionality of the application.
We will build the application with Flask. Flask is a small, web application framework built in Python. We chose Flask because of its simplicity and popularity.
Because, initially, we do not expect a large user base, we will use the SQLite database engine. A SQLite database is contained in a single text file and that file will be stored in the application's root directory. This eliminates the need for a separate database server and thus eliminates much of the usual complications involved in configuring a database.
We will track revisions of the application using the source control management tool, Git.
Users will be able to register account through a contruct we build in Flask. The user's information will be saved in a SQLite store and information will be presented to him using Bootstrap's constructs.
As stated in the project proposal, we shall be compensated at the rate of $0.00 per hour. Unless otherwise agreed upon in writing, your maximum liability for all services performed during the term of this agreement will not exceed $0.00.
In a show of good faith, we require the first 0 hours, or $0.00 as a down payment prior to undertaking the development of the application.
We will invoice you via billing service at every 0 days. You will pay us within 0 days of our submission of the invoice.
Additional features which we determine to be outside of the agreed upon project scope will require a separate estimate.
Beginning the day after the date of delivery of the final product you will have 0 days to inspect, test and evaluate the application to determine whether the application satisfies the acceptance criteria.
You will draft a document containing the acceptance criteria and we will approve it prior to the commencement of the acceptance testing period.
If the application does not satisfy the acceptance criteria, then we will attempt to resolve errors you discover during the acceptance testing period at the project rate ($0.00).
If we do not hear from you during the acceptance testing period, then the acceptance testing period will terminate after 0 days.
We will attempt to resolve errors you discover after the acceptance testing period for the hourly rate of $0.00.
You are under no obligation to seek technical support from us.
We cannot guarantee that the final product we deliver to you will be free of errors. As such, in no event shall we be liable to you for your lost profits or special consequential damages resulting from errors in or misuse of the application, even if you have advised us of the possibility of such damages.
To reduce the chance of this catastrophe from happening we insist that you do not release the application to the public until after the application has been thoroughly tested during the acceptance testing period.
This section describes which party owns which parts of the application. The main idea is to give you full ownership of the final product while allowing us to retain ownership of the routines and algorithms we invent along the way. Good programmers write code once and reuse that code in other projects.
After we receive your final payment, you will own the entire application, which, lawyers refer to as the "work product". In this context, the application is the combination of the User Interface elements, the source code and the database which includes all of the data stored said database.
"Background technology" is the fundamental functional components of the application including design patterns, data structures, class structures, functions, methods, algorithms, routines and subroutines. In other words, it's the individual parts of the application.
You have an unlimited license to use the background technology for the application to operate. You cannot sell the background technology or publicly claim that it is yours without written consent from us.
Background technology does not include any assets or technology you provide to us. You still retain ownership.
We reserve the right to display screen shots of the public-facing portion of the application for our portfolio. We reserve the right to link to the public-facing portion your application. We also reserve the right to write about the application on websites, in magazine articles and in books. We guarantee that we will never release the source code nor divulge any confidential information to any third party.
Just like a parking ticket, you cannot transfer this agreement to anyone else without our permission. This agreement stays in place and need not be renewed. If for some reason any part of this agreement becomes invalid or unenforceable, the remaining parts of it remain in place.
Although the language of this agreement is simple, this is still a legal document under the jurisdiction of United States courts.
By signing this document, each party guarantees they are authorized to bind their respective organizations to this agreement.
About this version
This contract is intended for developers where as the unadulterated version of Contract Killer 3 is intended for designers. I put a sample Flask application in this agreement to provide an idea of how the agreement looks with content.
I edited to the original document so many times and removed nearly all of the playful text that I'm certain Andy Clarke would not consider this a killer contract.
Sections I added
Identification of parties and purpose of agreement. Clearly define whom the agreement is between and what the agreement is for. I think Contract Killer 3 failed at providing this.
Technical and functional specification. Describe the application you are building and how it works. Generally, these are appendixes to the actual agreement, but I put them both in the contract body so 1) they cannot be ignored and 2) to keep you brief in writing them.
Do not voluntarily spend hours detailing the minutia of the application. However, if it is a client request, then feel free because all client requests are billable. The customer will not understand nor care about the intricacies of the app and you will change your mind or find a limitation which prevents you from implementing a feature that has been documented in the technical specification.
User acceptance testing period. Make it clear that the customer has time to review the application you built for him. I consider this period the "warranty period". If the customer finds bugs in the application you delivered to him, you ought to fix them
free of chargeat the project rate.Developer retains ownership of background technology. This ensures that you can reuse the routines you used in this project. Technically, Contract Killer 3 has this section (4th paragraph), but it is not clear.
UPDATE: I want to note that I nearly lost a client because of this clause. The client's attorney (it was first time I ever dealt with a lawyer as a freelancer) thought I meant that I retain ownership of the entire app, including the proprietary software that the client had developed—my task was to develop an authenticated Rails app to access and execute a private Ruby gem written by the client. What I meant was, if I develop (and I did) a generic routine such as user policy manager or a CSV parser, I want the right to use those routines in other applications and to publish them on GitHub. Even after I explained this the client's lawyer still was not satisfied, so I axed the whole section.
UPDATE: I originally wrote that all bugs found in the user acceptance period ought to be fixed free of charge. That was a mistake. The same client I wrote about in the update above used my naivety to their advantage and got an extra 15 hours of free development time from me. The saying "nice guy finish last" applies here. Always bill the client.
The intended goal
The Elements of Style was the inspiration behind the edits. I wanted an agreement which was readable to folks who are not lawyers.
The only gripe I have about Contract Killer 3 is there is text in that agreement which adds no value. All it did was create more work for the reader. For example:
That is 1 sentence and it does not provide any detail on the terms of the contract. To me, his attempts at setting a playful tone comes off as insecurity. Either because he's afraid to talk about legal requirements or he doesn't know how, so he puts in filler.
On the other hand, adding jokes which are actually funny is a good idea. Everyone enjoys laughing. But set the limit at 2 jokes. If you go overboard then you'll come off as attention starved and you may not be taken seriously.