Strangle Strategy

The Strangler Fig Pattern: Think Strategic, Act Tactical The strangler fig pattern has gained significant popularity as an effective approach to modernizing legacy systems. However, despite its merits, it is fundamentally a strategic pattern—not purely a tactical solution. Misunderstanding this distinction can lead to short-sighted implementations that don't fully leverage the pattern's potential. Strategically applying the strangler fig pattern does not exclude refactoring; instead, it inherently complements it. While strategic strangling involves progressively replacing legacy components, tactical execution often involves targeted refactoring to enable a smoother transition and better integration. Crucially, tactical patterns accompany strategic strangling. Two essential tactical variations worth mentioning are "front door strangling," where traffic is gradually routed to new implementations via a common entry point (often an API gateway), and "back door strangling," where the legacy system is incrementally replaced from the back end, typically involving data synchronization patterns like change data capture (CDC). When undertaking strategic strangling, it is practical—and often necessary—to employ a combination of tactical patterns tailored to individual use cases. Some of these patterns include: - **Refactoring:** Incremental improvement of legacy code to facilitate eventual replacement. - **Front door strangling:** Gradual redirection of requests through a new front-facing interface. - **Back door strangling:** Systematically replacing components behind the scenes, ensuring continuous operations. - **Change Data Capture (CDC):** Capturing data changes in legacy systems to synchronize with new services. - **Outbox Pattern:** Reliable asynchronous communication facilitating event-driven architectures. - **Sidecar Pattern:** Deploying auxiliary services alongside legacy components for incremental enhancement. - **API Gateway:** Centralized access management and request routing for transitioning between legacy and new components. - **Branch by Abstraction:** Using abstraction layers to incrementally replace underlying implementations. - **Shadow Database:** Parallel operation of new and legacy databases to validate new implementations with live data. The true power of the strangler fig pattern emerges when you strategically integrate these tactical approaches. Avoid simplistic interpretations. Instead, adopt a holistic perspective that thoughtfully combines tactics to achieve genuine, sustainable modernization.

Strangler Fig Pattern: A Smarter Approach to Legacy Modernization Rewriting an entire legacy application from scratch is often expensive, risky, and time-consuming. The Strangler Fig Pattern offers a practical alternative by enabling teams to modernize systems incrementally. Instead of replacing everything at once, an API Gateway or reverse proxy is placed in front of the existing application. As new services are developed, traffic is gradually routed to them while the remaining requests continue to be handled by the legacy system. Over time, the old application shrinks until it can be safely decommissioned. This approach provides several advantages: * Reduced migration risk through incremental changes * Continuous delivery of business value during the migration * Easier testing and rollback of newly migrated functionality * A smoother transition from monoliths to modern architectures However, the pattern must be implemented carefully. Without proper planning, it can lead to “distributed spaghetti,” where logic is split across systems, dependencies become tangled, and both old and new applications are permanently coupled. To avoid this: * Migrate by business capability or domain boundaries * Assign a single source of truth for each data domain * Use event-driven integration where appropriate * Keep routing rules simple and maintainable * Remove legacy components as soon as they are fully replaced The true success of the Strangler Fig Pattern is measured not by how long two systems coexist, but by how effectively the legacy system is retired while maintaining business continuity. #SoftwareArchitecture #Microservices #LegacyModernization #StranglerFigPattern #SystemDesign #CloudComputing #Azure #DotNet #Architecture #Engineering

