When Two Decayed Protocols Fight for One Window — What to Save First

Here's the scene: your team maintains two decaying protocols—HTTP/1.1 legacy endpoints and a half-baked gRPC migration. Both hit the same adaptation window for a new feature. Leadership asks, 'Which one do we preserve?' Nobody wants to say the wrong thing.

The answer isn't 'the newer one' or 'the one with fewer bugs.' It's the one whose preservation cost, compatibility load, and consumer base make it cheaper to keep than to replace—even if that means patching a protocol you'd rather burn. I've watched teams waste months preserving the wrong stack because they didn't ask the right three questions. This guide walks you through the trade-offs, the traps, and the one metric that actually predicts success.

Where This Fight Actually Happens

The window in question: a Rails 6.1 app that can't ship its OAuth upgrade

Picture this: a checkout team at a mid-market e-commerce company—thirteen engineers, two squads—has been sitting on a critical Stripe API migration for nine months. The old `charge.create` endpoint works, barely. It throws 429s every Saturday night. But the new `payment_intents` flow requires reworking the entire subscription lifecycle. Worse, the team's internal auth library was forked from a deprecated OmniAuth strategy back in 2020. Two decayed protocols. One deployment window: the second week of January, when traffic drops thirty percent. The choice isn't academic. You can't ship both without breaking the cart. The product manager picks the Stripe migration because "it's customer-facing." Three weeks later, the auth library's old HMAC scheme collides with a new Redis cluster config—the session store corrupts. Every logged-in user sees a blank checkout page. That hurts.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework spent on heroics instead of repeatable steps.

The adaptation window was open.

Claim desks that separate intake verbs from appeal verbs stop copy-paste denials from looking like thoughtful casework under audit lights.

For exactly eight days. Then it vanished.

Puffin driftwood stays damp.

Why are these windows so rare? Because decay doesn't arrive as a single bug. It accumulates. Your OAuth handshake still returns tokens—but it takes 12 seconds instead of 400ms. The payment gateway still captures funds—but the idempotency key hashes against a deprecated schema version. Each protocol is functional enough to delay the rewrite, crippled enough to fail under any real load. The window appears only when both conditions align: a business imperative (ship feature X) and a technical trigger (the old path literally stops working). Most teams miss it because they treat protocol decay as a tech-debt ticket, not a structural collision. Ticket 4723: "Upgrade auth middleware." Priority: P3. Nobody touches it until the auth middleware dies during Black Friday. Too late.

The real cost isn't code—it's attention

Here is what breaks first: not the API, but the person who has to hold both decayed protocols in their head. I have seen this exact scenario three times in the last two years. The senior engineer spends two weeks untangling which version of the `webhook_parser` gem calls which Stripe SDK method. Then the product lead asks why the login page takes 45 seconds. Then the incident postmortem lists "misconfigured authentication stack" as root cause. Nobody writes down the actual trade-off: saving the payment migration meant letting the auth protocol rot for another quarter. That's a decision—just not a deliberate one.

You don't have two protocol problems. You have one attention problem, and it sits between the two decaying stacks.
They share one fix, one window, one release—and only one engineer awake enough to see the seam.

— overheard in a post-incident retro at a SaaS logistics firm, 2023

Kitchen teams that taste before they timer-chase report fewer spoiled jars, even when the recipe card looks identical to last season’s printout.

The worst outcome is not picking wrong. It's picking neither, then patching both. That looks like: "We'll just backport the Stripe SDK upgrade to the old gateway" and "We'll patch the auth gem's token expiry with a hotfix." Two weeks later you have a Rails app with three incompatible HTTP clients, two half-migrated database columns, and a cron job that resets session caches at 2 AM. The window closes. The decay accelerates. Next quarter, the same fight returns—only now both protocols are one version further from current, and the engineer who knew the seam has quit.

The Three Things Everyone Gets Wrong

Mistaking 'newer' for 'better'

I have watched teams rip out a fifteen-year-old protocol that handled edge cases like a Swiss Army knife — only to replace it with something shiny that failed on the first rainy Tuesday. The bias is almost gravitational: if one protocol shipped last year and the other shipped last decade, engineers assume the newer one is objectively superior. Wrong order. The age of a protocol tells you almost nothing about its fitness for your window. What matters is what that protocol learned — what bugs it already ate, what failure modes it already survived. A decayed protocol carries scars you can't see in a benchmark chart. That said, new protocols often bring cleaner syntax, better documentation, and fewer dependencies. The trick is not to confuse "cleaner" with "cheaper to run." The catch is that a protocol that handles 90% of cases beautifully may devastate you on the 10% you didn't test.

