StackLift
All terms

Glossary

Change request

A formal, priced change to agreed scope after a project starts.

A change request is a formal, explicitly-priced change to the agreed scope of a project after work has started - captured against the original baseline rather than quietly absorbed, so cost and timeline stay honest.

Because StackLift carries one source of truth from estimate to proposal to delivery, post-kickoff changes are logged and priced transparently instead of causing scope creep.

Start in 60 seconds

Put this to work on your project.

Get an AI-assisted, architect-reviewed scope, cost range, and timeline. Free, no login.

The complete guide

Change request: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

A change request is a formal, written proposal to change the agreed scope of a project after work has started. It describes what changes, why, and what it does to cost, timeline and risk, and it is approved before work begins. This keeps the original baseline clear and stops scope from growing unnoticed.

What is a change request?

A change request is how a project handles the fact that people change their minds. Once scope, budget and schedule are agreed, anything that alters them goes through a visible step: someone describes the change, someone assesses its effect, and someone with authority says yes or no.

The request is measured against a baseline, the agreed version of scope, cost and timeline. Without a baseline, there is nothing to compare against, and every addition feels like a small favor until the total is out of hand.

A change request is not a sign that something went wrong. Learning during a project is normal and healthy. The request is the tool that lets you act on what you learn without losing control of the budget.

Why do change requests matter?

They protect both sides. The client sees what a change costs before agreeing. The delivery team is not asked to absorb unplanned work for free, and not blamed for delays that come from added scope.

  • They prevent scope creep, the slow growth of a project through small unrecorded additions.
  • They keep cost and schedule honest, since each change shows its effect up front.
  • They create a decision record: what changed, who approved it and why.
  • They force trade-offs: adding something often means dropping or delaying something else.
  • They keep the team's attention on the agreed plan instead of a moving target.

A well-run change process makes teams more flexible, not less. Because changes are easy to propose and clear to price, people raise them early, when they are cheapest.

What counts as a change, and what does not?

Not every adjustment needs a formal request. The test is whether the work falls inside the agreed scope and its acceptance criteria.

Change or not?
SituationChange request?Why
Fixing a defect against the agreed behaviorNoIt is part of delivering the agreed scope
Clarifying a detail the written scope left openUsually noResolve it by decision, and record it
Adding a feature not in the baselineYesNew scope with new effort
Changing how an agreed feature works in a way that needs reworkYesWork already done may be lost
Adding an integration or user roleYesMore surface area to build and test
Moving a deadline earlierYesAffects plan and resourcing
Swapping one feature for another of similar sizeOften yes, as a tradeNeeds agreement on what leaves

When in doubt, write it down and assess it. A short note that says "no change needed" is cheaper than a dispute later.

How does a change request process work?

  1. Raise: anyone on the project describes the change in plain words and why it is needed.
  2. Log: the request is recorded with a date, an owner and a status, against the baseline.
  3. Assess: the delivery team estimates effort, cost, timeline effect, risks and any dependencies. See software estimate.
  4. Decide: the approver, usually the business owner, accepts, rejects, defers or asks for a different option.
  5. Update: if approved, the baseline changes, including scope, schedule and budget.
  6. Build: the work is planned into a sprint like any other item.
  7. Close: the change is verified against its own acceptance criteria and the record is closed.

The record of each change, not only the decision, matters later. Months on, it explains why the product looks the way it does.

What should a change request contain?

A useful change request form
FieldWhat to write
Title and requesterA short name and who asked
DescriptionWhat should be different, in plain words
ReasonThe problem it solves or the opportunity it creates
Acceptance criteriaHow you will know it is done
Impact on scopeWhich agreed items it adds, changes or replaces
Impact on cost and timelineThe estimate, expressed in the same units as the original
Risks and dependenciesWhat could go wrong, and what must happen first
OptionsCheaper or smaller ways to get most of the value
Decision and dateApproved, rejected or deferred, by whom

Offering options is a mark of a good process. A client who sees a lighter alternative can choose it without feeling pushed.

How are changes priced?

The same way as the original work, so numbers are comparable. If the project was scoped in story points, a change is estimated in story points and priced on the same basis. Pricing by deliverable complexity, not by hours, keeps the logic consistent from the first estimate to the last change.

Costs usually come from new work, rework of finished work, retesting and the effect on other items. Smaller changes that fit into spare capacity may cost little, but they should still be visible. For how estimates are built, see the software estimation playbook.

What do real change requests look like?

