Scope creep and scope change can be the exact same work. The only difference is whether someone agreed to it: creep grows without approval, a new price or new dates, while a scope change is that growth agreed in writing, with its effect on price and timeline spelled out.

A change order is the paper that moves a request from the first bucket to the second. So the two terms aren't opposites so much as before and after.

Think of it like version control

If you write code, this maps neatly:

  • Change request = an issue. Someone asked for something. On its own it changes nothing.
  • Scope change = the decision to merge. Both sides agree the work is changing, and how.
  • Change order = the merged commit with a message: what changed, what it costs, how the dates move, and who approved it.
  • Scope creep = editing production directly. The real project changes, but the history (your written scope) doesn't.

That last one is why creep hurts. The written scope and the real project drift apart, and nobody can point to when.

Where the definitions come from

In a 2012 PMI PM Network discussion on preventing scope creep, consultant Trevor K. Nelson says "change and creep are not the same": creep is work outside the scope done "without approval" and "without an agreement for additional payment," while a scope change is acknowledged by the person in charge.

Chuck Millhollan, in a PMI Global Congress paper on scope change control, adds the part people forget: "scope change is inevitable," and the job "is not to stop scope change, but to successfully manage that change."

So the goal isn't to refuse changes. Clients learn things mid-project. The goal is to make every change a decision instead of a drift.

Side by side

Scope creep Scope change Change order
What it is Work grows, agreement doesn't Agreed change to the work Written record of that agreement
Starts with "Can you just..." A request that gets assessed You draft it after assessing
Approval None, or assumed Explicit and written It is the approval
Price You absorb it Agreed before work (can be zero or a credit) Stated on the document
Dates Old deadline stays, team squeezes Moved or confirmed Stated on the document
Direction Almost always more More, less, or a swap Whatever the change is
The written scope Stays the same while real work grows Updated to match Becomes part of the scope record

The row worth staring at is the last one. With creep, scope and reality diverge. With a scope change, they line up again.

One request, two outcomes

Hypothetical example. A studio is building a five-page site for a fixed fee. Midway, the client asks: "Could we add a simple blog? Just a listing page and a post template." The studio estimates about 8 hours, or $600 at its rate.

Path A (creep): "Sure, no problem." The blog gets squeezed in, launch slips a few days, and nobody connects the delay to the blog because it was never written down. Then the client asks for categories, because "all blogs have categories." Creep on top of creep.

Path B (change): "Happy to add that. It's outside the five pages we agreed, so it'd be $600 and move launch by three working days. Want me to send the change order?" The client says yes, signs a one-page change order, and the scope now says six templates. When categories come up later, there's an up-to-date scope to check them against.

Same client, same blog, same hours. Only Path B gets paid and keeps the next request easy to judge.

Turning creep into a change

  1. Have a scope you can check against. If the scope never listed what was included (and excluded), nothing can be called extra.
  2. Catch it at the request, not the invoice. Before anyone opens a file is the cheapest moment.
  3. Name it neutrally. "That's outside what we agreed, so here's what it would take" is enough.
  4. Describe the change and its effect. What's added, removed or swapped, the cost (including knock-on rework), and the date impact.
  5. Get the yes in writing before work starts, from the person who can approve spending.
  6. Update the scope and log it. Skip this and the change starts creeping again.

The UK government's project delivery guidance (Teal Book, chapter 22 on change control) tracks each change through statuses: requested, assessed, approved, deferred, implemented, closed. A column in a spreadsheet does the job for a small team. What matters is that "requested" and "approved" look different, so nobody builds something that's only been requested.

If the work is already done, you can still send a change order, but the client never got to say no, so expect pushback.

How an approved change slides back into creep

This is where teams lose money after doing everything "right":

  • The change grows after approval. "Blog listing plus one post template" becomes categories, an author page, a newsletter box. Each is a new request.
  • The scope doc never got updated. The change order lives in an inbox while the brief still says five pages. Millhollan's paper warns about "stakeholders with bad memories about what was (or was not) in scope."
  • The approval was fuzzy. "Yes, go ahead" on a call with no price is approval of an idea, not of a cost. In Millhollan's words, "there's no such thing as informal change control."
  • The wrong person said yes. Name the approver at kickoff.
  • Knock-on rework wasn't priced. A new blog can mean reworking the nav, footer and sitemap. If only the new pages were priced, the rework is creep inside an approved change.

Hypothetical example. A freelancer has an approved change order for two extra landing pages. Once they're built, the client asks for A/B tests with three headline variants each. That's testing work, not landing pages, so it gets its own quote.

What isn't creep

  • Included revisions. If the scope gives two rounds, those two rounds aren't creep, however annoying.
  • Fixing your own mistakes. The fee already covers them.
  • Gold plating. Extra polish your own team adds without being asked. It eats hours too, but you can't bill it; you just stop doing it.
  • Scope gaps. Work that was always needed but never written down (a cookie banner, a content migration). Not creep, but it still needs a decision on who pays, so treat it as a scope change.
  • Expected detail. "Two homepage concepts" doesn't specify photos or headlines; filling those in is the job. It becomes creep when two concepts turn into four.

Habits that keep changes from creeping

  • Write exclusions, not just inclusions.
  • Put a one-paragraph change rule in the contract: extras need written approval on price and dates before work starts.
  • Keep one channel for requests.
  • Check each request against the scope before you reply. Most creep happens in the reply.
  • Keep a change log: number, date, what changed, price, dates, approver, status.

If you want a starting point for the document itself, there's a free change order template. A spreadsheet works too. The check matters more than the tool.

Originally published at creepless.online. This version was drafted with AI assistance.