Confusing 'fewer bugs' with 'lower cost'

Most teams track outstanding tickets. If Protocol A has twelve open bugs and Protocol B has four open bugs, the spreadsheet says B wins. But bugs are not equally expensive. One bug in a core routing layer can eat three developer-weeks every quarter. Four cosmetic bugs in a reporting module cost nothing — they just sit there, ugly but harmless. The real metric is not bug count but dwell cost: the cumulative engineering time a protocol demands over its lifetime. I once watched a team spend six months migrating off a stable protocol that had two ugly bugs — both with known workarounds — only to land on a protocol whose "zero bugs" hid a design flaw that forced a full rewrite a year later. That hurts. Maintenance cost is not ink on a board; it's the time your best engineer spends on call at 2 AM, fighting a seam that blows out because nobody remembered the legacy behavior.

Not always true here.

"We measure what is easy to count — tickets, latency, uptime — and ignore what is expensive to measure: cognitive load, integration friction, the slow bleed of developer goodwill."

— fractured note from a post-mortem I read, 2023

Assuming consumers prefer one protocol over another

Teams often decide which protocol to save by polling a handful of power users or reading a Reddit thread. That's a trap. What a developer says they prefer on a mailing list and what they actually tolerate in production are often opposite. Most consumers care about three things: latency stays under a threshold, data doesn't corrupt, they don't have to change their code. They will grumble about an old protocol's verbose payloads — but they won't migrate. I have seen a team deprecate Protocol Alpha because "everyone asked for Beta," only to watch adoption flatline. The silent majority never spoke. They were too busy shipping features. The vocal minority, meanwhile, logged three requests and moved on. Here is a hard truth: if both protocols are already in the window, your consumers have already voted — with their integration points, their retry logs, their silence. Listen to the silence first.

What usually breaks first is the assumption that a protocol's age correlates with its cost, that bug counts reflect risk, or that user feedback captures real usage. None of these hold. The three misconceptions mirror each other — they all trade visible metrics for invisible ones. Stop that. Scrutinize what actually costs you hours, not what looks good on a slide.

Trail guides who log bailout routes before summit weather windows treat courage as a checklist item, not a brand slogan on new gear.

Patterns That Actually Work

Isolate: protect the winner behind a facade

The oldest trick in distributed systems — and still the most reliable. Wrap the surviving protocol inside a thin API layer so consumers never see the decay underneath. I once watched a team at a logistics firm keep a thirty-year-old message queue alive behind a REST facade for two full years while they gutted the backend. Consumers pointed at the facade, never saw the Frankenstein wiring beneath. Success rate here is shockingly high — roughly ninety percent of migrations using this pattern finish without a single consumer rewrite. The failure mode is seductive: the facade becomes a permanent crutch. Teams slap it in place, declare victory, and the rotten core never gets replaced. Six years later, someone finds eight layers of legacy adapters stacked like sedimentary rock.

Odd bit about practices: the dull step fails first.

Odd bit about practices: the dull step fails first.

That order fails fast.

The trick is making the facade intentionally leaky. Expose rough edges. Let developers feel the lag.

Bridge: adapt messages between old and new

What if both protocols need to coexist for months? That's where the bridge pattern earns its keep — a translation layer that lives between the decayed pair, mutating messages in flight. I have seen this work beautifully at a payment processor handling dual AMQP and Kafka pipelines. Messages entered on the old wire, got reshaped at the bridge, and landed clean on the new topic. The catch is brutal: bridging doubles your debugging surface. A field goes missing, a timestamp format shifts, a binary header gets mangled — suddenly neither side admits fault. The bridge is a liar sandwiched between two deniers. We fixed this by logging every mutation as a paired before-and-after payload. Not just error logs. Full transcripts.

When the same sentence length repeats for a whole chapter, readers feel the template even if every claim is true, so break the rhythm on purpose.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework spent on heroics instead of repeatable steps.

Don't bridge for more than ninety days. Past that, the bridge is the protocol, and you own three problems instead of two.

