A client emails you three weeks into a project.
"Hey, while you're in there, can you just do a quick thing for me? The logo in the footer is sitting a pixel or two off. Should be a two-minute fix."
You read it. You know the answer.
Two minutes.
You open the file. The footer component is shared across twelve pages, and the logo alignment is driven by a grid variable that cascades into the header, which means you now have to audit the header too. The "two minute fix" is forty minutes. You ship it, say nothing, and keep working.
A week later the client asks for another quick thing. Then another. By the end of the project you've done about six hours of unpaid work and you're mildly resentful but can't quite point to where it went wrong. You close the project on time, take a small loss you didn't notice in the quote, and promise yourself next time you'll push back.
Next time, you do the same thing.
Why "quick thing" is almost always a lie, without anyone lying
The client isn't being manipulative. When they said "two minutes," they meant it. They looked at the logo, imagined dragging it two pixels, and estimated the time it would take them to drag it two pixels. They weren't thinking about your grid system, your breakpoints, your component reuse. They weren't hiding anything. They just don't have the context.
This is the central mechanic of scope creep. The person asking genuinely believes the request is small, because they're pattern-matching against the visible surface of the work, not the structure underneath. When they say "quick," they mean: it looks quick to me.
And because they sincerely believe it, pushing back feels to you like you're arguing with an honest person over two minutes of your time. Which is why, in the moment, you don't.
The compounding is what kills the project
One quick thing is fine. Two is fine. The danger isn't any individual request. It's that every silent "yes" shifts the baseline of what the client assumes is included.
By request number four, the client isn't asking anymore. They're telling you what they assume you'll do as part of the job, and "out of scope" has quietly stopped existing as a category in their head. The brief you signed a month ago doesn't get referenced anymore, because none of the recent work was framed against it.
Here's the math that nobody runs:
- Quick thing #1: 40 min
- Quick thing #2: 25 min
- Quick thing #3: 90 min (more than advertised)
- Quick thing #4: 20 min
- Quick thing #5: 2 hours (turned out to involve a third-party API)
That's a little over four hours. On a $2,500 project, that's a 7-9% margin hit, often the entire profit on the engagement. You don't notice because it's spread across weeks, and because each individual ask felt like a rounding error.
The real reason you keep saying yes
It isn't because you're bad at business. It's because every individual refusal feels disproportionate to the size of the ask.
"Can you shift this two pixels?" "That'll be $75."
Reading it, it sounds ridiculous. You can't imagine saying that to another human being. So you do the work, swallow the cost, and quietly promise yourself you'll push back next time, when the ask is bigger and the refusal will feel "proportionate."
But the ask is never bigger. The whole point of the "quick thing" pattern is that it stays below your threshold for pushing back. That's not a coincidence; it's the shape the problem takes.
The trick is to stop evaluating each request in isolation.
The one sentence that breaks the pattern
You don't need a confrontation. You need a template that routes every out-of-scope ask, small or large, through the same language, so it doesn't feel personal or selective.
"Happy to do that. It's outside the brief, so I'll add it as a small change order (takes about [X] minutes), and that way it doesn't displace the work we've already lined up for launch."
Three things this sentence does:
- "Happy to do that": you said yes. The client feels met.
- "Outside the brief": you named it, calmly. You didn't make it about money; you made it about a document you both signed.
- "Doesn't displace the work we've already lined up for launch": you framed the change order as protecting their timeline, not protecting your bank account.
The price is there, but it's secondary. The real payload is the framing: every new request gets structured, every structured request is either done as a change order or consciously dropped. No silent absorption.
"But it really is two minutes, just this once"
Here's the test that saves you: even if it is two minutes, reply as if it isn't.
The cost of using the structured reply on a genuinely two-minute task is almost zero. The client reads one extra sentence and moves on. The cost of not using it on something that turns out to be forty minutes is three hours of your life over the course of the project.
The ratio is obvious once you see it. Over-communicate, always. Undercharge, never.
The exception, and there is one, is when the request is genuinely cleanup from something you shipped. Typo you missed, broken link you introduced, misaligned element you actually signed off on. Those aren't scope creep, they're quality. Just fix them. Don't charge, don't spec, don't frame as additional. Move on.
Brief first, scripts second
Every script above works better when it can reference a specific document. "It's outside the brief" lands differently when the brief literally lists the deliverables in writing and the client signed it.
The brief doesn't have to be a legal contract. It just has to be explicit enough that both parties can look at it and agree what is and isn't included. If your current briefs are three-line paragraphs, every scope conversation is opinion versus opinion, and the client's opinion always wins, because they're paying.
If your briefs are structured (deliverables numbered, out-of-scope items listed, revision rounds capped), every scope conversation is opinion versus document. The document always wins.
That's the whole game. Get the brief right, get the scripts ready, and the "quick thing" problem collapses from an ongoing bleed into an occasional line in a change order.
Briefance turns messy client emails into structured briefs in under a minute. Deliverables, revision caps, and out-of-scope items called out explicitly. So when the next "quick thing" lands in your inbox, you're not arguing from instinct. You're referencing something you both already agreed to.
The summary, in thirty seconds
- Every "quick thing" compounds. Five silent yeses kill a project's margin.
- The client isn't manipulating you. They genuinely underestimate the work.
- Evaluate every request against cumulative cost, not individual cost.
- Reply to all out-of-scope asks (even the genuinely small ones) with the same structured sentence, so clients don't learn the pattern is optional.
- A specific brief makes the scripts work. A vague brief makes them feel petty.
Two minutes isn't two minutes. Never has been.