fbpx

Fixed price agile software projects: The good, the bad and the ugly

LAST UPDATED: September 17, 2020

Sokari Gillis-Harry

Fixed price agile projects are software development ventures which agencies execute based on the fixed price agile contract method.

 

The fixed price agile method, otherwise known as an agile fixed-price contract is a contractual agreement between a software development company and a software client where they allow for a pilot test phase before agreeing upon the work scope, budget, and due date of the software development project.

 

This method differs from the traditional fixed cost method in that it allows for a test phase before both parties agree upon terms while the fixed cost method demands that the client and software developer agree on the work scope and terms of the contract before the project even starts.

 

Historically, most contract models in software development seek to define the three major factors needed to complete a software development project; money, time, and scope. 

 

With fixed-price contracts, the money involved in building a software (budget), the time (due date), and the scope of work are usually defined ahead of time, but the agile method of development advocates for adaptability. Adaptive planning, flexible development, and continual improvement are some of the core tenets of agile development. 

 

These contrasts in both methodologies leave a lot of people wondering “how do fixed price agile projects work?”.

 

How Do Fixed Price Agile Projects Work?

 

We have already established that fixed cost projects entail knowing the three important factors: money, time, and scope of work needed for the project, ahead of time.

 

And we have also agreed that the agile method is a way of doing work that advocates for the project team to begin or start the project first, and make changes as needed as the project cycle progresses.

 

An agile fixed-price contract is one that allows the contractor and the software development company to come together and make a projection of the expected project cost, expected time needed for the project, and expected scope of work first. 

 

Thereafter, they agree and proceed on a test phase known as a “checkpoint”. After which they compare their predictions with the realities and then make educated decisions on how the implementation of the full software development project will go.

 

The fixed price agile contract also requires determining preset conditions where both parties agree to allow changes to the project and agree on how these changes can happen.

 

Why Fixed Price Agile Projects?

 

Offering customers a fixed price contract for an agile software development project is difficult. 

 

It requires the software development company to have a proper understanding of the client’s functional requirements, required technologies,  planned architecture, needed interfaces, employees’ skills, and whether or not there will be a need for parallel development (building different features at the same time and merging it afterwards), etc.

 

These complexities oftentimes lead to bad experiences on the sides of both the client and the software development company.

 

This is why fixed agile contracts are very important.

 

Fixed-price agile projects allow you and your software developer to test-run a pilot phase where you have an understanding of what you need in terms of money, time, and scope, then both parties can proceed to agree on a fixed cost contract- a win-win situation for all parties involved.

 

Fixed Price Agile Projects: The Bad and the Ugly

 

One of the biggest arguments against the fixed price agile method is that the two components that make up the methodology are quite opposed.

The agile method of software development was created as an improvement to the traditional waterfall method. It advocates that instead of planning a meticulous full software development from start to end, detailing it fully and then building the product only to discover that it does not function as planned, you should utilise small development cycles known as sprints.

Sprints are periods of one week to one month, during which a software development team complete a set amount of work.

 

In simple terms, while the fixed price method of contracts sues for writing things in stone and giving the customer clarity on the product that they can expect, the cost that the product comes at and when they can expect the software product to be completed; agile is very much built on the condition that projects will not be cast in stone and that there will be continued ability to change project requirements and details as the project cycle progresses and as new things are discovered.

So as you can see, the fixed-price agile method is not the easiest concept to sell. The contradiction between both concepts is enough to show you why there are a lot of people opposed to the fixed-price agile methodology.

 

Two major issues come to mind when one thinks of fixed price agile projects:

 

  1. Managing Scope: How do you bring in the flexibility that is needed to make a project agile?

 

  1. How do you manage the constraint of fixed cost and schedule that are necessary for fixed-price projects?

This brings us to the next line of discussion.

 

Fixed-Price Agile Projects: How to Move Forward

 

A fixed price agile project can be challenging to pull off because most software development teams need the flexibility to make changes here and there in response to the client’s needs.

If you don’t manage it properly, that flexibility could get stunted in a fixed price agile arrangement.

 

However, there are ways to achieve agility even in a fixed price project. Below are ways through which you can make a fixed price agile project work for all parties involved:

 

Start with an MVP

At Sprinthub Mobile, we understand that most of our clients are very knowledgeable about their businesses, but we don’t expect them to understand what their software projects need upfront. 

 

Owing to this,  we usually advise that clients sit down with their software development company (us) to break the project into smaller projects.

 

After this, we can collaborate to come up with some “must-have” features that the product needs while we categorise other features as “nice to have”.

 

After doing these prioritisations at the beginning of the project, it is usually easier for us to guide our clients on how to get the maximal returns on investments.

 

This approach helps both parties to focus on what is important first and helps deliver a minimum viable product (MVP) that you can build upon.

 

The Fixed Price Should not be Cast in Stone

 

One of the most important tenets of the agile technique is it gives you the ability to make swift changes driven by business goals, focusing on new things that you consider more important as you move along in the software development cycle.

 

But remember, we already established that the fixed-cost technique often has the three main factors- money, time, and scope spelt out before the project is even started. 

So the question then becomes, how do these two concepts coexist?

 

The answer is simpler than you think. For an agile method to work with the fixed-price contract, there must be a change mechanism that allows both parties to manage the project employing agile methods while allowing the fixed contract to run its course.

 

The client and the software development company must agree on preset conditions that allow both parties to make changes to the project, the cost implication of the changes, and who bears the financial responsibility for the changes when signing the contract.

 

Opt for small-scale features-level contracts

 

Most times fixed-price contracts usually focus on the entire scope of the software development project. 

And as such, the project may need over 30 large features with longer timelines. This might be too much to scope under the agile method.

 

More so, the fixed-contract approach usually allows no chance for the software development team to garner feedback and the flexibility to change the scope as the need arises.

 

So, to make the fixed-price contracts work with the agile development method, you will have to opt for small-scale features and make sure that you keep the contracts t small-scale and as well limit it to a few features at a time.

 

With that, you give the team better flexibility while giving clients the allowance to pick the features that are important to their business goals as circumstances change.

 

Conclusion

It is glaring that fixed price agile projects are not particularly easy to pull off. The opposing philosophies of both project methods can stifle the proper functioning of a fixed-price agile project.

However, if some conditions are met, a fixed-price agile project can work. Some of these conditions that need to be met include:

 

  1. Making sure that the project is right for a Fixed Price engagement
  2. Focusing on Minimum Viable Product
  3. Maintaining a level of flexibility

 

After meeting these conditions, you will be well on your way to navigating the fixed price agile methodology and executing your software development project properly.

About the Author

Message Sent

Let's connect