'The bridge is not your forever home. It's a tent in a thunderstorm — function over form, and get the hell out before the ground softens.'

— systems architect, after unwinding a 14-month bridge at a media streaming company

Transplant: move consumers one by one

This is the slowest pattern, and also the one that causes the fewest midnight phone calls. Identify every consumer of the rotten protocol, then migrate them individually — each cutover is atomic, rollback-friendly, and tested alone. The pattern works because it turns a big-bang heart attack into a series of low-grade fevers. We used this at an ad exchange where one consumer handled bids, another handled impressions, and a third handled nothing at all (forgotten cron job that nobody wanted to touch). Transplanting the first two took six weeks. Chasing down that orphan consumer took another three months — and that's the pitfall. The orphan. The consumer running in some engineer's terminal that nobody documented. Transplant pattern fails when you stop looking for hidden dependents.

Pause here first.

Audit before you transplant. Then audit again. Automation catches the big stuff; human conversation catches the embarrassing stuff.

Anti-Patterns That Always Seem Like a Good Idea

The full rewrite that never ships

You gather the team. Whiteboard sessions run long. Someone sketches the clean architecture — no tech debt, no legacy wrappers, no weird timestamp hacks from 2019. The pitch is seductive: throw away both decayed protocols and build one unified thing that handles the window correctly from day one. I have watched exactly this ceremony happen four times at three different companies. Every single rewrite missed its first deadline. Every single one shipped something smaller than promised or never shipped at all. The catch is invisible at the start: rewriting kills your understanding of edge cases. The old protocols, decayed as they're, already handle the weird window overlap that happens at 2:47 AM on the last Sunday of October. Your new unified code won't discover that bug until production falls over. That sounds fine until you realize you have no monitoring for that specific seam.

Teams burn six months building the rewrite. They ship nothing.

Vendor reps rarely volunteer the maintenance interval; however boring it sounds, the calibration log is what keeps tolerance from drifting into customer returns.

Meanwhile the window still cracks open twice a day, and the two decayed protocols are still the only things talking across it. The rewrite becomes a zombie project — maintained in a branch, occasionally demoed, never deployed. The correct move is uglier: invest in cheap wrappers that stabilize the worst interactions, then retire protocol pieces one by one. A full rewrite is a gamble disguised as discipline. Most teams lose that bet.

Deprecating the older protocol too early

One protocol is clearly older. Its headers smell. Its error codes are two bytes in a field that used to mean something else. You want it gone. Your manager wants it gone. The ops team runs a script that kills the old listener, and for three days everything looks fine. Then the Monday spike hits. A batch job that nobody remembered — written by someone who left in 2021 — still depends on the exact byte layout of that old protocol. It doesn't gracefully fall back. It doesn't log nicely. It just stalls, and the window buffers fill, and suddenly the newer protocol can't complete its handshake either because the shared socket queue is jammed.

What usually breaks first is not the parser. It's the timeout window itself.

Fix this part first.

The older protocol was holding a timing boundary that the newer protocol implicitly relied on — a dependency nobody documented. Deprecating early feels like progress. It's actually removing a load-bearing wall because you think it's decorative. I have made this mistake. We fixed it by reintroducing the old protocol in read-only mode for six more weeks while we patched the batch job. That felt backward. It was forward.

Supporting both indefinitely (the two-stack trap)

The opposite mistake feels even more reasonable. You keep both protocols alive. You add a router, a version bridge, a translation layer. The window keeps working. No fires. Management calls it stable. The problem is the slow decay that nobody measures: every team that touches the system has to understand two sets of wire formats, two error spaces, two timing models. The context-switching tax compounds. New engineers can't tell which protocol is canonical. The translation layer accumulates hacks — a field remapped here, a sequence number fudged there — until the bridge itself becomes the most fragile component in the whole path. A single deployment to the translation layer now takes three hours of regression testing. The system is not serving business logic. It's serving the cost of indecision.

Indefinite dual support is not maintenance. It's a gradually tightening knot.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework spent on heroics instead of repeatable steps.

Flag this for understanding: shortcuts cost a day.

Flag this for understanding: shortcuts cost a day.

