Why Hidden Change Request Fees Are Killing Your IT Projects

Picture this: you've hired a software agency to build your business's new system. You've signed the contract, agreed on a price, and kicked off the project. Three months in, you're excited — the system is taking shape and you can finally see what's possible.

Then you have a new idea. A small tweak to how the reporting works. Maybe a different flow for user onboarding now that you've actually seen how the system feels to use. Perfectly reasonable — it's your system, and you're refining it based on real understanding.

Your project manager gets back to you with a quote. RM5,000 for the reporting change. RM3,200 for the onboarding tweak. CR-001 and CR-002.

What Are Change Request Fees?

A change request (CR) fee is what many software agencies charge when a client requests any modification that falls outside the original scope document. On paper, it sounds reasonable: you agreed on X, you're now asking for Y, and Y costs extra.

In practice, it's one of the most client-hostile billing models in the entire technology industry — and it's considered standard practice.

The Original Sin: Scope Documents Are Incomplete by Nature

Here's what no agency will tell you upfront: the initial scope document is, by its very nature, incomplete. Not because your project manager is incompetent. Not because you failed to think things through. But because software development is a process of discovery, and you cannot fully discover what you need before you've seen what's being built.

Think about it. You're asked to describe, in precise detail, a system you've never used, built on technology you may not understand, solving problems that will only become fully clear once development starts. You do your best. You write a requirements document. You answer every question put to you.

But the moment you see the first working prototype, you'll know things you didn't know before. You'll see a flow that needs changing. You'll realise a feature you thought you wanted isn't what you actually need. You'll discover something essential that nobody thought to put in the original scope.

How CR Fees Become a Business Model

The charitable explanation for CR fees is risk management: agencies want to protect themselves from clients who keep expanding scope indefinitely, burning developer time without paying for it. Scope creep is a genuine problem in software development, and this concern is real.

But here's what happens in practice: CR fees stop being a protection mechanism and become a revenue model.

Agencies learn that clients will discover gaps during development. They learn that clients will have new ideas as the system takes shape. So instead of building this expected discovery into the project price, they scope narrowly — knowing that the real margin comes later, in CRs.

The Hidden Costs Beyond the Invoice

The financial damage from CR fees is painful but visible. The hidden costs are often worse — and they compound throughout the project.

The Misaligned Incentive at the Heart of the Problem

The financial costs are real. But the deepest problem with CR fees isn't financial — it's structural.

When an agency charges for change requests, they are financially incentivised to have more change requests. A well-scoped project that runs cleanly to completion is less profitable than one that generates five CRs along the way.

This creates a perverse incentive: the agency profits from ambiguity. From vague scope documents. From missing requirements. From not asking the right questions upfront. Every gap in the original specification is a future revenue opportunity.

The client's interests and the agency's interests become structurally opposed. The client wants fewer CRs. The agency's margin grows with more. This is not a foundation for a genuine partnership.

Why Discovery During Development Is Normal — and Should Be Free

Here's the engineering reality that no agency's sales team will explain to you.

Software requirements that seem clear on paper often reveal their complexity during implementation. A data model that looked simple in a spreadsheet needs three additional fields to work correctly in practice. A user flow that seemed obvious on a wireframe creates friction when real users interact with it. A reporting feature that seemed straightforward requires a different database query structure than originally planned.

These discoveries aren't failures of planning. They are the natural result of moving from abstract descriptions to concrete, working software. They happen on every project, for every client, at every competent agency.

The difference is who absorbs the cost.

The $0 CR Fee Model: How It Actually Works

When we tell clients that Heartbyte charges $0 for change requests, the natural question is: how do you stay profitable?

The answer is that we build the reality of iterative discovery into our project pricing from the start. We scope honestly, price for the full journey — including the refinements that will inevitably come — and plan for the fact that good software evolves during development.

What we don't do is quote low to win the contract and then make our margin on CRs. That model is profitable in the short term and catastrophic for client relationships. We've seen what it does to clients, and we've chosen a different path.

There are limits, of course. Zero CR fees means scope refinements, feature adjustments, and reasonable evolutions of the original brief. It doesn't mean unlimited new features with no impact on timeline or budget. If a client wants to significantly expand the project — adding an entirely new module, pivoting the product direction — that's a conversation about a revised project, not a change request.

But the adjustments, refinements, and discoveries that happen in any normal software project? Those are part of the service. Always.

Red Flags to Watch For When Hiring a Dev Agency

If you're evaluating software agencies, here's what to look for before you sign anything.

The Future Is Client-First

The CR fee model exists because the software industry has historically had more leverage than its clients. Technical complexity creates information asymmetry: clients don't know enough about software development to know when they're being overcharged or when a "necessary" change request was actually a gap the agency should have anticipated.

That's changing. Clients are more informed. Word spreads. The agencies that build genuine trust — by treating clients as partners rather than revenue opportunities — are the ones that build sustainable, referral-driven businesses.

Zero change request fees isn't a gimmick or a loss-leader. It's a commitment to aligning our incentives with yours. When you succeed, we succeed. When your system does what your business actually needs, that's the outcome we were both working toward.