These examples are typical of software projects in general and are not drawn from any named client.

  • A customer portal project adds single sign-on with a company identity provider after the first demo, because the client's IT team requires it.
  • A booking product needs a second payment method for a new market, which touches checkout, refunds and reporting.
  • An internal tool gains a new approval step because a regulation changed, which affects several screens and email notices.
  • A marketplace asks to move its launch date earlier for an event, which means trading some planned features for a later phase.
  • An AI assistant project adds a second knowledge source after testing shows users ask about a topic the first source does not cover.

In each case the useful move is the same: describe it, estimate it the same way as the original work, show the effect on timeline and offer a lighter option.

How do you reduce the number of changes?

You cannot remove change, but you can make most of it cheaper and earlier. Most expensive changes come from things that could have been learned before building.

  1. Invest in a proper discovery phase so requirements, users and integrations are clear before build.
  2. Write user stories with acceptance criteria that everyone can read.
  3. Show working software early and often, so reactions arrive while changes are small.
  4. List what is out of scope, as well as what is in, and keep that list in the baseline.
  5. Prioritize with the MVP mindset: build the core first and defer the rest.
  6. Name one decision maker, so changes are not argued from several directions.

The MVP feature prioritization playbook can help you decide what truly belongs in the first release.

Do change requests fit with agile delivery?

Yes. Agile welcomes change, and a backlog already absorbs reordering and new ideas. The difference is what is fixed. In a fixed-scope or fixed-budget engagement, new work either replaces something of similar size or adds to the budget.

Many teams use both layers. Day-to-day reordering inside the agreed scope and budget needs no formal request. Anything that grows the total, or breaks a commitment such as a launch date, goes through one. See fixed-scope vs. hourly billing for how billing models change the conversation.

What mistakes should you avoid?

  • Saying yes in a meeting and recording nothing, which creates unpriced scope.
  • Making the process so heavy that people avoid it and ask informally.
  • Estimating changes in a different way from the original work.
  • Approving without checking the effect on the schedule and other items.
  • Treating clarifications as free and then discovering they were new features.
  • Forgetting to update the baseline, so the next change is measured against stale numbers.
  • Letting the person who benefits from the change be the only one to approve it.

How do you know your change process works?

  • Every scope change has a record with an estimate and an approver.
  • Changes are assessed quickly, so decisions do not stall the team.
  • Final cost and schedule can be explained as the baseline plus approved changes.
  • Few surprises at handover: no one is asking "why does this cost more than agreed?"
  • The number of changes falls over time as discovery improves.

A steady trickle of well-handled changes is healthy. A flood suggests the original scope was thin; revisit discovery.

What do change requests mean for cost and timeline?

The size of a change depends on how much new work it adds, how much finished work it disturbs, how many other parts it touches and how late in the project it arrives. A change after launch of a related feature costs more than the same idea raised during scoping.

Most first versions take 6 to 16 weeks depending on scope, and well-scoped projects have fewer changes. A free estimate gives a feature-by-feature baseline, and the AI Scope Sprint produces a detailed scope, user stories, tech stack, cost and timeline range in three days.

How StackLift handles change

Estimate, proposal, project and client portal share one baseline, so change is explicit. Post-kickoff changes are logged and priced transparently instead of becoming scope creep. Every estimate is reviewed by a senior architect before it becomes a commitment, and scope, budget and delivery path are agreed before engineering begins.

Clients see live project state, approvals and invoices in the client portal. See how delivery works and the software handover checklist.

Questions people ask

What is the difference between a change request and a change order?

They describe the same idea. Change order or variation order is the contract term, common in construction and procurement. Change request is the term used when the proposal is being raised and assessed, and it becomes an order once approved and priced.

Is a change request the same as a bug report?

No. A bug is behavior that does not match what was agreed, and fixing it is part of the work. A change request alters what was agreed.

Who approves a change request?

The person with authority over scope and budget, usually the client's business owner, with the delivery lead confirming the estimate. Name the approver at the start of the project.

Can a change request be rejected?

Yes. It can be rejected, deferred to a later phase or reshaped into a smaller option. A recorded rejection is still useful.

How long should assessing a change take?

Small changes should be assessed within a few working days. Larger ones may need a short design step. Agree the expected response time up front.

Do change requests slow down projects?

A light process adds little time and saves much more by preventing rework and disputes. A heavy one slows things, so keep the form short.

What if a change makes the project cost more than planned?

That is what the request shows you before you commit. You can approve it, choose a smaller option, drop something of similar size or defer it.

How do change requests work with a fixed-price contract?

The fixed price covers the agreed scope. Changes outside it are priced separately and added to the baseline once approved.

Should I include a change process in the contract?

Yes. State how changes are raised, assessed, priced and approved, and who signs. It prevents disagreements.