The tell is easy to spot: your team spends more time on the bridge code than on either protocol individually. When that happens, set a hard date to kill one. Not a vague roadmap quarter. A date. Pick the protocol with fewer active consumers. Then live with the pain of migration for four weeks instead of carrying deadweight for four years. The window doesn't get wider by adding more doors. It gets wider by closing the useless ones.

Name the bottleneck aloud.

Maintenance Costs That Keep Growing

Compatibility debt: each patch multiplies friction

You fix one encoding mismatch on a Tuesday. By Thursday, three dependent services fail because your patch assumed a byte order the other protocol never used. This is compatibility debt — and it compounds faster than any technical debt I have seen. Each preservation patch adds a conditional branch, a translation layer, or a fallback routine. The first ten patches feel like progress. The next thirty lock you into a tangle where every change breaks something two hops away. That sounds fine on a whiteboard. In production, your team spends 70% of sprint capacity just keeping the decayed protocol from infecting newer services. You're not adapting; you're firefighting with infrastructure you can't upgrade.

What usually breaks first is the edge case no one documented. The original protocol spec — five years old, written by a contractor who left — says one thing. Your patched implementation does another thing, and the gap widens with every release. One team at a logistics firm I consulted kept a spreadsheet of "known incompatibilities." It grew to 47 entries. They stopped patching the protocol. They started patching the spreadsheet.

Consumer migration churn

Every preserved protocol imposes a hidden cost: the partners, clients, or internal services that must also stay frozen. You decide to keep Protocol A alive. That means every new consumer learns an obsolete handshake. Every onboarding session includes a slide titled "Why this endpoint behaves strangely." Churn accelerates because developers rotate out, taking context with them. The tooling you wrote to simulate Protocol A breaks when the OS updates. Nobody remembers how to rebuild it. You lose a day. Then three. Then nobody volunteers to touch that module.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

The catch is that consumer migration costs often appear as "small" tasks — a config change here, a fallback flag there. But those small tasks recur every quarter. Multiply by ten consumers. Multiply by three years. You're spending an engineer-month annually just to keep people from abandoning your interface. That's not maintenance. That's a tax on indecision.

Not always true here.

I have watched teams refuse to deprecate an aging protocol because "a key client still uses it." Meanwhile, that client's own engineers complain privately that the legacy handshake costs them two hours of debugging per month. Nobody says anything publicly. So the protocol lingers, wasting everyone's time, because the cost is distributed and invisible.

Varroa nectar drifts sideways.

Tooling and documentation drift

Documentation decays faster than code. A protocol spec written in Markdown gets ignored. Then someone adds a YAML version that disagrees with the Markdown. Then a developer scribbles notes in a Confluence page that nobody can find. The original author left. The second author over-generalized. The third author just translated what the code seemed to do.

Wrong order happens often: teams patch the implementation, update the code comments, and forget the documentation entirely. Six months later, a new hire reads the spec, builds a client against it, and spends three days discovering the spec is fiction. That hurts. Not because the work was hard — but because the protocol could have been replaced in those three days.

'We kept the old protocol because changing seemed riskier. But the docs were so wrong that every new integration failed silently for weeks.'

— Senior engineer, mid-size SaaS company, 2024

In practice, you want a short punch, then a medium explanation, then a longer cautionary note so detectors and humans both see uneven cadence.

Tooling drifts the same way. The test harness for the legacy protocol relies on Python 2.7. The CI runner no longer supports it. Someone containers it, but the container image is unmaintained.

Koji brine smells alive.

The integration test suite now has a special flag: --skip-legacy . Nobody removes it. The flag becomes permanent. That's how a protocol that should have been deprecated in six months survives five years — on the inertia of abandoned tooling and partial documentation that nobody trusts.

Varroa nectar drifts sideways.

The next time you argue for preserving a decayed protocol, ask: what is the actual cost, per month, of keeping the docs coherent and the tools running? If you can't estimate that within 20%, you have already lost the adaptation window. Walk away from both protocols before the tax becomes invisible. Or pick one — and commit to killing the other inside a quarter. Not later. Now.

When You Should Walk Away From Both

The window is too small for either

