Application Modernization - Intro: A Gordian knot issue

In a complex climb or on a mountaineering expedition the goal and the map (see also) to achieve it are essential but are not enough.  On top of these, a set of trade-offs and decisions need to be handled to successfully and safely get to the goal, such as:

• how much material to have: in this case the advantage of less weight against safety and hunger in case of delays caused by poor weather
• length of pitches and how many anchors to use in rock climbing: trading off speed vs the length of potential falls
• Rope discipline: taking the time to keep the belays organized to avoid creating risks in handling messed up ropes

Likewise, in complex IT systems, like Business Platforms, it's not straightforward how to address a transformation toward a cloud solution. It's essential to manage the complexity of the problem across multiple aspects, decoupling problems and issues to avoid complexity pile-ups and exponentially difficult situations.

Decoupling will not be perfect, but like in the Gordian knot myth, forceful actions and decisions are necessary to get a situation unstuck and develop a new and better design equilibrium.  These decisions will have costs (measured in different ways, such as money, time, effort, or lost features) that make it complex to find the target solution with the optimal trade-offs. However, not deciding is also a choice with its own costs (e.g because of security, maintainability, and obsolescence).

In this series, I plan to go in more depth into a set of different aspects to address and optimize these hard decisions, in the context of decoupling and evolving complex enterprise systems. Specifically, I will look into:

1. DDD to Break down the Business Domain - Here the focus is on functional aspects of the business domain, to identify a better functional partition and decoupling of components. Also exploring techniques to break down independent microservices in a single bounded context.
2. Transaction and Events microservices -  Here the focus is on breaking the monolith by addressing the compute side. Traditional enterprise systems are centralized around a transactional core to guarantee business consistency. Cloud and distributed services require re-thinking of requirements and approaches (e.g. with Event Streaming and CQRS) to move from a traditional ACID approach to an eventually consistent one within the constraints of the CAP Theorem.
3. Unravel the data - An often overlooked aspect, that creates long-lasting complexity in large-scale integrations that need data flowing across multiple systems and domains. This is a critical challenge in breaking monoliths since data encapsulation in old legacy systems is lacking because of ad-hoc batch point-to-point integrations.  
4. DevOps to assemble the pieces - All previous aspects focus on decoupling to handle the complexity of the application modernization initiative. This however increases the number of running pieces in the solution and DevOps is the key to handling this complexity, with a documented and auditable approach. This is not limited to traditional build and deploy pipelines but should address all tools to design, observe, manage and improve the solution.