Lesson 9: When You Can’t Fix Everything Right Away: Why a Smart Stopgap Makes Sense
Sometimes you know a problem needs a real, lasting fix – but customers are getting hurt in the meantime. In these moments, doing something fast isn’t just smart – it’s necessary. Let’s talk about why a quick, focused stopgap often works best, and how to pull it off without making things worse.
This tension pops up almost everywhere in operations work, but hardly anyone talks about it head-on. On one hand, you want to solve things right. Figure out what’s actually broken, design solutions that last, and avoid those quick patches that fix one thing then cause three more headaches somewhere else. You’ve probably built your whole approach around that idea: mapping out workflows, digging into causes, interviewing people, running experiments with clear finish lines.
But then there’s the other hand – the customers who are dealing with the fallout right now. Every day you spend building, testing, or validating a permanent fix is another day where people lose trust, support lines get jammed, and goodwill leaks away.
You don’t have to choose between speed and doing it right. There’s a smarter way: do something fast to protect customers immediately, while you work on the proper solution behind the scenes.
This isn’t about cutting corners. A good stopgap is intentional, visible, and temporary. It keeps things from getting worse while your real fix takes shape.
Here’s the real principle: Protect customers first. Build the proper solution second.
By now, you know which failures matter most and hurt customers the hardest. Maybe you’re already running experiments to tackle the root cause. Sometimes, though, the pain is just too obvious to wait for a perfect fix.
When you keep seeing one problem cause real pain – like broken access, billing messes, onboarding troubles, missed emails – don’t just tell customers “a fix is coming.” Step up, stop the bleeding now, and be honest: what you’re putting in place is temporary.
It only works if you keep it temporary. Stopgaps that stick around too long become unofficial workarounds, and pretty soon nobody remembers what they really replaced. They give you room to think and design, but you’ve got to move on once the real fix is ready.
A Simple Example: The Friday Billing Mess
This one says it all. A billing process kept failing every Friday. It didn’t hit every customer, just a certain group at a tricky spot in their cycle. But for them, the damage was immediate: no access to what they paid for, typically for a whole weekend – the worst time, since support is thin and frustration grows unchecked.
When we dug in, the real cause turned out to need a pretty complex engineering fix. We knew it would take a while, but customers didn’t have that luxury.
So, we set up a basic stopgap – nothing fancy, just two steps:
A manual daily sweep of billing records to catch failures before they hit customers.
A temporary rule that stopped batch jobs after 4pm Thursdays – eliminating the window for Friday failures.
Not elegant, totally manual, but everyone knew they were placeholders, not permanent answers.
What happened? Customer incidents stopped cold. The pattern disappeared in the first week. Support calls dropped, since nobody had to fight about missing access anymore. Suddenly, the team had time and space to design that permanent fix carefully, without panic or pressure. The result? A better solution, built right.
That matters. When you rush to fix things in a crisis, you make quick decisions – less testing, and usually more bugs or side effects. The stopgap takes away some pressure, protects customers, and actually helps your real engineering work.
How to Do a Stopgap Without Making a Bigger Mess
You flex the details based on the situation, but here is the basic move:
- Pinpoint the failure hurting customers most right now.
Don’t get distracted by the “interesting” ones or something with a cute fix. Look for direct, repeated impact – that’s where you strike first.
- Pick the simplest move that breaks the pattern.
Stopgaps usually fall into three buckets:
- Manual checks – a person jumps in and catches failures before customers feel them.
- Temporary rules – change when, how, or where a process runs to close the failure window.
- Simple automation – a lightweight script that flags trouble before it spreads.
Do whatever is fastest, as long as you don’t create new risks. Skip the pretty solutions for now. Focus on what works, today.
- Make it clear: this is temporary.
Tell the team, tell stakeholders, explain why you’re doing this and when it ends. It sets everyone’s expectations – the stopgap is a bridge, not the finish line. It also shows customers you’re actively managing the problem, not just shrugging and waiting.
- Track what happens.
Is the failure pattern gone? Do customers stop calling? If your stopgap’s working, you’ll see signs right away. If not, shift gears fast.
- Set a real review date before you start.
Don’t link it to whenever the real fix finishes. Pick a date – it could be weeks or months out – when you’ll sit down, measure impact, and decide if you still need that band-aid. That keeps your temporary fix from quietly turning into a permanent, messy workaround.
The Hard Truth
A lot of leaders see stopgaps as embarrassing – a sign that planning wasn’t good enough, or engineering was too slow. I used to feel that way. I wanted fixes that were clean, rolled out once, and never touched again. Doing something “temporary” felt like failing.
But I learned the hard way that protecting customers always comes first. Operational elegance comes second. Sometimes you need a crude fix, fast – so you can breathe and build the right solution next.
It’s not that stopgaps are bad. The mistake is letting them turn into the permanent process without review. The two-week manual sweep that quietly lasts for two years, the “temporary” rule that becomes mission-critical, the workaround nobody even remembers how to change.
Stopgaps only work when you treat them as the smart, temporary fixes they are – with a plan, an endpoint, and someone actually building the real solution. The moment the pain disappears, so does the urgency. If you aren’t careful, everyone stops paying attention – and you’re stuck with a messy workaround forever.
Move fast to protect your customers. Build properly to solve the real problem. Always circle back and close the loop.
So, ask yourself – do you have a recurring failure hurting customers right now, even though a permanent fix is underway? What’s the simplest thing you could do to stop the pain today? That’s your stopgap. Run it, talk about it, measure it. And make sure someone owns the true fix with a real deadline.