Gosh I haven’t heard the term “Strangler Fig pattern” for yonks, which is a software engineering strategy for replacing a legacy system gradually instead of rewriting it all at once. The name comes from the tropical strangler fig tree which grows around an existing tree, slowly taking over until the original tree dies away. The new structure replaces the old one incrementally rather than through a single dramatic event. Instead of a big bang transformation in software, you have something like: - Leave the existing system running. - Build a new capability alongside it. - Route some users or requests to the new component. - Once that part is stable, retire the equivalent part of the old system. - Repeat until the old system has vanished. I can see why Luis Saiz reached for this analogy, as my thesis increasingly argues that organisations shouldn't attempt a massive redesign before adopting intelligent systems. Instead, they should: - Introduce one bounded intelligent workflow. - Establish governance around it. - Learn from it. - Expand to adjacent workflows. - Gradually change decision ownership and operating practices. - Allow the new operating model to grow until the old one is largely obsolete. The crucial point is that this all happens while the organisation is still running. You don't stop the business to redesign it from first principles, you introduce one bounded capability, learn what governance, decision rights and coordination it actually requires, then use those lessons to shape the next one. The operating model is discovered through implementation rather than designed upfront. On reflection, I think this is remarkably similar to the Strangler Fig pattern. You're not replacing the organisation overnight, you're replacing its operating model one capability at a time. There is one important difference, though. In software, you're replacing code. In my work, you're replacing ways of organising work. The unit of change isn't a service or API, it's workflows, decision rights, governance and coordination. The agent harness doesn't arrive in a vacuum, it inherits the existing operating model. Every deployment therefore has two outputs: a working capability and new organisational knowledge. That knowledge shapes the next deployment, allowing the operating model to evolve through successive deployments rather than a single redesign. That distinction is interesting because it suggests the pattern could be adapted from software architecture into organisational architecture. Perhaps what software engineering calls the Strangler Fig pattern has an organisational equivalent. If so, it may explain why organisational transformation in the age of intelligent systems is evolutionary through successive deployments rather than revolutionary.

We’re often taught that directional conviction requires taking directional risk. But in markets characterized by extreme volatility or unexpected gapping, vertical spreads can sometimes feel like a lottery ticket. Enter the Inverse Skip Strike Butterfly. Unlike standard butterflies (neutral, price-pinning trades) or standard skip-strike butterflies (moderately directional, defined-risk trades), the Inverse Skip Strike strategy is built for directional expansion, and it does so with a fascinating net-credit structure. Think of it as the strategic mirror image. Instead of buying the equidistant 'wings' and selling the 'body' for a debit, you are constructing a net-credit trade that profits from a massive, violent breakout in either direction. The Core Setup (Moderately Bearish Example): Imagine you are moderately bearish on Stock ABC (trading at $105), anticipating a pullback toward $100 after earnings, but also want protection if the trade completely explodes to the upside ($120+). Here’s how you engineer the structure: 1. Sell 1x In-The-Money (ITM) Put @ $110 2. Buy 2x At-The-Money (ATM) Puts @ $105 3. Sell 1x Out-Of-The-Money (OTM) Put @ skip a strike $95 The Quantitative Engine Behind the Trade: Net Credit Generation: Because you are selling the expensive ATM and OTM put options and buying the cheaper body puts, you are collecting a significant net credit to enter the trade. This credit acts as your maximum potential profit. In essence, you are long a 'body' and short two slightly cheaper 'wings', which behaves like a short straddle/strangle at inception, but one with defined risk. Asymmetrical, Defined Risk: This is the strategy’s true quantitative power. By skipping the intermediate $100 put, you are accepting limited upside (the net credit if the stock explodes to $120+), but you have strictly capped your directional loss on the downside. Shading on your payoff curve visually illustrates that losses are not only limited, but they are dramatically less severe on the bearish side compared to the parabolic risk of a naked short straddle. Maximum Profit and the "Vol Crush" Fade: Your maximum profit is realized if the underlying asset collapses, but only if it collapses so much that it goes below your lowest strike ($95). It also profits immensely if implied volatility craters. When does it make sense? The Inverse Skip Strike Butterfly is a structural tool for traders looking to express a moderate, controlled directional conviction with: 🔹 📊 High Probability of Profit: It often boasts a wider profit zone than naked vertical spreads. 🔹 🛡️ Catastrophic Tail-Risk Mitigation: Strict loss caps ensure that a stock gapping against you isn’t a ruinous event. 🔹 Income-focused portfolios. Are you deploying Inverse Skip Strike butterflies for earnings breakouts, or do you prefer using them for directional trades with limited risk? #CapitalMarkets #OptionsTrading #RiskManagement #QuantitativeFinance #Derivatives #Volatility #Strategies

