All articles
Startups & BusinessNovember 7, 2026 6 min read

Change Request or Scope Creep? A Protocol for Telling Them Apart

Most agencies lose margin not to bad estimates but to changes they never logged as changes. Here's the protocol we use to separate real change requests from scope creep — without wrecking the client relationship.

Every agency has a story that starts with "it was just a small tweak." Three weeks later the sprint is blown, the PM is apologising, and someone on your side is eating the cost. The problem is rarely the tweak itself — it's that nobody drew the line between a change request and scope creep in time to do anything about it.

This is the protocol we use to draw that line. It isn't bureaucracy for its own sake. It's the thing that keeps fixed-bid projects from quietly turning into unpaid T&M.

The definitions that actually matter

Most teams use "change request" and "scope creep" interchangeably, which is exactly why they can't manage either. We force a distinction:

  • Change request: a deliberate, logged ask from the client (or from us) that alters agreed scope, timeline, or acceptance criteria. It has a paper trail and a price.
  • Scope creep: unlogged work that drifts into the sprint via Slack, hallway conversations, "while you're in there" comments, or an over-eager developer saying yes.

The mechanical difference is simple: a change request has been priced and accepted. Scope creep has not. Everything else — whether the change is big, small, reasonable, urgent — is secondary.

Why the distinction is worth defending

Clients don't wake up planning to abuse your team. Scope creep usually comes from goodwill: a developer wants to be helpful, a PM wants to avoid a hard conversation, a client assumes a small ask is small work. The result is the same regardless of intent — your margin disappears and your team burns out defending an estimate that no longer reflects reality.

If you can't name a change as a change, you can't bill it, schedule it, or decline it.

The intake rule: one door, no exceptions

The single highest-leverage policy we've adopted is this: all scope-adjacent asks go through one channel, and engineers don't make scope decisions in DMs.

In practice that means:

  1. Any ask that arrives via Slack, email, standup, or a hallway chat gets acknowledged — never rejected — and immediately mirrored into the project's change log.
  2. The PM (not the developer) decides whether it's in-scope, a change request, or a clarification.
  3. Engineers have a one-line script: "Good catch — let me loop in [PM] so we can get this scheduled properly."

This sounds obvious. It isn't. The failure mode on every agency project is a senior developer who wants to look responsive, agreeing to "just add a quick filter" in a Slack thread at 4pm on a Thursday. That filter is now in scope. Nobody priced it. Nobody adjusted the timeline. And when the sprint misses, the client points at the burndown chart.

The classification triage

When a new ask hits the log, the PM runs it through a three-question triage, in order:

  1. Is it already covered by the signed scope or a reasonable interpretation of it? If yes → in-scope, schedule it.
  2. Is it a clarification of ambiguous scope? If yes → log it as a clarification, confirm the interpretation in writing, schedule it.
  3. Does it change behaviour, add surface area, or alter acceptance criteria? If yes → change request. Stop work on that item until it's priced and signed.

Most disputes live in question two. We resolve them in favour of the client on small items (under roughly half a day of work) and formally on anything larger. The goodwill from eating a few two-hour clarifications is worth more than the revenue, and it makes you credible when you do draw the line on a real change.

The change request itself: keep it boring

A change request shouldn't read like a legal document. It should read like a receipt. Ours fit on one screen:

## CR-014: Add CSV export to admin orders view

**Requested by:** Priya (client), 2026-03-04
**Classification:** New feature (out of signed scope)

**Summary**
Add a "Download CSV" button to /admin/orders that exports
the currently filtered result set.

**Impact**
- Engineering: ~1.5 days (backend streaming + frontend button + tests)
- Design: none (reusing existing button component)
- QA: 0.5 day
- Timeline: pushes Sprint 7 delivery by 2 working days,
  OR defers CR-012 (bulk status update) to Sprint 8

**Price:** £1,850 fixed, or 2 days T&M at agreed rate
**Expires:** 2026-03-11

**Client decision:** [ ] Approve  [ ] Defer  [ ] Decline

Three things matter here:

  • The trade-off is explicit. Either the timeline moves or something else drops. We never let a client believe a change is free in time, even if they're willing to pay for the engineering.
  • The CR expires. Without a deadline, clients sit on decisions for weeks and then expect the original price. A seven-to-ten-day expiry forces a decision while the context is fresh.
  • It's numbered and logged. CR-014 lives in the repo, in the project wiki, and in the weekly status email. Nobody can later claim it was never discussed.

The weekly scope review

The protocol above only works if someone looks at the log on a regular cadence. We run a 15-minute scope review every Friday with the PM, tech lead, and client sponsor. The agenda never changes:

  1. CRs opened this week — status and decisions needed.
  2. Clarifications logged this week — any that should have been CRs?
  3. Items currently in sprint — any drifting toward CR territory?
  4. Decisions needed before Monday.

The second item is the one that saves projects. Every PM has a bias toward classifying asks as clarifications because it avoids a pricing conversation. Having the tech lead in the room creates a counterweight. If engineering is spending real time on something logged as a clarification, it probably wasn't one.

The war-story version

On a mid-size e-commerce build last year, we shipped a product listing page that the client had signed off on at wireframe, design, and staging. Two days before launch, the marketing lead asked for "a quick thing": the ability to pin featured products to the top of any category, with a scheduling window and A/B variant support.

The developer, trying to be helpful, said it was probably a day's work. It wasn't. It was a week, because scheduling and A/B meant data model changes, a new admin UI, and a cache invalidation path we hadn't planned for. By the time the PM caught it on the Friday review, three days were already gone.

We ate those three days. But we also wrote CR-031 for the remaining work, held the launch, and had a direct conversation with the client about what had happened. The client was fine with it — they'd assumed "quick" meant quick. The developer got a gentle reminder about the one-door rule. The protocol existed; we just hadn't enforced it.

When the client pushes back

Some clients will treat every CR as hostile. A few tactics that work:

  • Frame CRs as protecting the original budget, not inflating it. "If we absorb this, something you've already paid for gets cut or delayed. The CR is how we keep your signed scope intact."
  • Offer a change budget up front. On larger engagements, bake in a 10–15% change pool at kickoff. Clients draw from it without a new PO each time, and you both see the balance drop in real time. It reframes changes from adversarial to shared-resource.
  • Separate the pricing conversation from the technical conversation. Engineers shouldn't negotiate rates in the same thread where they're explaining why a feature is complex.

If a client refuses to accept any CR process, that's data. It usually means the next project with them will be worse, not better.

Where we'd start

If your agency doesn't have a scope protocol today, don't try to roll out all of this at once. Start with the one-door rule for a single project: every scope-adjacent ask goes through the PM, and engineers have a scripted response for Slack. Add the weekly 15-minute review the following week. Introduce formal CRs on the next new engagement, not a running one.

If you want to see how we structure this inside statements of work and delivery, our agency delivery services page outlines the contract scaffolding we use. The protocol is only as strong as the paperwork it sits on — but the paperwork is useless if your team still says yes in DMs.

#agency#scope#pricing#project management

Want a team like ours?

72Technologies builds production software for the kind of teams who actually read this blog.

Start a project