If you find this article contains errors or problems rendering it unreadable (missing images or files, mangled code, improper text formatting, etc) please contact the editor so corrections can be made. Thank you for helping us improve this resource
ôMilestone Deliverablesö are interim and final assets delivered to the Publisher by the Developer throughout the term of the development agreement. The approval of the ôMilestone Deliverablesö by the Publisher triggers the payment of the ôAdvancesö that fund the ongoing development process. These Milestone Deliverables are defined in the Publisher/Developer Agreement, often in minute detail. This article addresses the fallacy of detailed ôStatic Milestone Deliverablesö and discusses a preferred methodology involving ôFlexible Milestone Deliverables.ö
ôI hear you know how to make games...hereÆs $5mil - make me some!ö
As the stories go, in the wild and wooly early days of the Video Game Industry, Developers were funded by Publishers by the delivery of rather large checks. These funds were dispersed solely on the DeveloperÆs representation that they could actually make games. Sadly, Publishers eventually realized that they needed some form of control over the Developer or there would be no way to assure that the Publisher would ever receive a game for their investment. So, milestones were born. Instead of a single check to pay for the entire game, the funds were delivered over time, with the Developer being required to show the Publisher that progress was being made on the development of the game. At first, a few milestones with general descriptions were given, such as, 1.) the signing of the contract, 2.) a playable alpha, 3.) fully completed beta, and 4.) delivery of the gold master. Except for the first milestone, each of these deliverables would have to be accepted by the Publisher before the correlative Advance payment was made to the Developer top continue the funding of the development of the game.
As this milestone process evolved, Publishers began to add more milestones into their contracts and put more detail into each milestone to better manage the process and reduce their perceived economic risk. Often, the details of the deliverable were derived from the design document supplied by the Developer. As deliverables became more and more defined, Developers became less and less likely to meet them as required under their agreements. Eventually, ôMilestone Deliverablesö became a running joke in most studios because as long as the Publisher was satisfied with the actual progress of the game, compliance to the details of what the contract defined ôdeliverablesö was in practice, not much of an issue. But it should be.
Feature creep, new technologies and iteration vs. static deliverables.
The simple reality is that things change throughout the development process. Even the best planned development cycles do not go as expected. Of course, the creative process in developing games gives a solid justification to this fact. After all, games are the result of a creative process and often rely on emerging technologies. They are also the product of a group effort with many cross dependant assets. This already complex process is complicated further by the fact that Developers and Publishers often attempt to define all the deliverables over a 24-30 month project before the project has even begun based on a design document. Then new technologies emerge, designs change (hopefully for the better), cross dependent elements fall off track because other parts of the game are simply more difficult to implement that anticipated. Quite frankly, some times Developers pitch games too zealously and end up over-promising in the process. All of these complications, and more, end up with Developers making commitments to milestone deliverables that they can not and do not keep. And most Developers and Publishers know this fact when they sign their contracts.
Developer is in default from Milestone 2, or maybe 3...
There is an inherent risk to the developer in this process. It puts the Developer in technical default under the contract because of a failure to provide the deliverables called for in the contract. As a result the publisher can terminate the contract ôfor causeö at any time, rather than exercising the ôfor convenienceö termination. Under these contracts, a ôfor causeö termination is inevitably less advantageous to the developer than a ôfor convenienceö termination. A ôfor convenienceö termination often requires the publisher to pay out a portion of the remaining advances to get out of the contract where the ôfor causeö termination does not. No Developer should put itself in a position where it is in breach of contract within a few months of signing with their Publisher.
As you probably know, certain elements in the asset pipeline are expected to occur at certain points and certain elements are necessarily dependant on the pre-existence of other elements. Other elements are completely independent and due to personnel issues, allocation of resources, or a myriad of other things that may not occur exactly when you anticipate. These matters often result in an actual delivery schedule that does not even vaguely resemble the milestone deliverable schedule in the contract. Just like when milestones were first implemented to accommodate for an evolving industry, as our industry matures we need to find ways to accommodate this disparity. Not just because of the unreliability of the deliverable schedule, but because great games require iteration. And iteration can not be written into a hard milestone deliverable schedule. Most importantly, milestone deliverables need to reflect what is actually occurring in practice. The inclusion of flexible milestone deliverables in the contract recognizes these facts, builds this flexibility into the contract to create a more organic relationship throughout the development process.
A fixable flexible solution
Here is how it works. The initial milestone deliverable is, of course, defined. ThatÆs easy, as it is usually the signing of the contract itself. The next full deliverable in the contract is also fairly simple and straight forward in that it is invariably based on the first iteration of the existing project, whether it is a partially completed game, proof of concept or technology demo or even a completed design document. From there on, the Publisher and Developer agree to confer periodically throughout the development of the game to set the deliverables. In this manner flexible deliverables allow the Developer and the Publisher to continue to write the specifications for each deliverable based on the prior deliverable. So, the second deliverable is based on what was delivered in the first deliverable. The third deliverable on what was delivered in the second, the fourth on the third and so on.
In addition, if there is a departure from the original design that requires substantial additional work by the Developer; the Developer has the opportunity to ôup-sellö the Publisher. Then modifications can be negotiated to the advances due under the contract to facilitate additional funding to compensate the Developer for approved additions to the game. That way, the additional enhancements are not done at the DeveloperÆs expense. They can be factored into the deliverable and also added into the advanced payments that accompany it. Of course, this process does require a close working relationship between the Publisher and the Developer. But the benefits to both are well worth the effort.
So, while some of the best Developer war stories come out of discussions regarding the difference between the deliverable and æthe deliverable,Æ that is, the deliverable in the contract and the deliverable delivered, this is really no laughing matter. Often with static deliverables the Developer finds itself dependant upon the good graces of the Publisher to accept a deliverable that in no way resembles what is called for by the contract. It is hardly a decent position to be in when the advances tied to those deliverables could mean life or death to your company. It is bad enough when there are a few items missing from the list of deliverables in the first few milestones. However, the problem exacerbates exponentially as the project moves from milestone to milestone due to the interdependency that naturally exists among the deliverables. So, letÆs make the deliverables in the contract match the deliverables in practice. Sure, there will be fewer war stories to tell. But it will be better for everyone involved, both Developer and Publisher. After all, static milestone deliverables have been a joke in the industry for years and it is time we stop laughing and started doing something about it.
[Tom Buscaglia, The Game Attorney, writes frequently on subjects of interest to game developers. The above article is for the information and education of members of the development community. Feel free to distribute or disseminate this article. But please include the legend "Copyright 2007, Thomas H. Buscaglia, Esquire" and an active link to in each article posted or published elsewhere. The sale or any other commercial exploitation of this article, in whole or in part, is strictly prohibited.]