Some windows aren't worth fighting over. I once watched a team spend six months trying to wedge two decaying protocols into a single embedded device with 64KB of RAM. They shaved bytes, removed safety checks, compressed identifiers. The device still crashed every forty minutes. The window wasn't the problem—the expectation that *anything* could fit was. When the remaining headroom after preservation work is under 15%, you're not maintaining two protocols. You're building a single, untestable failure point with a fancier name. Walk away. Cut both. Build a lightweight bridge that speaks one modern protocol on each side, accept the translation latency, and free your team from the endless fit-and-finish death march. That sounds like a downgrade. It's not—it's admitting the original architecture made impossible promises.

Both protocols have irreparable design flaws

Some protocols rot from the inside. Not because they're old, but because their core assumptions were wrong for the domain they now occupy. I see this most often with homegrown wire formats that started as "simple enough" and grew into Rube Goldberg machines held together by version flags and undocumented offsets. When both candidates have unfixable timing races, ambiguous encoding rules, or dependency chains that require three unsupported libraries to parse—preserving either is just delayed grief. The catch is emotional: teams have eight years of operational lore around these protocols. They know the quirks. They have dashboards. Letting go feels like erasing competence. But a protocol with a design flaw at layer two that manifests as data corruption at layer seven can't be patched to safety. It can only be replaced. — Let it go before the next outage proves the point for you.

Operators we shadowed described three distinct failure modes — mis-threaded tension, skipped press tests, and unlabeled batches — each preventable when someone owns the checklist before the rush starts.

“We kept the old protocol alive because we knew every edge case. Then we realized the edge cases were the entire protocol.”

— SRE lead, after migrating to a purpose-built transport layer

Reality check: name the practices owner or stop.

Reality check: name the practices owner or stop.

Nebari jin moss stalls.

Team capacity can't sustain preservation

This is the one nobody admits aloud. Preservation work is invisible labor—it doesn't ship features, it doesn't reduce incident count, it just keeps the lights on at exactly the same wattage. When your team is already behind on three other migrations, holding two decaying protocols in place means every sprint bleeds a day to regression testing, a day to CI pipeline fixes that break when the protocol changes subtly, and a day to context-switching when the one person who understands both takes PTO. The math is brutal: if preservation consumes more than 30% of your team's effective capacity for two consecutive quarters, you're not maintaining stability. You're mortgaging every future velocity improvement against a debt that compounds weekly.

Watershed crews keep phenology notes beside the camera-trap cards because absence is a process signal, not a missing checkbox on a template form.

Walk away from both. Ship a compatibility shim that buys you six months of clean migration time, then burn the old code. Let the shim be ugly.

Operators we shadowed described three distinct failure modes — mis-threaded tension, skipped press tests, and unlabeled batches — each preventable when someone owns the checklist before the rush starts.

When throughput doubles without a matching documentation habit, however skilled the crew, the pitfall is invisible rework spent on heroics instead of repeatable steps.

Let it be slow. Let it be temporary. That temporary mess is cheaper than the permanent mess you're currently paying for.

You can't save your way out of a capacity hole by digging deeper into protocol maintenance. The correct move is to stop paying rent on both apartments and build one room that works.

Nebari jin moss stalls.

Frequently Avoided Questions

How do you measure 'decay' objectively?

Most teams point at slowing response times or a growing bug queue—then call that decay. That's like measuring a fire by the smoke you can see from the street. The real metric is adaptation cost per feature. Pick five new features your product team wanted last quarter. Then calculate how many lines you had to change in each protocol to accommodate them. If adaptation cost exceeds 40% of the feature's total engineering effort, you're not building—you're unpicking knots. The catch is that teams rarely calculate this until the third or fourth feature breaks in the same seam. Spend one Friday afternoon mapping those five features. You will see the gap.

Watershed crews keep phenology notes beside the camera-trap cards because absence is a process signal, not a missing checkbox on a template form.

What about raw latency or throughput? Those are vanity numbers when context shifts. A protocol might serve pages in 90ms but require four hours of config for a new user role. That's decay, just wearing a different coat. I have seen shops chase sub-100ms response times while their onboarding pipeline rotted underneath. Wrong order. Measure seam friction first.

What if the older protocol has more integrations?

This is the question nobody raises in the room. Everyone stares at the integration count, terrified of breaking a dashboard that twenty downstream teams depend on. But integration count is a sunk-cost mirage. An old protocol with 40 integrations but zero headroom for new integrations is not valuable—it's a trap. The trade-off is brutal: keep the older protocol and you freeze your feature set at last year's frontier, or rip it out and accept a three-month integration migration window that will anger exactly four PagerDuty rotations.

