Business

Change Requests in a Software Project: A Process That Keeps Scope and Trust Intact

November 11, 2026 · 6 min read · Etzal Group Team

Halfway through a project, a department head asks the developer directly for an extra report. The developer, wanting to help, builds it. Three more requests follow by the same route. At the end, the vendor presents an invoice for forty additional days, the client's sponsor says nobody approved them, and both sides are sincere. The software is fine. The relationship is not. Handling change requests through a simple written process prevents this without slowing the project.

Why change is normal

A requirement written in month one describes what people believed they needed before they had seen anything. When working screens appear, they learn. Regulations move, a competitor launches something, a manager is replaced. A project with no changes at all is usually one where nobody is paying attention.

The problem is never change itself. It is change without three things: a record, an assessment of impact, and a decision by someone with authority.

First, sort the request

Not everything a user asks for is a change. Sort it into one of three kinds.

  • Defect. The software does not do what the agreed requirement says. Fixed by the vendor at no charge.
  • Clarification. The requirement was ambiguous and this settles a detail within its evident intent. Normal work.
  • Change. Something new, or different from what was agreed. Goes through the process.

Most arguments are about the boundary between the second and third. Good acceptance criteria written in advance make the boundary visible. Where it is honestly unclear, a habit of splitting the difference on small items keeps goodwill.

The process on one page

1. Anyone may raise a request, in writing, through one channel. A form, a ticket, an email to the project manager. Not a hallway conversation with a developer. Developers are instructed to answer, kindly, "please send that to the project manager".

2. The vendor assesses the impact within an agreed time, for example three working days:

  • What needs to be built or altered.
  • Effort and cost.
  • Effect on the schedule.
  • Effect on other parts of the system, on testing and on data.
  • Risk.

3. The client decides. Approve, reject, or defer to a later phase. The decision is made by the named approver.

4. Approved changes are added to scope in writing: the plan, the price and the acceptance criteria are updated.

5. Everything is logged. One list both sides can see.

Nothing is built before step 3. That single rule removes most disputes.

The form

Keep it short enough that people will use it.

  • Number and date.
  • Requested by.
  • Description: what should be different.
  • Reason: what problem it solves.
  • Priority: must have for go-live, or can wait.
  • Impact assessment: effort, cost, schedule, affected areas. Filled in by the vendor.
  • Decision: approved, rejected or deferred, by whom, on what date.

The "reason" field matters. Often the problem behind the request can be solved in a cheaper way than the one proposed.

Pricing changes fairly

Agree the rules in the contract, before the first change arises.

  • Day rates per role, fixed for the duration of the project.
  • Estimates given before work starts, with a commitment not to exceed them without approval.
  • Small changes handled by a pre-agreed allowance. For example, the contract includes a contingency of 10 percent of the build price, drawn down by approved change requests. Small items do not need a new purchase order each time.
  • Swaps. A change may be exchanged for removing something of similar size that has not yet been built.
  • Cost of assessment. For large changes, the analysis itself takes days. Agree whether that time is charged.

A vendor who quotes a low project price and high change rates is planning to earn on changes. Compare the rates when you compare proposals.

Approval limits

To keep things moving:

  • Below a small threshold, the client's project manager approves.
  • Above it, the sponsor approves.
  • Anything affecting the go-live date goes to the steering group.

Decisions should take days. A change request that waits three weeks for a signature does more damage to the schedule than the change itself.

The change log

A table kept current:

No.DescriptionRequested byCostSchedule effectStatus
1Add delegation of approvalsFinance4 daysNoneApproved
2Export stock report to spreadsheetWarehouse1 dayNoneApproved
3Second language for customer portalMarketing15 daysPlus 2 weeksDeferred to phase 2

Review it at every progress meeting. Show the running totals: approved cost so far, and cumulative effect on the date. Small approvals add up, and the totals keep everyone honest about why the end date moved.

Deferring is a decision too

"Not now" is often the best answer. A phase 2 list gives good ideas a home without disturbing the current release. It also tests them: a surprising number of urgent requests are no longer wanted three months later.

For each request, ask whether go-live can happen without it. If yes, it is a candidate for phase 2.

Common mistakes

  • Verbal approvals.
  • Developers accepting requests directly.
  • No impact assessment, so cost is discovered afterwards.
  • Treating defects as changes, which the client rightly resents.
  • Treating changes as defects, which the vendor cannot sustain.
  • No single approver.
  • A log nobody reviews.
  • A process so heavy that people route around it.

Late changes cost more

A change during design alters a document. The same change after testing alters code, tests, data, training materials and manuals. This is why time spent on prototypes and reviews early is cheap, and why a freeze before user acceptance testing is reasonable: after the freeze, only defects are fixed and new ideas go to the next phase.

We run this process on our own projects and include the form and log in our project setup. See how we work in Enterprise Software, or contact us if a project you are running needs its scope brought back under control.

Summary

Expect change and give it a path: one channel, a short form, an impact assessment, a decision by a named approver, and a log reviewed at every meeting. Separate defects and clarifications from true changes. Agree rates, an allowance and approval limits in the contract. Build nothing before approval, defer what can wait, and freeze scope before acceptance testing.

Frequently asked questions

Is every small adjustment a change request?

No. Corrections to work that does not meet the agreed requirement are defects, and they are fixed at the vendor's cost. Clarifications that fit within the agreed scope are normal work. A change request is for something new or different from what was agreed, even if it is small.

Who should approve change requests?

One named person on the client side with authority over budget and scope, usually the project sponsor or owner. Requests from users go through that person. Set a value limit below which the project manager may approve alone, so small changes do not wait for a meeting.

How can we reduce the number of change requests?

Spend more time on requirements and prototypes before the build, involve the people who will use the system, and deliver in short releases so misunderstandings appear early. Changes will still happen, because the business learns as it sees the software. The aim is fewer surprises, not zero changes.

Author

Etzal Group Team

Etzal Group Team, helping businesses grow with technology. Contact us.

Related service

Free consultation

Not sure where to start? We will map the right system for your business, free.