Why We Engage Almost Exclusively on Retainers

We have made a deliberate choice to engage with clients almost exclusively through monthly retainers rather than fixed bids.

Why? There are several reasons:

The Frustrations of Fixed-Price Agreements

Fixed-price agreements often start with a predetermined price and timeline for the project.
However, a project’s requirements will inevitably change as new requirements are discovered and additional needs are clarified. This leads to a need to amend the original agreement and adjust the price and timeline accordingly.

These kinds of amendments necessitate back and forth, and are not only frustrating for both the client and the software development team, but will take additional time that could have been spent more efficiently working towards completing the project.

We have found that more often than not, fixed-price agreements give a false sense of security. They obfuscate the fact that, at the start of the project, no one deeply understands the ins and outs of what is being built in full detail. As a result, many software development agencies will inflate their estimates in an attempt to compensate for this, or they will underbid with the intent to renegotiate partway through the project.

We’d rather just be transparent about this inherent uncertainty from the start and charge our clients for the work that’s actually necessary to complete the project.

Ambiguity of Scope

Even if a project’s feature set were to remain the same from start to finish, there is still ambiguity about what is in scope vs. what is out of scope.

Take for example a spec doc that lists “password reset.” Does this mean a simple password reset by email? Or does it mean a more elaborate two-factor authentication process with magic links? The degrees of complexity here can be many magnitudes different, and it’s nearly impossible to have a perfect understanding of a software project’s technical requirements right from the start.

This ambiguity can lead to disputes and disagreements about project boundaries, causing strain on the client-developer relationship.

Rather than going over a spec doc with a fine tooth comb, discussing each line at length before cementing it in a fixed-price agreement, and then inevitably renegotiating as issues come up, we prefer to begin work with a clear, broad-strokes understanding of the project, and then go into the nitty-gritty of each feature as it makes sense for the process of development.

With this approach, we guarantee that the client’s budget will be used as efficiently as possible every step of the way.

Flexibility and Collaborative Approach

The retainer model fosters collaboration and flexibility because it allows the client to actively engage in redefining their requirements as new data and solutions emerge.

This collaboration helps us gain a deeper understanding of our clients’ needs, and together we can work towards most efficiently achieving their goals.

Avoiding Conflict and Ambiguity

Fixed-price agreements often become contentious when clients envision complex features while the software development team aims for simpler implementations. This is because the fixed bid agreement necessarily pits the objectives of the client and the agency against each other: the client wants to get the most sophisticated feature for their money, and the agency is looking to implement the simplest functional solution.

When working with an hourly retainer, we avoid this kind of conflict entirely. Instead we can present our clients with the cost/benefit analysis for these kinds of features and let them make the decision about what they want. This way, instead of being pitted against each other, we put ourselves on the same team and can work together towards optimized solutions.

Additionally, it’s worth noting that fixed-price agreements are inevitably amended many times throughout a project, and as such, are an illusion that creates a false sense of security at the start of the project.

Ultimately, we’ve found that engaging on hourly retainers promotes a more productive and aligned relationship between our team and our clients. We can avoid the frustrations, conflicts, and unmet expectations that come with fixed-price arrangements, and instead forge an alliance that allows us to navigate obstacles, embrace uncertainty, and build better software.