Handling Change Requests in a Fixed-Scope Software Project — Integrations & APIs article by Rui Codex

Handle a change request in a fixed-scope project by logging it, assessing its effect on scope, cost and schedule, and getting written approval before any work starts. Agree the change control process at kickoff, separate defects from new requests, and price each change as a documented amendment rather than absorbing it silently.

Key takeaways

  • A change request is any written or agreed deviation from the approved scope, including small changes that look harmless.
  • Every change should be assessed for its effect on scope, cost, schedule and risk before the team starts building.
  • Approved changes should be recorded as a signed amendment, so the baseline and the invoice stay aligned.
  • Some requests should be declined or deferred, and the reasons should be written down.
  • Changes that touch personal data or regulated processes need an additional review step.

What is a change request in a fixed-scope project?

A change request is any proposed deviation from the scope both parties approved at the start. It can add a feature, but it also covers a field format change, a different integration partner, or a report that moves from weekly to daily. Each of these alters the work, even when the request sounds small.

The fixed-scope model depends on a stable baseline: a list of requirements, a delivery date and a price. Changes are the mechanism that keeps that baseline honest. Without a defined process, requests arrive by email, in meetings and in chat, and nobody can say later what was agreed.

Tip: Write the change control rule into the contract or statement of work before kickoff, including who may submit requests and in what form.

Teams often confuse three things: defects, clarifications and changes. A defect is a deviation from an agreed requirement and is normally fixed within the original scope. A clarification resolves ambiguity in the requirement text. A change alters what was agreed. Keeping these categories separate prevents a bug fix from being billed as a new feature, and prevents a new feature from being hidden inside a bug ticket.

For connected systems, many small requests touch the same interfaces. A new field in an order form may require changes to an integration layer that the original estimate did not include, so the impact is often larger than the request suggests.

How do you assess the impact of a change?

Assess a change by tracing it through the parts of the project it touches: requirements, design, code, tests, data, infrastructure and documentation. The assessment answers four questions: how much work it adds, which existing work it affects, what it does to the delivery date, and what new risk it introduces.

A practical assessment follows a fixed sequence:

  1. Record the request with the requester, date, business reason and the requirement it changes.
  2. Identify affected components and dependencies, including third-party systems.
  3. Estimate effort for design, build, testing and deployment separately.
  4. Identify schedule effects, including any work that must move to make room.
  5. Note new risks, such as untested integrations or new data handling.
  6. Return the assessment to the requester within an agreed time.
Tip: Ask for the business reason before pricing. A request that solves a stated problem can often be met with a smaller change than the one first proposed.

Estimates fail most often in integration work, where the hidden cost sits in data mapping, error handling and test environments. Before estimating, check the existing interface documentation and the test data available. If those do not exist, the estimate should say so, because the uncertainty is part of the impact.

How should a change be priced and approved?

A change should be priced from the assessment and approved in writing before work begins. The approval should state the scope change, the effect on the price and the date, and the person authorised to sign for each party.

There are three common pricing approaches, and each fails in a different way:

  • Time and materials for the change: transparent, but the client bears the risk of an underestimate.
  • Fixed price for the change: predictable, but it fails when the assessment missed a dependency.
  • Absorbed within contingency: smooth for small items, but it hides scope creep and drains the buffer meant for real risk.

Absorbing small changes is tempting, but it should be a deliberate decision with a limit. A useful rule is to absorb only changes below an agreed effort threshold and record every absorbed item in the change log, so the cumulative effect stays visible.

Teams that deliver custom work can use a standard change template and a shared log. Rui Codex describes its approach to custom development on its custom software services page, and the same discipline applies whichever team builds the software.

When should a change be declined or deferred?

A change should be declined or deferred when it conflicts with the agreed goal, when the budget or schedule cannot absorb it, or when the business value is unclear. Deferring is often better than declining, because the request can return in a later phase with better information.

Watch for these signals that a change should wait:

  • It depends on a system or data source that has not been confirmed.
  • It would require re-testing of parts already accepted by the client.
  • It is a preference that does not solve a stated problem.
  • It would push a critical milestone past its committed date.

When declining, explain the reason in terms of the agreed scope and offer alternatives, such as a smaller version or a later release. A short written record protects both parties if the question returns during acceptance testing.

Tip: Keep a parking lot list for deferred requests and review it at each milestone, so good ideas are not lost and not forced into the current scope.

If the change involves selecting a delivery partner or reviewing how a team handles scope, the guide on choosing a software development partner in Belgium covers the contract questions to settle early.

Does a change ever need a data protection review?

Yes, a change that adds or alters personal data processing should be reviewed before it is built, because the data protection obligations apply to the new processing. The EU General Data Protection Regulation sets out the principles and duties that apply, and the official text is available on EUR-Lex. This article is general information and not legal or tax advice.

In practice, the change log should flag any request that adds a new personal data field, a new recipient, a new storage location or a new purpose. Those flags trigger a review by the client's data protection contact, who decides whether an assessment is needed. The engineering team can describe the data flow, but the legal conclusion belongs to the client.

Rui Codex offers technical implementation support for such changes, but it does not provide legal, tax or compliance advice, audits or certification.

Hypothetical examples

Here are two hypothetical scenarios:

Scenario one. A project team is building an order portal with a fixed scope. The client asks to add a delivery date field to the order form. The team logs the request, traces it to the order database and the warehouse interface, and reports that the change is small in the interface but requires a new test case. The client approves the change as an amendment, and the schedule moves by the agreed days.

Scenario two. During the same project, the client asks to replace the shipping integration with a different provider in the final month. The assessment finds that the new provider's interface is undocumented and that the test environment is not available. The team recommends deferring the change to a second phase, and the client agrees after reviewing the risk note.

Tip: In both scenarios the decision depended on the written assessment, not on the size of the request as the client first described it.

Frequently Asked Questions

What should a change request contain?

A change request should contain the requester, the date, the business reason, the requirement it changes and the desired outcome. Without the business reason, the team cannot judge whether a smaller change would solve the same problem.

Can a small change be absorbed without a written amendment?

A small change can be absorbed only if the contract allows it and the team records it in the change log. Absorbing without a record makes later disputes hard to resolve, because the baseline no longer matches what was delivered.

Who has the authority to approve a change?

The person named in the contract as authorised to change scope should approve the change in writing. In many projects this is a client project owner and a supplier project manager, and their names should be stated in the amendment.

How do you handle a change that arrives during testing?

A change during testing should be assessed separately, because it may require retesting of accepted functions. Record the regression effort, agree whether it is in scope, and schedule the change for a later release if the test window cannot absorb it.

Conclusion

Change requests are a normal part of software delivery, and a fixed-scope project can handle them well when the process is defined early. Log every request, assess its effect across the system, price it in writing and decline or defer when the case is weak. Keep the change log current, and treat data protection and integration risks as first-class items. If you are planning a project and want a structured review of how changes will be handled, request a project consultation or email info@ruicodex.com.

Sources

Tags: change requests fixed-scope projects change control software project management scope management API integration project governance custom software development

Need Help Implementing This?

Our team can help you put these insights into practice. From AI automation to custom software development, we build solutions that deliver real results.

Send a project request