The "Big Bang" migration is a trap. Here is how you migrate a Frontend Monolith to Micro Frontend safely. Most teams decide to move from a Legacy Monolith to a Modern Stack by rewriting everything from scratch. This is almost always a disaster. Features freeze, bugs multiply, and the "launch" gets delayed by months. As a Staff Engineer, my advice is to stop the rewrite. Start strangling. I recommend the 𝗦𝘁𝗿𝗮𝗻𝗴𝗹𝗲𝗿 𝗙𝗶𝗴 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 using an 𝗔𝗽𝗽 𝗦𝗵𝗲𝗹𝗹 first. 𝗧𝗵𝗲 𝟰-𝗦𝘁𝗲𝗽 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆: 1️⃣ 𝗕𝘂𝗶𝗹𝗱 𝘁𝗵𝗲 "𝗔𝗽𝗽 𝗦𝗵𝗲𝗹𝗹" Create a lightweight container in your modern stack (e.g., React/Vite). This strictly handles the global "Frame" - Navigation, Sidebar, and Authentication. 2️⃣ 𝗘𝗺𝗯𝗲𝗱 𝘁𝗵𝗲 𝗠𝗼𝗻𝗼𝗹𝗶𝘁𝗵 Load the entire Legacy App inside the Shell (via Iframes or Nginx proxy). The user sees the new UI shell, but interacts with the old legacy content. 3️⃣ 𝗥𝗼𝘂𝘁𝗲 𝘁𝗼 𝗡𝗲𝘄 𝗠𝗙𝗘𝘀 Pick one vertical (e.g., /𝘴𝘦𝘵𝘵𝘪𝘯𝘨𝘴). Point that route to a new Micro-Frontend. Route /𝘴𝘦𝘵𝘵𝘪𝘯𝘨𝘴 ➝ New React App. Route /* ➝ Legacy Monolith. 4️⃣ 𝗦𝘁𝗿𝗮𝗻𝗴𝗹𝗲 & 𝗥𝗲𝘁𝗶𝗿𝗲 Gradually migrate routes one by one (/𝘥𝘢𝘴𝘩𝘣𝘰𝘢𝘳𝘥, /𝘱𝘳𝘰𝘧𝘪𝘭𝘦). Once the Monolith has 0 routes left, shut it down. 𝗪𝗵𝘆 𝘁𝗵𝗶𝘀 𝘄𝗶𝗻𝘀: ✅ 𝗜𝗺𝗺𝗲𝗱𝗶𝗮𝘁𝗲 𝗩𝗶𝘀𝘂𝗮𝗹 𝗨𝗽𝗴𝗿𝗮𝗱𝗲: Users get the new modern Nav/Header on Day 1. ✅ 𝗭𝗲𝗿𝗼 𝗗𝗼𝘄𝗻𝘁𝗶𝗺𝗲: You ship value continuously, not in one massive "Big Bang." ✅ 𝗥𝗶𝘀𝗸 𝗠𝗶𝘁𝗶𝗴𝗮𝘁𝗶𝗼𝗻: If a new page breaks, you revert just that route, not the whole app. System Design isn't just about the destination. It's about designing a safe path to get there. Have you tried the Strangler Fig approach? #Frontend #SystemDesign #MicroFrontends #SoftwareArchitecture 

𝗙𝗿𝗼𝗺 𝗣𝗶𝗹𝗼𝘁 𝗣𝘂𝗿𝗴𝗮𝘁𝗼𝗿𝘆 𝘁𝗼 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗦𝘂𝗰𝗰𝗲𝘀𝘀: 𝗛𝗼𝘄 𝗪𝗲 𝗧𝗿𝗮𝗻𝘀𝗳𝗼𝗿𝗺𝗲𝗱 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗲𝘀 𝘄𝗶𝘁𝗵 𝗔𝗜 After deploying #AI #ML solutions across multiple enterprises over the past several years, we've cracked the code on what separates successful #DigitalTransformation from failed pilots. Our team has guided organizations from pilot purgatory to production excellence—here's the #AIStrategy playbook that's delivered consistent results. The Transformation We've Witnessed We've helped organizations stop retrofitting legacy systems and start rebuilding strategically. Instead of asking "where can we add AI to existing workflows," our most successful clients now ask: "If we rebuilt this process today with #ArtificialIntelligence at its core, what would it look like?" Three #AIDeployment Strategies We've Proven in Production Outcome-Driven Implementation (Not Output Theater) We've guided teams away from vanity metrics like "processed 10% more invoices" toward measurable business impact like "reduced cash cycle by 15 days" and "decreased operational costs by 40%." This #ProcessOptimization approach has forced genuine process reengineering and delivered quantifiable #ROI across every deployment. Strangler Pattern Success Stories We've deployed this #EnterpriseAI strategy across major process transformations. Take one process slice, rebuild it AI-native, prove concrete value, then systematically expand. Results: Zero business disruption while achieving 60-80% #OperationalEfficiency gains. Legacy systems get replaced gradually while operations continue seamlessly. Adaptive Process Architecture We've built processes as living digital ecosystems that learn and optimize continuously. Our deployments now feature #MachineLearning systems that experiment with new workflows autonomously, eliminating the traditional months-long change management cycles. Continuous adaptation has become our clients' sustainable #CompetitiveAdvantage. What We've Learned About #AIProject Failure After analyzing dozens of failed initiatives, we've identified the pattern: Most "AI projects" aren't AI projects—they're IT modernization efforts with machine learning features bolted on afterward. The #CLevel executives we work with have evolved their strategic thinking: From measuring pilots → measuring transformed business processes From asking "can AI optimize this?" → asking "how do we rebuild this process around AI capabilities?" The Market Reality We're Seeing Organizations approaching #AIIntegration incrementally are finding themselves outpaced by competitors who've fundamentally reimagined their operations around artificial intelligence. We've witnessed this #BusinessTransformation firsthand: The 5% of organizations that rebuild processes AI-first are creating insurmountable competitive moats while the other 95% remain trapped in endless pilot cycles. Happy to connect - DM me.

Same goals. Different grip. 2020. Fourteen days forcing team alignment. Seven draft decks. Zero movement. Week three, I asked ONE different question: ❌ "How do we drive alignment?" ✅ "How might you contribute to what's already committed?" Three weeks later: distributed intelligence I'd been strangling came back. Not because I found better goals. Because I stopped squeezing them. Here's the physics behind why squeezing water makes it escape: 1/ Flow Requires Less Control, Not More • In flow states, your prefrontal cortex (control network) quiets down. • Tiger Woods doesn't think about his swing mid-shot. → Stop white-knuckling. Set conditions. Step back. 2/ Autonomy > Coercion • GM Fremont: Worst US plant. Sabotage, absenteeism, drugs. • NUMMI: Same workers, autonomy-based system → Best in America. • The shift: Workers could stop the line, set standards, drive improvement. → Replace "How do we convince them?" with "What makes this inevitable for them?" 3/ The White-Bear Trap • Tell someone "Don't think about white bears." •  They'll think about white bears. → Your forcing creates the resistance you feel. 4/ Cells Self-Organize When the Field Is Right •  Your body manages 37 trillion cells without micromanaging a single one. • You tune conditions (temperature, nutrients, pH). Patterns emerge. → Change the current, not the people. 5/ No Universal Forcing Function •  "No Free Lunch" theorem: No single method wins everywhere. •  Control works for emergencies. •  Invitation works for creation. → Wisdom is mode selection, not gripping harder. Before your next meeting: Check your body: ↳  Jaw tight? Shoulders climbing? → You're forcing. ↳  Breath full? Hands open? → You're inviting. Then ask: "What would make the right behavior inevitable?" (Not "How do I convince them?") The water balloon taught me what spreadsheets couldn't: 👉 Only an open hand can hold water. 💬 What's one place you're squeezing that needs cupping? Full story: The Water You Can't Hold [link in comments] Tomorrow: The 3-minute Water Balloon Dojo drill. #leadership #neuroscience #culture #management #orgdesign #systemsthinking #flow #performance #workdesign #psychology

** A Minimum Viable Architecture to an Intelligent Telco ("IntelliCo") ** The telecom industry is currently facing a challenging situation, caught between the demand for immediate AI-driven ROI and the lengthy process of transforming legacy systems to align with the full TM Forum ODA framework and regain soverignty and agility. At DEXTRIT, we propose regaining architectural control by applying a Strangler Fig Pattern to legacy BSS/OSS stacks. Instead of a bloated risky "big bang" replacement, deploy a surgically precise, minimum viable set of ODA components wrapped in Open APIs. This creates a 'Golden Quadriad' of AI-readiness, intercepting and decoupling legacy capabilities one domain at a time. Here is a proposed HL MVA "Strangler" Set we could use to safely extract value and build the foundation for intelligence: 1. Decoupled Omnichannel (The Commerce Strangler): * ODA Components: TMFC001 (Product Catalog) & TMFC002 (Product Order Capture/Shopping Cart). * Open APIs: TMF620 & TMF622. * Strategic Intent: We deploy a "Light" Commerce Catalog to master sellable offerings and a decoupled Shopping Cart to persist intent across channels. This abstracts legacy BSS complexity from the customer journey instantly. 2. 360° Customer & Journey View (The Experience Strangler): * ODA Components: TMFC028 (Party Management). * Open APIs: TMF629 & TMF632. Strategic Intent: Aggregates touchpoints into a real-time state machine, enabling proactive churn prediction and Agentic CX. 3. 360° Inventory View (The Fulfillment Strangler): * ODA Components: TMFC008 (Service Inventory) & TMFC012 (Resource Inventory). * Open APIs: TMF638 & TMF639. Strategic Intent: We do not not necessarily replace the legacy Resource Inventory. Instead, we can create a cached, centralized "Commercial Inventory" fabric. This provides the AI with a 360° view of devices and services without the risk of a "heart transplant" migration. 4. The Intelligence Fabric (Data Mesh): * ODA Components: ODA Canvas Event Management. * Open APIs: TMF688 (Event Management). Strategic Intent: Captures real-time customer interactions and transactions as clean data products for AI/ML consumption, bypassing fragile legacy databases. Every piece of this proposed MVA treats vendors strictly as component providers, not ecosystem owners. You achieve immediate OPEX reduction and self-fund the long-term journey to ODA. If you are tired of theoretical slides and want to talk about pragmatic, senior-led execution, let’s connect next week in Barcelona. Drop me a DM, and let’s talk about modernizing your stack fast, lean, and under control. #MWC2026 #Telecom #TelcoAI #DataMesh #IntelliCo #TMForum #ODA #DigitalTransformation #DEXTRIT #CIO #EnterpriseArchitecture #OpenAPIs

Software rewrites promise exciting technological advancements but frequently become risky, budget-draining quagmires. So why do these projects fail so consistently, and what can we do differently? Richard Lawrence, founder of Humanizing Work, joins The Agile Within to unpack the hidden complexities and psychological pitfalls lurking beneath seemingly straightforward rewrites. We explore why the common directive to "just do what the old system does" is a dangerous trap, overlooking crucial hidden requirements, workarounds, and integrations that have developed over years. Richard introduces the "strangler approach"—a method that uses existing systems as scaffolding while gradually building new capabilities, allowing teams to deliver immediate value rather than delaying benefits until a complete replacement. Next we examine user psychology, revealing why technical arguments for rewrites ("outdated technology," "unsupported platforms") fall flat with actual users. "That's your problem, not mine," reflects the realistic user perspective Richard articulates. Instead, we explore human-centered strategies that recognize users care about job performance, not technical implementation details. Perhaps most valuably, Richard shares his "complexity-aware planning" framework, combining strategic exploration, active experimentation, and analytical planning to manage rewrite risks. We also tackle the difficult question of what to do when legacy customers no longer fit your product direction, offering alternatives to the blunt instrument of "firing customers" that build goodwill while still allowing strategic evolution. Ready to transform how you approach your next system rewrite? This episode provides practical wisdom that could save your team months of frustration and your company millions in wasted effort. Listen using your favorite podcast app or the link in the comments.

There are two kinds of software developers: those who develop and maintain and those who never deploy to production. Eventually, you will need to migrate your legacy system. 𝗦𝘁𝗿𝗮𝗻𝗴𝗹𝗲𝗿 𝗙𝗶𝗴 is a pattern you must know for legacy system migrations. This pattern incrementally replaces specific pieces of functionality with new applications and services. To implement the 𝗦𝘁𝗿𝗮𝗻𝗴𝗹𝗲𝗿 𝗙𝗶𝗴 pattern, you create a facade that intercepts requests going to the backend legacy system. The facade routes these requests either to the legacy application or the new services. And gradually migrate existing features to the new system while consumers keep using the same interface. With the facade safely routing users to the correct application, you can add functionality while ensuring the legacy application continues functioning. Over time, all features migrate to the new system, and the legacy system is no longer necessary. The Strangler Fig pattern is a practical approach for migrating legacy systems. ✅ Allow for gradual migration. ✅ Low-risk transition to a new architecture. ✅ Avoid disruption to end-users. ✅ Maintain the integrity of the legacy system during the migration process. Are you improving your legacy system or pushing a giant mud ball? Share your strategy and help a Software Engineer out there.