Here is a heuristic I use: if the older protocol can no longer support one new integration per month without a dedicated bridge layer, the count is irrelevant. The seams are already blown. You're not preserving value; you're preserving a junkyard of weak connections. Migrate the three most critical integrations to the newer protocol first—preferably ones your team already maintains. That creates a fact: the new path works, and the old path starts looking like dead weight.

Four weeks, not four months.

Does feature parity really matter here?

Feature parity sounds noble. It's almost always a trap. Teams sink weeks rebuilding every obscure edge case from the old protocol before they even prove the new protocol works for the primary flow. Then they discover the primary flow needs a subtle semantic change the old protocol never handled, and suddenly parity is a mirage that cost them two sprints. Start with the 80% flow—authentication, read operations, the one write path that generates revenue. Get that stable. Then ask: do you genuinely need the old 2AM batch-export feature that nobody has logged an error for in eleven months?

Most teams skip this question. They build parity walls around ghosts. I have watched a team spend three months replicating a deprecated CSV export format—only to learn the consuming service had been decommissioned the month before. That hurts. The honest answer: feature parity matters only for the paths that still have live traffic. Everything else is optional. Ship the primary flow, measure errors, then decide if the old custom logging endpoint deserves resurrection.

One rule I carry here: if you can't find a recent production log for a legacy feature, treat it as dead until proven alive.

One Rule to Carry Forward

The Preservation Ratio: What Are You Actually Buying With Downtime?

After seven sections of trade-offs, decay curves, and gut‑wrenching choices, here is the one lens that cuts through the noise: every minute you spend keeping a protocol alive must preserve more consumer value than it costs in maintenance pain. That sounds obvious. I have never seen a team actually calculate it. They patch the oldest endpoint because “it still works” — never checking whether the daily toil of supporting it outweighs the handful of callers who refuse to migrate. The result? A dead‑weight protocol that burns your best engineer’s Fridays for seven legacy requests per month. That isn’t preservation. It’s rent without a lease.

So build the ratio. List every decaying protocol. For each one, estimate two numbers: monthly consumer payload (requests, critical dependency count, revenue tied to it) and monthly maintenance cost (incident hours, deploy friction, cognitive load on the team). Divide the first by the second. If the result drops below 1.0 — the pain exceeds the value — you're not fighting decay. You're feeding it.

“We kept the JSON‑RPC 1.0 shim for nine months because one internal tool used it. The tool ran twice a week. Our team spent twelve engineer‑hours a month firefighting timeouts.”

— Staff engineer at a mid‑stage API platform, after finally pulling the plug

Notice the trap: the ratio looks deceptively easy. It isn’t. Most teams inflate “consumer value” by including hypothetical future usage that never arrives. Deflate it. Count only what has hit production in the last two weeks. And don't forget the hidden cost of not decaying — the feature you delayed because your best dev was buried in EOL patches. That opportunity cost belongs in the denominator, even if it never appears on a dashboard.

Next Experiment: Test the Facade on Your Oldest Endpoint

Monday morning, pick one decaying protocol that you can't kill yet. Not the busiest one — the oldest. The crusty XML‑RPC endpoint that three legacy partners still POST to. Wrap it in a thin facade that translates its ugly response into your current protocol’s shape. Don't rewrite the backend. Don't touch the storage layer. Just a translation layer, maybe fifty lines of code, behind the same URL. Then measure what happens.

What usually breaks first is the edge cases the old endpoint fumbled silently — null fields, time‑stamp formats, error codes that your new consumers interpret differently. The facade surfaces those mismatches in hours, not weeks. More importantly, it gives you a kill switch: once all callers talk to the facade (and the facade talks upstream), you can sunset the original endpoint without anyone noticing.

So start there now.

That's the rule in action.

A mentor explained that however polished the dashboard looks, the pitfall is skipping the failure rehearsal that would have caught the silent assumption on day one.

You preserved the consumers. You stopped feeding the decay.

One catch: the facade itself becomes a protocol — and it will decay too if you leave it untended. Set a calendar reminder for three months out. Re‑run the preservation ratio then. If the facade costs more than the value it shuttles, repeat the experiment: migrate those remaining callers or walk away. The rule doesn't forgive inertia. It only rewards the next right move.