<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Johan Vrolix on Medium]]></title>
        <description><![CDATA[Stories by Johan Vrolix on Medium]]></description>
        <link>https://medium.com/@johanvrolix?source=rss-347bd5be549e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*onDIdT2O2HW6_I7_jfDFtQ@2x.jpeg</url>
            <title>Stories by Johan Vrolix on Medium</title>
            <link>https://medium.com/@johanvrolix?source=rss-347bd5be549e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 01:41:07 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@johanvrolix/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Data Platform Maturity Trap]]></title>
            <link>https://blog.anarchitects.dev/the-data-platform-maturity-trap-6d9d6f7987cb?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d9d6f7987cb</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[data-architecture]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Tue, 31 Mar 2026 10:27:58 GMT</pubDate>
            <atom:updated>2026-03-31T10:27:58.697Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why organizations keep replacing tools instead of fixing architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AkTr5m31a3o-itJa5-r6Rg.png" /><figcaption>AI generated image</figcaption></figure><h4>Introduction</h4><p>Over the past decade, organizations have invested heavily in modern data platforms. They have moved from traditional data warehouses to Hadoop, from Hadoop to cloud data platforms, from there to lakehouses, and more recently to unified platforms such as Microsoft Fabric.</p><p>Each of these generations has been introduced with a similar promise: to finally resolve long-standing issues such as fragmented data landscapes, slow analytics, and the lack of reliable insights.</p><p>Despite these advances, many organisations continue to encounter the same structural problems: they move from one platform to another, invest in new implementations, and yet observe that fundamental challenges remain unchanged.</p><p>This recurring pattern can be described as the <strong>Data Platform Maturity Trap</strong>.</p><h4>Phase 1: The tool promise</h4><p>Each cycle typically begins with the introduction of a new technological paradigm.</p><p>Examples include the belief that Hadoop would solve scalability, that data lakes would provide flexibility, that cloud data warehouses would simplify architecture, or that unified platforms would eliminate fragmentation altogether.</p><p>These platforms promise improvements in scalability, performance, accessibility, and ease of use. Implicit in these promises is the assumption that selecting the right platform will resolve the organization’s data challenges.</p><h4>Phase 2: The platform implementation</h4><p>Once a platform has been selected, organizations initiate implementation programs.</p><p>These programs typically focus on:</p><ul><li>setting up the platform</li><li>structuring workspaces</li><li>building ingestion pipelines</li><li>defining data models</li><li>developing dashboards and reports</li></ul><p>At this stage, the emphasis lies on delivery and execution: engineering teams and consultancies are often highly effective in implementing these solutions, and initial results can be promising.</p><h4>Real-world signal: the certification reflex</h4><p>Within many organisations, maturity is often measured through certifications and vendor partnerships. A common situation is the need to obtain a certain number of certified engineers to maintain a partnership status with a platform vendor.</p><p>This results in efforts such as accelerating certification programs, encouraging employees to obtain platform-specific credentials, and aligning closely with vendor ecosystems.</p><p>From a commercial and operational perspective, this approach is entirely rational: certifications provide credibility, facilitate access to vendor networks, and create measurable indicators of progress.</p><p>At the same time, this behaviour reveals an important pattern. Organisations are optimising for alignment with platforms and vendors, rather than for alignment within their own architecture.</p><h4>The hidden gap</h4><p>Certifications validate knowledge of a platform, but they do not address fundamental architectural questions. They do not clarify how business domains are structured, who owns specific data, how systems align with domain boundaries, or how responsibilities are distributed across the organization.</p><p>As a result, organizations may become highly capable from a technical standpoint while still experiencing persistent issues such as fragmented data landscapes, duplicated logic, inconsistent definitions, and unclear ownership.</p><h4>Certification &lt;&gt; coherence</h4><p>This leads to an important distinction: certifications confirm expertise in the use of specific tools or platforms, but they do not guarantee that the overall architecture is coherent.</p><p>In other words:</p><blockquote>Organizations certify their ability to use technology,</blockquote><blockquote>but rarely structure how their systems, data, and domains relate to one another.</blockquote><h4>Phase 3: The architecture reality</h4><p>After the initial implementation phase, structural issues begin to emerge. These often manifest as duplicated datasets, inconsistencies across reports, proliferation of pipelines, and unclear domain boundaries.</p><p>Multiple teams may develop parallel models of the same concepts, each optimized for their own use cases.</p><p>From a technical perspective, the platform functions as intended, from an architectural perspective, fragmentation persists.</p><h4>Phase 4: The platform disappointment</h4><p>Over time, business stakeholders begin to notice the consequences:</p><ul><li>reports may contradict one another, insights may take longer to deliver than expected, and trust in the data may decrease.</li><li>responsibilities become unclear, and it becomes difficult to determine which version of the truth should be used.</li></ul><p>At this point, the conclusion is often drawn that the platform is not delivering the expected value.</p><h4>Phase 5: The next platform</h4><p>Rather than addressing the underlying architectural issues, organisations frequently respond by exploring alternative technologies.</p><p>This may involve migrating to a different platform, introducing additional tools, reorganizing teams, or launching new transformation initiatives.</p><p>The expectation is that a different technological choice will resolve the problems encountered.</p><p>In doing so, the cycle begins again.</p><h4>The real problem: missing domain architecture</h4><p>At the core of this pattern lies the absence of a shared understanding of the domain. Key questions remain insufficiently addressed:</p><ul><li>What are the core business domains?</li><li>How are responsibilities distributed across those domains?</li><li>Who owns which data?</li><li>What are the key business events?</li><li>Which concepts form the foundation of the organisation’s language?</li></ul><p>Without clear answers to these questions, any platform becomes a technical layer built on top of organizational ambiguity.</p><h4>Architecture before platforms</h4><p>Technology is most effective when it amplifies a well-defined architecture. A more sustainable approach follows a different sequence:</p><ol><li>Domain exploration</li><li>Responsibility mapping</li><li>Domain architecture</li><li>Data and software architecture</li><li>Platform design</li><li>Implementation</li></ol><p>In practice, many organisations begin at step five.</p><h4>Breaking the Maturity Trap</h4><p>Escaping the Data Platform Maturity Trap requires a shift in perspective. Rather than starting from platforms, organizations must begin with the structure of their own domains.</p><p>This involves developing a shared understanding of the business, defining clear boundaries, establishing ownership, and aligning software and data architectures accordingly. Only then can platforms serve as accelerators rather than sources of additional complexity.</p><h4>This is not just a data problem</h4><p>Although this pattern is particularly visible in the context of data platforms, it is not limited to that domain. Similar dynamics can be observed across many areas of technology.</p><p>Organizations replace frontend frameworks without reconsidering domain boundaries, introduce microservices without clearly defining service ownership, migrate to the cloud without redefining responsibilities, or adopt AI tooling without understanding the underlying processes.</p><p>In each case, the underlying assumption remains the same: that a new technology will resolve structural issues. In reality, technologies evolve, but architectures tend to persist.</p><p>Without addressing the underlying structure of domains, responsibilities, and ownership, organizations risk repeating the same cycle regardless of the tools they adopt.</p><p>This pattern is therefore not specific to data platforms, it reflects a broader architectural challenge.</p><h4>What&#39;s the take-away?</h4><p>Modern platforms and tools are powerful and continue to evolve at a rapid pace, however, no technology can compensate for a lack of architectural coherence.</p><p>Replacing tools is relatively straightforward, designing a coherent architecture requires more effort, but provides significantly greater long-term value.</p><p>Ultimately:</p><blockquote>Technology amplifies architecture.</blockquote><blockquote>It does not replace it<em>.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d9d6f7987cb" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/the-data-platform-maturity-trap-6d9d6f7987cb">The Data Platform Maturity Trap</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Architecture is not the map, it’s the meaning behind it]]></title>
            <link>https://blog.anarchitects.dev/architecture-is-not-the-map-its-the-meaning-behind-it-24b663368e26?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/24b663368e26</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 10:38:51 GMT</pubDate>
            <atom:updated>2026-03-20T10:38:51.727Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why ArchiMate 4 feels like a step toward how architects actually think</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JvjPYHqFlzwLxAwm4sw5JA.png" /></figure><h3>Intro</h3><p>In the previous articles, we explored two ideas. First, the paradox of architecture: we aim to reduce complexity, yet our tools and frameworks often become complex themselves. Then, a second observation: our understanding of systems is never complete from the start. It evolves — from simple views to deeper insights to fuller context. Which raises a natural question:</p><blockquote>If architecture is not about modelling everything, and if our understanding is always evolving…<br><strong>what is architecture actually supposed to do?</strong></blockquote><h3>The illusion of completeness</h3><p>In many organizations, there is a persistent belief:</p><blockquote>If we can just map everything: every system, every interaction, every dependency, we will understand the enterprise.</blockquote><p>Modern tooling reinforces this idea. We can now:</p><ul><li>analyse codebases</li><li>detect dependencies</li><li>reconstruct flows</li><li>generate diagrams</li><li>maintain detailed system inventories</li></ul><p>This is incredibly powerful, but it also creates a subtle illusion:</p><blockquote>that <strong>completeness leads to understanding</strong></blockquote><p>In reality, completeness often leads to something else:</p><blockquote><strong>overwhelm</strong></blockquote><h3>Understanding is not the same as knowing everything</h3><p>A complete catalog of a system does not automatically make it understandable, it only creates the <em>possibility</em> of understanding.</p><p>Architecture starts where we:</p><ul><li>select what matters</li><li>structure what we see</li><li>give meaning to complexity</li></ul><p>This is why experienced architects rarely try to model everything, instead, they ask:</p><ul><li>What is relevant for this decision?</li><li>What abstraction helps here?</li><li>What does the audience need to understand?</li></ul><h3>From models to meaning</h3><p>Architecture models are often misunderstood as:</p><blockquote>representations of reality</blockquote><p>But in practice, they are:</p><blockquote>tools for reasoning</blockquote><p>They are not meant to capture everything, they are meant to make something clear enough to act upon.</p><p>This is also why different views exist:</p><ul><li>business views</li><li>application views</li><li>technology views</li></ul><p>Not because reality is fragmented, but because understanding requires perspective.</p><h3>Why ArchiMate 4 is interesting</h3><p>This is where the evolution toward <strong>ArchiMate 4</strong> becomes interesting.</p><p>Not because it introduces something radically new, but because it seems to move in a direction many architects already took in practice.</p><p>A few notable shifts:</p><ul><li>More emphasis on domains and structuring concepts</li><li>Simplification of the meta-model</li><li>Less rigid separation between layers</li><li>More flexibility in how concepts relate</li></ul><p>In other words:</p><blockquote>less focus on modeling everything precisely, more focus on modeling what is meaningful</blockquote><h3>What experienced architects already do</h3><p>Long before any new version of a framework, experienced architects tend to:</p><ul><li>ignore parts of the meta-model that don’t add value</li><li>adapt modeling to the audience</li><li>focus on domains instead of layers</li><li>simplify views instead of expanding them</li><li>evolve models over time</li></ul><p>They don’t aim for:</p><blockquote>completeness</blockquote><p>They aim for:</p><blockquote>clarity and usefulness</blockquote><p>ArchiMate 4 feels like a recognition of that reality.</p><h3>Where tooling fits in</h3><p>Detailed system analysis and discovery tooling can be extremely valuable, they help us:</p><ul><li>understand the current implementation</li><li>uncover hidden dependencies</li><li>identify gaps between AS-IS and TO-BE</li><li>validate assumptions</li></ul><p>But they operate at a different level, they answer:</p><blockquote>what exists</blockquote><p>Architecture, on the other hand, answers:</p><blockquote>what should exist and how it should be structure<em>d</em></blockquote><h3>The role of coherence</h3><p>If there is one thing architecture must provide, it is this:</p><blockquote>coherence</blockquote><p>Coherence between:</p><ul><li>business intent</li><li>domain structure</li><li>system design</li><li>implementation</li></ul><p>Without coherence:</p><ul><li>models drift from reality</li><li>systems drift from intent</li><li>governance becomes friction</li></ul><p>Architecture is the discipline that keeps these layers aligned, not by modelling everything, but by ensuring that what we model <strong>fits together</strong>.</p><h3>From control to guidance</h3><p>This also changes how we think about governance.</p><p>Instead of:</p><ul><li>heavy review boards</li><li>manual interpretation of policies</li><li>late-stage validation</li></ul><p>We move toward:</p><ul><li>clearer models</li><li>shared understanding</li><li>automated guardrails where possible</li></ul><p>But even then:</p><blockquote>not everything can be encoded and not everything should be</blockquote><p>Because architecture is not just about enforcing rules. it is about enabling good decisions.</p><h3>Closing</h3><p>A precise view of a system is valuable, but it is not architecture.</p><p>Architecture begins where we take that information and turn it into something people can understand, reason about, and evolve.</p><blockquote>A complete system map shows us what exists.</blockquote><blockquote><strong>Architecture is what gives it meaning<em>.</em></strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24b663368e26" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/architecture-is-not-the-map-its-the-meaning-behind-it-24b663368e26">Architecture is not the map, it’s the meaning behind it</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Complexity is not the enemy in architecture]]></title>
            <link>https://blog.anarchitects.dev/complexity-is-not-the-enemy-in-architecture-56ae1b66aff9?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/56ae1b66aff9</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[data-architecture]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 10:38:53 GMT</pubDate>
            <atom:updated>2026-03-18T10:38:53.486Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why good architecture models become more detailed over time</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jDWA2i8-avE_hlpLiTG0pQ.png" /></figure><p>In the previous article, we explored a paradox of enterprise architecture: the tools designed to reduce complexity often become complex themselves. But there is another perspective worth considering:</p><p>What if complexity in architecture models is not always a problem?</p><p>What if it is sometimes the result of growing understanding?</p><h3>Architecture as discovery</h3><p>Architecture is rarely created in a single step. When architects start modelling a system or an organisation, they rarely understand everything immediately.</p><p>The first model is usually simple. It might contain:</p><ul><li>a few capabilities</li><li>several key systems</li><li>some major relationships</li></ul><p>This first model is often rough, but useful. It provides a shared starting point. Then something interesting happens; as architects talk to stakeholders, analyse processes, and explore systems, new insights appear.</p><ul><li>Hidden dependencies surface.</li><li>Integration points become visible.</li><li>Responsibilities become clearer.</li></ul><p>And naturally, the model evolves.</p><h3>the model becomes richer</h3><p>As understanding grows, the model typically becomes more detailed, not because the architect wants complexity, but because the reality being described becomes clearer.</p><p>A system landscape that initially showed five systems may later reveal fifteen. A capability map may reveal previously invisible dependencies. Integration flows that seemed simple may turn out to involve multiple services and platforms.</p><p>In other words:</p><blockquote>The system did not become more complex.</blockquote><blockquote>Our understanding simply became more accurate.</blockquote><p>This is a natural and healthy evolution.</p><h3><strong>Why</strong> views matter</h3><p>This is exactly why architecture frameworks emphasise views and viewpoints: not everyone needs the same level of detail.</p><p>A business executive may want to see:</p><ul><li>strategic capabilities</li><li>major systems</li><li>transformation initiatives</li></ul><p>An engineering team may need to see:</p><ul><li>services</li><li>components</li><li>integrations</li><li>data flows</li></ul><p>The same architecture model can therefore produce multiple views, each tailored to a specific audience. The underlying model may grow richer over time, but each view remains clear and purposeful.</p><h3>Pro<strong>gr</strong>essive disclosure of complexity</h3><p>Good architecture does not hide complexity. Instead, it reveals complexity progressively.</p><p>First the big picture, then the important relationships, then the deeper structural elements. This approach is sometimes called <strong>progressive disclosure</strong>.</p><p>It allows people to understand systems step by step, rather than being overwhelmed by detail, and it reflects an important reality:</p><p>Architecture models do not only describe systems, they also reflect the evolution of our understanding of those systems.</p><h3>The real skill of an architect</h3><p>The real skill of an architect is therefore not eliminating complexity, it is managing it, by:</p><ul><li>choosing the right abstractions</li><li>creating views aligned with the audience</li><li>allowing the model to evolve as understanding grows</li></ul><p>Complexity is not the enemy, unmanaged complexity is. Good architecture reveals complexity only when it becomes meaningful.</p><h3><strong>Whe</strong>n standards meet practice</h3><p>If architecture modelling is about balancing clarity and precision, then modelling languages should ideally support that balance. They should provide enough structure to describe systems accurately, but not so much ceremony that modelling becomes harder than understanding.</p><p>Interestingly, this balance seems to be influencing the evolution of architecture standards themselves.</p><p>In the next article, we will look at a development that reflects exactly this shift.</p><p>Because the upcoming ArchiMate 4 appears to move closer to how experienced architects have been using modelling languages pragmatically for years.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=56ae1b66aff9" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/complexity-is-not-the-enemy-in-architecture-56ae1b66aff9">Complexity is not the enemy in architecture</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The paradox of Enterprise Architecture]]></title>
            <link>https://blog.anarchitects.dev/the-paradox-of-enterprise-architecture-fe5933ec99d2?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe5933ec99d2</guid>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[archimate]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Mon, 16 Mar 2026 12:57:01 GMT</pubDate>
            <atom:updated>2026-03-16T13:43:55.477Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why the tools meant to reduce complexity often become complex themselves</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6biXwq8teCyPtqTsDXYXrw.png" /></figure><p>Enterprise architects exist to reduce complexity.</p><p>Organisations grow, systems multiply, processes intertwine, and before long the landscape becomes difficult to understand, let alone change. Architecture is supposed to bring clarity. It provides models, viewpoints, and structures that help people understand how an organization works and how it should evolve.</p><p>And yet there is a quiet paradox at the heart of enterprise architecture: the tools designed to reduce complexity often become complex themselves.</p><p>Anyone who has worked seriously with architecture frameworks or modelling languages has felt this tension. Over time, the very instruments meant to simplify reality begin to mirror the complexity they were meant to tame.</p><h3>The intent: making systems understandable</h3><p>Enterprise architecture exists because organisations are complex socio-technical systems. They consist of people, processes, information, applications, infrastructure, and governance structures interacting in dynamic ways. Without structure, these systems quickly become opaque. Decisions become local, systems evolve independently, alignment disappears.</p><p>Architecture aims to counter this by creating shared understanding, models and viewpoints help answer fundamental questions:</p><ul><li>What does the organization actually do?</li><li>Which capabilities support which outcomes?para</li><li>What needs to change when the business changes?</li></ul><p>In principle, modelling languages are meant to support exactly that: clarity, but something interesting tends to happen as these languages evolve.</p><h3>The drift toward formalism</h3><p>Over time, architecture languages tend to grow.</p><p>They gain:</p><ul><li>more concepts</li><li>more relationship types</li><li>more rules</li><li>more semantic precision</li></ul><p>The motivation behind this evolution is understandable. Architects want to remove ambiguity. They want models that are logically consistent and analyzable. Tool vendors want architectures that can be validated automatically.</p><p>So the meta-model becomes richer. From a theoretical perspective, this strengthens the language. From a practical perspective, it often makes it heavier.</p><p>A simple statement such as:</p><blockquote>&quot;System A uses System B.&quot;</blockquote><p>can suddenly require a chain of modelling constructs involving components, services, interfaces, and realisation relationships.</p><p>Technically correct, conceptually exhausting. The model becomes precise, but the story becomes harder to read.</p><h3>When the language overtakes the conversation</h3><p>Architecture models are not created to satisfy a meta-model, they exist to support conversation. Enterprise architecture sits at the intersection of strategy, technology, and organisational change. Its purpose is to help business leaders, architects, and engineers develop a shared understanding of how the organisation works and how it should evolve.</p><p>But when modelling becomes overly formal, something subtle happens: instead of explaining the organisation, architects start explaining the modelling language and meetings drift toward discussions like:</p><ul><li>Should this be a capability or a service?</li><li>Is this relation &quot;serving&quot; or &quot;used-by&quot;?</li><li>Should we explicitly model the interface?</li></ul><p>The architecture discussion becomes a meta-model discussion. At that point, the tool designed to reduce complexity has started introducing its own.</p><h3>What experienced architects quietly do</h3><p>Interestingly, most experienced architects resolve this tension in the same way. They simplify the language in practice, not by rejecting modelling standards, but by using a pragmatic subset of them. They typically:</p><ul><li>limit the number of concepts they use</li><li>rely on a small set of relationships</li><li>avoid modelling unnecessary intermediate elements</li><li>create models for specific questions rather than describing everything</li></ul><p>In other words, they create <strong>a working dialect</strong> of the modelling language. The goal is no longer to represent the full theoretical richness of the meta-model, the goal is to maximise understanding.</p><p>A good architecture model should make someone say:</p><blockquote>&quot; Now I understand how this works.&quot;</blockquote><p>not</p><blockquote>&quot; Now I understand the meta-model.&quot;</blockquote><h3>Architecture is ultimately about coherence</h3><p>If we step back, the purpose of architecture becomes clearer: architecture is not primarily about diagrams or modelling languages. It is about coherence. Coherence between:</p><ul><li>business intent and operational reality</li><li>capabilities and systems</li><li>teams and responsibilities</li><li>strategy and implementation</li></ul><p>Models are simply instruments that make that coherence visible.</p><p>When models become the center of the discipline, the discipline starts drifting away from its purpose. The best architecture work rarely starts with modelling languages, it starts with understanding the domain , understanding how value flows through the organisation, understanding how people, systems, and decisions interact.</p><p>Only then do models appear as tools to capture that understanding.</p><h3>The paradox revisited</h3><p>Perhaps the paradox of enterprise architecture is not that modelling languages become complex, perhaps the real challenge is that our understanding of systems evolves. And when our understanding deepens, our models naturally become richer.</p><p>In the next article, we will explore this idea further:</p><p>What if complexity in architecture models is not a failure of architecture, but a sign that our understanding of the system is improving?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe5933ec99d2" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/the-paradox-of-enterprise-architecture-fe5933ec99d2">The paradox of Enterprise Architecture</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why your Angular PRs keep getting bigger (and why it’s not a skill problem)]]></title>
            <link>https://blog.anarchitects.dev/why-your-angular-prs-keep-getting-bigger-and-why-its-not-a-skill-problem-f15d1d7efcde?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/f15d1d7efcde</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[angular]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[nx]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 16:02:55 GMT</pubDate>
            <atom:updated>2026-02-25T14:03:34.491Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7GgJsynveFPcf7pI2tosiQ.png" /><figcaption>AI Generated image</figcaption></figure><p>In the early months of a codebase, pull requests are small and contained: A button change touches one component, a new feature lives inside one domain. Reviews are quick and confidence is high.</p><p>Two years later, something feels different: A minor change suddenly spans five libraries, a UI tweak requires state adjustments elsewhere, a &quot;simple&quot; refactor turns into a 1,200-line PR.</p><p>Nothing dramatic happened, no one made a catastrophic architectural decision and yet the repo starts to feel fragile. The common explanation?</p><blockquote>“Engineers aren’t disciplined enough.”</blockquote><p>In most cases, that’s wrong. This is not a skill problem. It’s a structural one.</p><h3><strong>The hidden mechanism behind growing PRs</strong></h3><p>Angular, especially when combined with Nx, provides powerful structural guardrails.</p><p>Even without Nx, similar discipline can be implemented using ESLint rules, architectural linting, or custom CI checks. Tooling helps. But tooling alone does not guarantee structural integrity…</p><p>Over time, three patterns tend to emerge:</p><h4><strong>1. Shared libraries start absorbing ownership</strong></h4><p>What begins as a small shared utility folder becomes a central dependency hub. Features import from shared. Shared imports from features (sometimes indirectly). Domain logic leaks into generic libraries. Now a change in one feature subtly depends on behavior defined elsewhere.</p><p>For example, a pricing feature begins importing shared validation utilities. Over time, those utilities start referencing domain-specific types for convenience. Later, another feature imports the same shared module — unintentionally inheriting pricing assumptions. Now changing a pricing rule requires updates across shared logic, validation flows, and multiple feature modules.</p><p>What looked like reuse quietly became coupling.</p><p>A small modification ripples outward. PR size increases.</p><h4><strong>2. State ownership becomes ambiguous</strong></h4><p>Global stores expand “just in case.” UI state gets promoted upward for convenience. Observables are subscribed to in multiple places. Side effects become scattered. Now when you change one async flow, it’s unclear what else depends on it.</p><p>PRs grow not because the feature is big but because ownership is unclear.</p><h4><strong>3. Boundaries become suggestions</strong></h4><p>You may have Nx module boundary rules, you may enforce ESLint dependency constraints, you may even have CI checks preventing forbidden imports. But over time, exceptions accumulate. Warnings remain warnings. Rules get loosened under deadline pressure. Feature-to-feature imports slip in &quot;just this once&quot;. Shortcuts are justified under deadline pressure.<br>Tooling doesn’t usually fail. Discipline erodes around it.</p><p>No single decision breaks the architecture. But the aggregate effect increases coupling. And coupling expands the surface area of every change.</p><h3><strong>The real cost of bigger PRs</strong></h3><p>Larger PRs don’t just slow reviews.</p><p>They introduce structural risk:</p><ul><li>Higher regression probability</li><li>Longer review cycles</li><li>Reduced confidence in refactors</li><li>Upgrade hesitation</li><li>Slower onboarding</li></ul><p>Eventually, teams start avoiding certain domains entirely. Not because they’re incompetent, but because the cost-of-change feels unpredictable.</p><p>That unpredictability is structural friction.</p><h3><strong>Why adding developers doesn’t fix it</strong></h3><p>When PRs grow and velocity slows, the reflex is often to add capacity. More developers, more parallel work, more feature throughput. More! More! MORE!</p><p>But structural friction compounds with scale. If boundaries are weak, every additional contributor increases the probability of coupling drift.</p><p>You don’t solve structural entropy by increasing throughput. You solve it by reducing coupling.</p><h3>The structural alternative</h3><p>Instead of asking: &quot;How do we ship faster?&quot;, ask: &quot;Why does change feel expensive?&quot;.</p><p>Look at:</p><ul><li>Cross-domain PR frequency</li><li>Growth of shared libraries</li><li>Scattered subscriptions</li><li>Global state surface</li><li>Boundary rule violations (whether enforced by Nx, ESLint, or custom tooling)</li></ul><p>The solution is rarely a rewrite. <br>It’s usually incremental containment:</p><ul><li>Reinforce domain boundaries</li><li>Clarify state ownership</li><li>Reduce shared dumping grounds</li><li>Gradually tighten constraints</li><li>Split large PRs structurally</li></ul><p>Small, consistent structural interventions compound. Over time, PRs shrink again. Not because engineers improved, but because the system stopped resisting change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KRgfGmyttxT8lSIIJ-5Lxw.png" /><figcaption>AI Generated image</figcaption></figure><h3><strong>A structural health signal</strong></h3><p>If you notice PRs getting bigger month after month, treat it as a leading indicator. It’s not a failure, it’s a signal your architecture is drifting. And drift is natural in growing systems.</p><p>The difference between fragile and resilient codebases isn’t whether drift happens, it’s whether governance exists to contain it.</p><p>Structural clarity compounds, so does entropy. The question isn’t whether your Angular codebase will evolve, it’s whether it evolves deliberately or by accident.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mOUwSCBXugd9naP_lf_nhg.png" /><figcaption>AI Generated image</figcaption></figure><blockquote>If structural friction is becoming the real constraint in your Angular/Nx system, a short structural audit can clarify whether incremental governance would reduce cost-of-change.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f15d1d7efcde" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/why-your-angular-prs-keep-getting-bigger-and-why-its-not-a-skill-problem-f15d1d7efcde">Why your Angular PRs keep getting bigger (and why it’s not a skill problem)</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Best-of-Breed: Why the Next Decade Belongs to Architects, Not Integrators]]></title>
            <link>https://blog.anarchitects.dev/beyond-best-of-breed-why-the-next-decade-belongs-to-architects-not-integrators-c529ecf2d6ed?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/c529ecf2d6ed</guid>
            <category><![CDATA[modern-data-architecture]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Fri, 24 Oct 2025 09:41:37 GMT</pubDate>
            <atom:updated>2025-10-24T09:41:37.823Z</atom:updated>
            <content:encoded><![CDATA[<h3>The future isn’t about adding more tools, it’s about restoring coherence.</h3><p>The last decade was ruled by <em>best-of-breed</em>. Every department built its own digital stack: the best CRM here, the best analytics tool there.<br>It was liberating, until it became unmanageable. Now, companies are rediscovering something they forgot in the rush to the cloud: architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SLi9JGKPLNwz9z94HmBb7w.png" /></figure><h4>1. The Age of Best-of-Breed</h4><p>For years, “best-of-breed” was the north star of digital transformation. Why settle for one vendor’s suite when you can assemble the perfect combination yourself?</p><ol><li>Marketing picked HubSpot.</li><li>Sales chose Pipedrive.</li><li>Finance automated billing in Teamleader.</li><li>Operations adopted Monday or Jira.</li></ol><p>Everyone optimized for their own success.</p><p>It was the age of independence: fast, flexible, empowering. But there was one flaw: no one designed the whole.</p><blockquote><em>What once felt like freedom slowly turned into fragmentation.</em></blockquote><p>Each system defined its own truth. Customers, orders, payments, and performance all existed, but in parallel universes. The organization as a whole lost its single story.</p><h4>2. The Integrator Era</h4><p>When the pain became visible, a new hero emerged: <strong>the integrator</strong>.<br>Integration platforms, iPaaS, and APIs promised to stitch the chaos back together.</p><p>We built bridges: Zapier flows, API gateways, ETL pipelines.<br>IT teams became digital plumbers, connecting endpoints and syncing data.</p><p>It worked — for a while. But each connection added complexity. Each dependency reduced flexibility. Every new tool made the web harder to maintain.</p><blockquote><em>Integrators connected systems — but not understanding.</em></blockquote><p>We learned that connectivity isn’t coherence. Data flowing between misaligned systems doesn’t create unity. <br>It just moves the confusion faster.</p><h4>3. The Breaking Point</h4><p>Now, the cracks are impossible to ignore.</p><ul><li>Reports don’t match between departments.</li><li>Integrations break silently after a schema update.</li><li>Business logic hides in scripts no one remembers writing.</li><li>AI projects stall because the data underneath lacks meaning.</li></ul><p>Leaders are starting to ask deeper questions:</p><blockquote><em>“Where does our information actually live?”<br> “What is our single source of truth?”<br> “Why can’t we trust our own data?”</em></blockquote><p>Those are not IT questions. They’re architectural ones.</p><h4>4. The Rise of the Architect</h4><p>Enter the <strong>Architect</strong>,<strong> </strong>not as a job title, but as a mindset. The architect doesn’t start with tools. They start with <em>understanding</em>.</p><p>Architects:</p><ul><li>Think in systems, not silos.</li><li>Map how value flows through the organization.</li><li>Model domains before choosing technologies.</li><li>Align business, software, and data around shared meaning.</li></ul><blockquote><em>Where integrators connect APIs, architects connect understanding.</em></blockquote><p>This principle is embodied in <strong>Unified Domain Exploration (UDE)</strong>:<br> a structured way to rediscover your organization’s core logic before building or integrating anything.</p><p>We map the <em>contexts</em>, <em>events</em>, and <em>flows</em> that define how your business actually works.<br>Only then do we design a reference architecture — one that gives tools their place and purpose.</p><p>The goal isn’t to control technology, but to make it coherent.</p><h4>5. The New Principle: Best-of-Architecture</h4><p>The first wave of digital transformation was <strong>best-of-breed, </strong>picking the best tools.<br>The second was <strong>integration</strong>, connecting them all.<br>The next one will be <strong>best-of-architecture</strong>, designing for coherence from the start.</p><p>Best-of-architecture means:</p><ul><li>Modeling before building.</li><li>Understanding before automating.</li><li>Integrating meaning, not just data.</li><li>Creating ecosystems that evolve instead of entangle.</li></ul><blockquote><em>Tools deliver speed.<br>Architecture delivers direction.</em></blockquote><p>When you get the architecture right, you can swap, scale, or innovate without breaking the system. That’s how you build digital resilience.</p><h4>6. Closing Thought</h4><p>We spent a decade assembling the perfect collection of tools.<br>The next decade will be about making them work together with intention.</p><p>Because the problem isn’t that companies use too many tools.<br>It’s that they’ve forgotten <em>why</em> those tools exist in the first place.</p><blockquote><em>Architecture doesn’t slow progress.<br> It makes progress sustainable.</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c529ecf2d6ed" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/beyond-best-of-breed-why-the-next-decade-belongs-to-architects-not-integrators-c529ecf2d6ed">Beyond Best-of-Breed: Why the Next Decade Belongs to Architects, Not Integrators</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Tool Chaos to Digital Ecosystem]]></title>
            <link>https://blog.anarchitects.dev/from-tool-chaos-to-digital-ecosystem-48ba92efc767?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/48ba92efc767</guid>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[information-technology]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Tue, 14 Oct 2025 07:47:24 GMT</pubDate>
            <atom:updated>2025-10-14T07:47:24.538Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Why Integration Isn’t an IT Problem; It’s an Architectural One</strong></h4><p>The modern cloud stack was built on a best-of-breed philosophy: pick the best tool for every task.<br>But after years of stacking SaaS products, many organisations now face a hidden cost: fragmentation.<br>APIs connect the dots, yet the big picture remains blurry. It’s not the tools that fail, it’s the missing architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e-x7hVxeCmgu8aj9h6ku6A.png" /></figure><p>For the past decade, companies have eagerly adopted SaaS tools to modernize and speed up their operations.<br>CRM, marketing automation, project management, analytics; there’s a tool for everything.<br>Each one promises instant value, no IT department required.<br>And for a while, it worked.<br>But then something happened.<br>The more tools companies added, the less connected they became. The cloud gave every problem a tool, but no one guarded the whole.</p><h4>1. The SaaS Revolution and Its Side Effects</h4><p>SaaS has given organizations immense agility. <br>A marketing team can launch campaigns in HubSpot.<br>Finance can automate invoicing in Teamleader.<br>HR can track performance in BambooHR.<br>Each tool solves one problem brilliantly within its niche, a reflection of the cloud’s best-of-breed philosophy.<br>Instead of one monolithic suite, businesses assemble a constellation of specialised apps.<br>It’s a wonderful idea in theory: pick the best tool for every job.<br>In practice, it fragments the organization’s digital foundation.</p><p>Soon, the conversation shifts from “<em>how do we get this tool running?</em>” to “<em>how do we make all of this work together?</em>”</p><h4>2. The Reality of Integration</h4><p>Every SaaS vendor reassures you:</p><blockquote><em>“Don’t worry, we have an API.”</em></blockquote><p>And that’s true. APIs give you access to data, but not to meaning.<br>A CRM’s <em>Customer </em>isn’t the same as a billing system’s <em>Client</em>.<br>The field <em>Status = Active</em> may mean something entirely different in each context.</p><p>APIs connect systems technically. They don’t align them semantically.<br>So companies start building fragile bridges with Zapier, Make, or custom scripts, only to discover that every small schema change can break the chain.</p><p>The result:</p><ul><li>Reports don’t match between departments.</li><li>Data is duplicated or inconsistent.</li><li>Integrations pile up like digital spaghetti.</li></ul><p>The systems are talking – but they’re not understanding each other.</p><h4>3. Why This Isn’t an IT Problem</h4><p>Most organisations treat integration as a technical challenge. But the real issue lies elsewhere.<br>It’s not that the APIs don’t work, it’s that the business domains aren’t aligned. Teams use different concepts, definitions, and rules without realising it.<br>This isn’t about code. It’s about shared understanding.</p><p>Without a common domain model: a coherent view of how customers, products, payments, and events relate, no amount of integration will bring order. Integration fails not because of technology, but because of fragmented meaning.</p><h4>4. The Architectural Perspective</h4><p>This is where architecture steps in. Not as another IT layer, but as the missing foundation.</p><p>Start with Unified Domain Exploration (UDE), a structured process to rediscover the logic of your business before touching any tool or API.</p><p>We map:</p><ul><li>Contexts: where things happen and who owns them.</li><li>Events: what actually changes in the system.</li><li>Information flows: how data moves and transforms.</li></ul><p>From that, design a reference architecture for integration. One that defines how systems should interact, what each system owns, and where truth resides.<br>Only then connect the tools, not randomly, but purposefully. Real integration starts where tools end, with understanding the domain.</p><h4>5. From Chaos to Coherence</h4><p>When you reframe integration as an architectural discipline, things change:</p><ul><li>Data becomes consistent across systems.</li><li>Each application has a clear responsibility.</li><li>You can evolve your stack without breaking everything else.</li><li>Reporting, automation, and AI become reliable because the underlying structure makes sense.</li></ul><p>You’re no longer maintaining a tangle of connections. You’re orchestrating a coherent ecosystem.</p><p>Tools will change. Architecture endures.</p><h4>6. Closing Thought</h4><p>Companies believe they become faster by adding more tools. In reality, they become faster by understanding what they’re doing.</p><p>Architecture <strong>doesn’t</strong> <em>slow you down</em>, it gives you <strong>direction</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48ba92efc767" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/from-tool-chaos-to-digital-ecosystem-48ba92efc767">From Tool Chaos to Digital Ecosystem</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Siloed Thinking to Shared Insight: The Power of Unified Domain Exploration]]></title>
            <link>https://blog.anarchitects.dev/from-siloed-thinking-to-shared-insight-the-power-of-unified-domain-exploration-8093d8a61822?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/8093d8a61822</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[application-development]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[business-strategy]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Wed, 14 May 2025 10:37:09 GMT</pubDate>
            <atom:updated>2025-05-14T10:37:09.488Z</atom:updated>
            <content:encoded><![CDATA[<p>Today, software is embedded in everyday life. Our phones, TVs, household appliances, cars — even light bulbs — all run on software. And all this use of software produces vast amounts of data.</p><p>Companies rely on software to run their business and on data to gain insights, build competitive advantages, and even forecast what’s going to happen next. As a result, software development and data engineering have become booming disciplines, essential to scaling and supporting modern enterprises.</p><p>Both domains are evolving rapidly — with new frameworks, programming languages, platforms, components, and tools emerging constantly.</p><p>Yet at the same time, we hear — and often experience — stories of delays, budget overruns, poor scalability, inefficiencies, mismatches between what’s built and what’s being measured, and the constant need for rework.</p><p>Much of this stems from the fact that software and data architects operate in silos, despite working on the same business reality. They model the same world — but observe it differently:</p><ul><li>Software looks at behavior, interaction, rules, processes.</li><li>Data looks at what has happened, what needs to be measured and analysed, what is likely to happen.</li></ul><p>This disconnect isn’t just theoretical — it plays out in real projects every day.</p><p>Software teams typically kick off first. They gather requirements from business stakeholders, focus on user interactions, business rules, and system behavior, and start modeling and building the application.</p><p>Weeks or months later, the data team enters the picture. They organize their own meetings to collect reporting needs, KPIs, and analytical definitions — often talking to the same business stakeholders, asking many of the same questions.</p><p>But by then, the context is already fragmented.</p><p>The data team receives requirements without insight into the original conversations that shaped the application. There’s no shared model or language to rely on. As a result, terms are reinterpreted, processes are abstracted differently, and critical details are lost in translation.</p><p>This often leads to reporting that doesn’t match what the software does — and users who don’t trust the data. Dashboards surface inconsistent metrics. Business logic is duplicated, but subtly different. Time, budget, and trust are wasted — all because the domain was explored twice, and separately.</p><blockquote>“The greatest waste in software and data isn’t bad code — it’s misaligned understanding.” That line came to me while writing this — and I’m curious how others feel about it.</blockquote><p>But what if we could avoid this disconnect entirely?</p><p>What if business stakeholders, software, and data architects explored the domain together, from the very beginning?</p><p>What if we didn’t separate behavior from measurement — but instead treated them as two perspectives on the same reality?</p><p>That’s the idea behind <strong>Unified Domain Exploration</strong>:</p><blockquote>A shared approach to understanding the business domain that brings together software and data disciplines — aligning terminology, capturing business logic, and uncovering both operational and analytical needs in one unified process<em>.</em></blockquote><p>By exploring the domain collaboratively, we lay a foundation where software and data models reinforce each other instead of drifting apart. We speak the same language. We reduce ambiguity. We design systems that not only run the business, but also reflect it clearly through data.</p><h3>A DDD-Inspired Approach to Unified Domain Exploration</h3><p>Unified Domain Exploration isn’t a vague ideal — it’s a practical, structured process, inspired by the principles of Domain-Driven Design (DDD). It uses collaborative modeling techniques that help teams gain a deep, shared understanding of the business domain from both a behavioral and analytical perspective.</p><p>Some key practices include:</p><ul><li><strong>Domain Storytelling:</strong> to visualize how domain experts actually work by mapping real-world interactions, responsibilities, and the use of information</li><li><strong>Event Storming</strong>: to uncover business processes, domain events, and the flow of information</li><li><strong>Context Mapping</strong>: to identify boundaries, responsibilities, and integration points between subdomains</li><li><strong>Use Case Modeling</strong>: to define core interactions and expected outcomes</li><li><strong>Shared Glossary (Ubiquitous Language)</strong>: to align terminology across software, data, and business stakeholders</li></ul><p>These are well-established DDD practices. <strong>Unified Domain Exploration extends them with an additional step: <em>Pulse Mapping</em>.</strong></p><p><strong>Pulse Mapping</strong> introduces a dedicated moment for software and data architects to collaborate explicitly on <strong>observability, traceability, and data availability</strong> — ensuring that what matters most in the domain is not only implemented functionally, but also made accessible for <strong>analytics, monitoring, and data governance</strong>.<br>It bridges the gap between business logic and measurable outcomes, allowing teams to design applications that are ready to power operational dashboards, data platforms, and compliance requirements from day one.</p><p>The outcome?</p><blockquote>One shared model, understood and supported by all disciplines — and directly usable for both software design and data modelling.</blockquote><h4>How This Translates into a Data Warehouse</h4><ol><li><strong>Conceptual model</strong> Derived from domain concepts, entities, and relationships identified during exploration (e.g., Order, Customer, Invoice).</li><li><strong>Logical model</strong> Structured per bounded context, normalised into consistent data structures (e.g., hubs and links in a Data Vault model).</li><li><strong>Physical model</strong> Optimised for performance, but with a clear lineage back to domain events and use cases, ensuring transparency and trust.</li></ol><h4>How This Translates into Software Development</h4><ul><li><strong>Bounded contexts</strong> become well-defined modules or services.</li><li><strong>Use cases</strong> drive the core application logic and user interactions.</li><li><strong>Domain events</strong> enable asynchronous communication and integration across contexts or systems.</li></ul><h4>Even When Using Off-the-Shelf Software</h4><p>Unified Domain Exploration is also valuable when custom development isn’t the goal:</p><ul><li>It clarifies where purchased systems fit within the business domain.</li><li>It makes overlaps and gaps explicit, helping to avoid redundancy.</li><li>It provides a foundation to define smart integrations and prevent semantic misalignment between systems.</li></ul><h3>A Concrete Example: A Next-Generation Job Board Platform</h3><p>Imagine a startup launching a job board where companies can post vacancies and candidates can apply online. But this isn’t just a basic job site: they aim to automate significant parts of the hiring workflow.</p><p>Beyond managing job postings and applications, the platform must:</p><ul><li>Allow recruiters to assign <strong>standardized</strong> or <strong>custom-built assessments</strong> to job offers</li><li>Automatically <strong>generate employment contracts</strong> based on accepted offers</li><li>Enable <strong>digital signing</strong> of contracts</li><li>Handle <strong>fees</strong>, <strong>commission rates</strong>, and <strong>payment schedules</strong> automatically once a hire is finalised</li></ul><p>A seemingly straightforward idea quickly grows into a sophisticated ecosystem of interdependent processes.</p><h4>Without Unified Domain Exploration</h4><p>Here’s what typically happens:</p><ul><li>The software team interviews stakeholders and starts defining entities like <em>JobPosting</em>, <em>Application</em>, <em>Assessment</em>, and <em>Contract</em> based on their own assumptions about hiring processes.</li><li>The data team gets involved much later when executives want dashboards showing “assessment completion rates,” “conversion rates from application to hire,” or “total fees collected per client.” Without understanding the original business logic, they reverse-engineer incomplete or inconsistent datasets, interpret column names differently, and ask business users for clarification — only to receive slightly different explanations than the software team originally heard.</li></ul><p>The result?</p><ul><li>Dashboards show numbers that don’t align with operational reports.</li><li>Contract, fee, and payment data are inconsistently tracked or misinterpreted.</li><li>Stakeholders lose trust in both the platform and the reporting.</li><li>Every insight request begins with: “How was this data pulled?”</li></ul><h4>With Unified Domain Exploration</h4><p>Now imagine both teams aligning from the start.</p><p>In a shared domain exploration session, they map the journey from job creation to candidate hiring and onboarding:</p><blockquote><strong>Recruiter posts job → Assigns assessments → Candidate applies → Candidate completes assessments → Recruiter reviews application → Offer extended → Contract generated → Contract signed → Fee invoiced</strong></blockquote><p>They identify key domain events and concepts (<em>JobPosting</em>, <em>Assessment</em>, <em>Application</em>, <em>Offer</em>, <em>Contract</em>, <em>FeeInvoice</em>), and define bounded contexts like <em>Job Management</em>, <em>Assessment Management</em>, <em>Application Management</em>, <em>Contract Management</em>, and <em>Billing</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-VekrcCxqtNLPJjxVgaJAA.png" /><figcaption>Event Storming. AI generated image</figcaption></figure><p>They also capture business rules, such as:</p><ul><li>Standard assessments must be approved by an admin before reuse.</li><li>Contracts must comply with local labor laws depending on candidate location.</li><li>Fee rates vary by customer type and must be calculated automatically upon contract signature.</li></ul><p>From this shared model:</p><ul><li>The software team builds modular services that mirror real hiring and billing flows.</li><li>The data team models domain events and transitions to allow clean, event-driven reporting (e.g., &quot;time from application to hire&quot;, &quot;revenue per customer&quot;).</li><li>Data definitions, ownership, and quality expectations are agreed upon upfront — no retrofitting.</li><li>Everyone speaks the same language — and both the business and candidates get a seamless experience.</li></ul><h3>The Benefits of Unified Domain Exploration</h3><p>Unified Domain Exploration isn’t just a modeling technique — it’s a strategic enabler. By aligning everyone around the same domain understanding, each group benefits in tangible ways:</p><h4>For the Business</h4><ul><li>Fewer workshops, fewer questions — no need to repeat the same explanations to different teams</li><li>Shared language — no more confusion about what &quot;application &quot;, &quot;hire&quot;, or “assessment” actually mean</li><li>Higher trust — when reports match what users see in the system, confidence grows</li><li>Faster delivery — clearer understanding leads to fewer iterations and rework</li></ul><h4>For Software Teams</h4><ul><li>Clearer requirements grounded in actual business language and events</li><li>Bounded contexts that reflect real business domains, enabling modular, maintainable code</li><li>Use-case-driven design that aligns architecture with what users really need</li><li>Domain events that support scalable, loosely-coupled integration</li></ul><h4>For Data Teams</h4><ul><li>Early involvement — understanding the domain before data models or pipelines are built</li><li>Models aligned with software — no more reverse-engineering source systems</li><li>Clear lineage from domain event to KPI or dashboard</li><li>Better conversations with business stakeholders, based on shared concepts</li></ul><h4>For the Organization</h4><ul><li><strong>Better alignment</strong> between business strategy and technology execution</li><li><strong>Faster time to value</strong> through fewer handovers, less rework, and clearer ownership</li><li><strong>Lower total cost of ownership</strong> by reducing duplication and increasing maintainability</li><li><strong>Increased agility</strong> thanks to modular, domain-aligned design</li><li><strong>Improved data quality and trust</strong> across systems and reporting layers</li><li><strong>Sustainable growth</strong> enabled by scalable, business-aligned architecture</li></ul><p>Unified Domain Exploration creates a shared mental model — one that guides decisions, aligns expectations, and connects the dots between what happens in the business, what gets built in software, and what gets measured in data.</p><h3>Is This Really New?</h3><p>The idea of exploring a business domain isn’t new. Domain-Driven Design has long emphasized the value of techniques like event storming, use case modeling, and ubiquitous language — but these practices are typically applied within the scope of <strong>software development</strong>.</p><p>In data architecture, there’s also a strong tradition — and a clear best practice — of starting from a <strong>business-driven conceptual and logical model</strong>. These models define key entities, relationships, and definitions, ideally before touching any source systems. The source data is then mapped to this business model, and further translated into physical structures and ELT pipelines.</p><p>However, in practice, many data initiatives <strong>don’t start from the business model</strong>. Pressured by deadlines or unclear ownership, they fall back to <strong>source-driven modeling</strong> — reverse-engineering database schemas and trying to reconstruct meaning afterwards.</p><p>What’s often missing is a <strong>shared exploration</strong>: a structured collaboration where software and data teams align on the domain together — upfront. Without that, software ends up reflecting business behavior, while data reflects system implementation — not necessarily business understanding.</p><p>Unified Domain Exploration doesn’t aim to replace these modeling practices. It seeks to <strong>connect</strong> them — giving all teams a shared, living foundation rooted in the domain itself.</p><h3>Beyond Alignment: Metadata for Agentic Systems</h3><p>Unified Domain Exploration doesn’t just solve today’s integration and modeling pain. It also sets the stage for tomorrow’s intelligent systems.</p><p>Most generative AI and agent-based systems rely on structured metadata to function intelligently. But what’s often missing is shared context — a clear, consistent understanding of what data means, how it’s produced, and how it relates to the business.</p><p>Unified Domain Exploration provides exactly that:</p><ul><li>A <strong>shared glossary</strong> rooted in business meaning</li><li>A <strong>context map</strong> that defines responsibility and integration</li><li><strong>Domain events</strong> that expose intent and outcome</li><li><strong>Use cases</strong> that reveal behaviour and motivation</li></ul><p>This isn’t just helpful for teams — it’s machine-readable structure for any system that needs to reason about data.</p><p>New platforms are being designed with AI in mind from day one. UDE provides the semantic scaffolding to make them not just functional, but intelligent and trustworthy.</p><h3>Tooling Synergy: Where Strategy Meets Execution</h3><p>Unified Domain Exploration lays the strategic groundwork for building both operational systems and analytical platforms — but to move fast, teams often rely on automation frameworks: code generation tools, model-driven pipelines, or monorepo-based modular architectures.</p><p>These tools can dramatically accelerate delivery — but only if they’re fed with a well-understood, consistent domain model.</p><p>Unified Domain Exploration provides:</p><ul><li>Bounded contexts that drive separation of concerns in both software and data</li><li>Domain events and use cases that inform which processes and data flows to prioritise</li><li>A shared glossary that reduces ambiguity in naming, modelling, and code generation</li><li>Clear traceability from business reality to technical implementation</li></ul><p>In software development, this enables modular, scalable architectures that reflect the business. In data engineering, it improves the structure, quality, and maintainability of automated data pipelines.</p><blockquote>Whether you’re generating APIs, schema definitions, or ELT pipelines — automation is only as good as the model it’s built on.</blockquote><p>Unified Domain Exploration <strong>doesn’t</strong> replace your tools — <strong>it makes them smarter.</strong></p><p>The gap between software and data won’t close by itself. And as organisations grow more complex and data-driven, that gap only becomes more painful.</p><p>But it doesn’t have to stay that way.</p><p>When we stop treating software and data as separate worlds — and start exploring the domain together — something shifts. We build smarter. We measure what matters. We move faster with fewer surprises.</p><p>Unified Domain Exploration isn’t a methodology. It’s a mindset.<br>And once you’ve experienced it, going back to silos feels… outdated.</p><p>If any of this resonates — or challenges how your teams currently work — it might be time to step into a shared room, grab a roll of brown paper, and start mapping your domain together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8093d8a61822" width="1" height="1" alt=""><hr><p><a href="https://blog.anarchitects.dev/from-siloed-thinking-to-shared-insight-the-power-of-unified-domain-exploration-8093d8a61822">From Siloed Thinking to Shared Insight: The Power of Unified Domain Exploration</a> was originally published in <a href="https://blog.anarchitects.dev/">Anarchitects</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Architecting Scalable Relationships: Mastering Modularity with NX, NestJS, and TypeORM]]></title>
            <link>https://medium.com/@johanvrolix/architecting-scalable-relationships-mastering-modularity-with-nx-nestjs-and-typeorm-ebf4d5ffdd0d?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebf4d5ffdd0d</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[monorepo]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Mon, 26 Feb 2024 17:26:25 GMT</pubDate>
            <atom:updated>2024-02-26T17:26:25.338Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gjDHP78v5LU96hbw3kPT9w.png" /></figure><p>In the rapidly evolving landscape of software development, the quest for efficiency, scalability, and maintainability prompts developers to explore and adopt architectural patterns and tools that promise to streamline processes and bolster application performance. This article delves into a powerful trio — NX, NestJS, and TypeORM — and showcases how leveraging these technologies in concert within a three-tier architecture can significantly enhance the modularity of backend applications. Through the development of a blogging platform, encompassing entities such as Article, Comment and Category, we unravel a strategy for implementing business logic that champions maximum modularity.</p><h3>Introduction</h3><p>The combination of NX, NestJS, and TypeORM represents a formidable toolkit for developers aiming to construct robust, scalable backend applications. NX provides an extensible environment for managing monorepos, NestJS offers a progressive framework for building efficient server-side applications, and TypeORM brings an advanced ORM technique for seamless database interaction. This article aims to explore the symbiotic relationship between these tools within a three-tier architecture, emphasizing the creation of reusable libraries aligned with each architectural layer to achieve unparalleled modularity.</p><h3>Background</h3><h4>NX Monorepo</h4><p><a href="https://nx.dev/">NX</a> stands out for its ability to organize code in a monorepo, facilitating shared libraries and streamlined version control across multiple projects. This setup is ideal for large-scale applications requiring a unified codebase for various components.</p><h4>NestJS Framework</h4><p><a href="https://nestjs.com/">NestJS</a>, inspired by Angular, adopts a modular approach, making it easier to organize application logic into manageable chunks. Its compatibility with TypeORM ensures a cohesive environment for handling complex data relationships.</p><h4>TypeORM</h4><p><a href="https://typeorm.io/">TypeORM</a> simplifies database interactions by allowing developers to perform queries using TypeScript or JavaScript, abstracting away the direct use of SQL. Its integration with NestJS enhances the ORM capabilities, particularly in managing entity relationships.</p><h3>Setting Up an NX Monorepo</h3><p>To kickstart a project with NX, NestJS, and TypeORM, begin by setting up an NX workspace:</p><pre>npx create-nx-workspace@latest my-blog --preset=empty --pm=yarn<br>cd my-blog<br>yarn nx add @nx/nest<br>yarn add @nestjs/typeorm typeorm pg<br>yarn nx generate @nx/nest:application api</pre><p>This sets the stage for a monorepo environment where different aspects of the application can be developed in isolation yet work cohesively and installs the necessary TypeORM dependencies and support for PostgreSQL (install driver package for your database of choice).</p><h3>Implementing Maximum Modularity</h3><p>Embracing maximum modularity within a three-tier architecture for backend applications requires a strategic approach, especially when leveraging a powerful combination of NX, NestJS, and TypeORM. This method is particularly beneficial when developing reusable libraries that align with each architectural layer, ensuring that components are both scalable and maintainable.</p><h4>Data Access Libraries: Entity and Repository Design</h4><p>In a modular architecture, each entity — Article, Comment and Category — should be encapsulated within its own data access library. This encapsulation allows for the entities to be reused across different parts of the application without direct dependency on one another. Here’s how we approach this:</p><ul><li><strong>Separate Data Access Libraries:</strong> For each entity, we create a dedicated library that houses both the TypeORM entity and a corresponding NestJS provider for the repository. This structure facilitates independent management and evolution of each entity.</li><li><strong>Handling Relationships</strong>: Instead of using direct relationship decorators like <em>@OneToMany</em> or <em>@ManyToMany</em>, which necessitate the inclusion of related entities, thereby coupling them tightly, we adopt a different strategy. For many-to-many relationships, we introduce separate data access libraries dedicated to the relationship itself, equipped with their entity and repository. This entity explicitly represents the join table in the database. For one-to-one and one-to-many relationships, we simply include the relevant foreign key IDs in the entities. This approach decouples the entities, allowing them to be used independently.</li></ul><p>For each entity (Article, Comment and Category), create a separate data access library. This library includes a TypeORM entity and a NestJS provider for the repository.</p><p><strong>Article Data Access Library:</strong></p><pre>yarn nx generate @nx/nest:lib data-access-article</pre><p><strong>Article Entity:</strong></p><pre>import { Column, Entity, PrimaryGeneratedColumn } from &#39;typeorm&#39;;<br><br>@Entity()<br>export class Article {<br>  @PrimaryGeneratedColumn()<br>  id!: number;<br>  @Column()<br>  title!: string;<br>  @Column()<br>  content!: string;<br>  // Storing the author as string for simplicity<br>  @Column()<br>  author!: string;<br>}</pre><p><strong>Article Repository Provider:</strong></p><pre>import { Injectable } from &quot;@nestjs/common&quot;;<br>import { InjectRepository } from &quot;@nestjs/typeorm&quot;;<br>import { Repository } from &quot;typeorm&quot;;<br>import { Article } from &quot;./article.enity&quot;;<br><br>@Injectable()<br>export class ArticleRepository {<br>  constructor(<br>    @InjectRepository(Article) private articleRepository: Repository&lt;Article&gt;<br>  ) {}<br><br>  findAll(): Promise&lt;Article[]&gt; {<br>    return this.articleRepository.find();<br>  }<br><br>  async findOne(id: string): Promise&lt;Article&gt; {<br>    const article = await this.articleRepository.findOne({where: {id: +id}});<br>    if (!article) {<br>      throw new Error(&#39;Article not found&#39;);<br>    }<br>    return article;<br>  }<br><br>  create(article: Article): Promise&lt;Article&gt; {<br>    const newArticle = this.articleRepository.create(article);<br>    return this.articleRepository.save(newArticle);<br>  }<br><br>  async update(id: string, article: Partial&lt;Article&gt;): Promise&lt;Article&gt; {<br>    const updatedArticle = await this.articleRepository.preload({<br>      id: +id,<br>      ...article<br>    });<br>    if (!updatedArticle) {<br>      throw new Error(&#39;Article not found&#39;);<br>    }<br>    return this.articleRepository.save(updatedArticle);<br>  }<br><br>  async remove(id: string): Promise&lt;void&gt; {<br>    const article = await this.findOne(id);<br>    await this.articleRepository.remove(article);<br>  }<br>}</pre><p><strong>Article Data Access Module:</strong></p><pre>import { Module } from &#39;@nestjs/common&#39;;<br>import { TypeOrmModule } from &#39;@nestjs/typeorm&#39;;<br>import { Article } from &#39;./article.enity&#39;;<br>import { ArticleRepository } from &#39;./article.repository&#39;;<br><br>@Module({<br>  imports: [TypeOrmModule.forFeature([Article])],<br>  providers: [ArticleRepository],<br>  exports: [ArticleRepository, TypeOrmModule],<br>})<br>export class DataAccessArticleModule {}</pre><p><strong>Comment Data Access Library:</strong></p><pre>yarn nx generate @nx/nest:lib data-access-comment</pre><p><strong>Comment Entity:</strong></p><pre>import { Column, Entity, PrimaryGeneratedColumn } from &#39;typeorm&#39;;<br><br>@Entity()<br>export class Comment {<br>  @PrimaryGeneratedColumn()<br>  id!: number;<br>  @Column()<br>  author!: string;<br>  @Column()<br>  content!: string;<br>  // Omitting relationships and using IDs for modularity<br>  @Column()<br>  articleId!: number;<br>}</pre><p><strong>Comment Repository Provider:</strong></p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { InjectRepository } from &#39;@nestjs/typeorm&#39;;<br>import { Comment } from &#39;./comment.entity&#39;;<br>import { Repository } from &#39;typeorm&#39;;<br><br>@Injectable()<br>export class CommentRepository {<br>  constructor(<br>    @InjectRepository(Comment) private commentRepository: Repository&lt;Comment&gt;<br>  ) {}<br><br>  findAll(): Promise&lt;Comment[]&gt; {<br>    return this.commentRepository.find();<br>  }<br><br>  async findOne(id: string): Promise&lt;Comment&gt; {<br>    const comment = await this.commentRepository.findOne({<br>      where: { id: +id },<br>    });<br>    if (!comment) {<br>      throw new Error(&#39;Comment not found&#39;);<br>    }<br>    return comment;<br>  }<br><br>  create(comment: Comment): Promise&lt;Comment&gt; {<br>    const newComment = this.commentRepository.create(comment);<br>    return this.commentRepository.save(newComment);<br>  }<br><br>  async update(id: string, comment: Partial&lt;Comment&gt;): Promise&lt;Comment&gt; {<br>    const updatedComment = await this.commentRepository.preload({<br>      id: +id,<br>      ...comment,<br>    });<br>    if (!updatedComment) {<br>      throw new Error(&#39;Comment not found&#39;);<br>    }<br>    return this.commentRepository.save(updatedComment);<br>  }<br><br>  async remove(id: string): Promise&lt;void&gt; {<br>    const comment = await this.findOne(id);<br>    await this.commentRepository.remove(comment);<br>  }<br>}</pre><p><strong>Comment Data Access Module:</strong></p><pre>import { Module } from &#39;@nestjs/common&#39;;<br>import { TypeOrmModule } from &#39;@nestjs/typeorm&#39;;<br>import { Comment } from &#39;./comment.entity&#39;;<br>import { CommentRepository } from &#39;./comment.repository&#39;;<br><br>@Module({<br>  imports: [TypeOrmModule.forFeature([Comment])],<br>  providers: [CommentRepository],<br>  exports: [CommentRepository, TypeOrmModule],<br>})<br>export class DataAccessCommentModule {}</pre><p><strong>Category Data Access Library:</strong></p><pre>yarn nx generate @nx/nest:lib data-access-category</pre><p><strong>Category Entity:</strong></p><pre>import { Column, Entity, PrimaryGeneratedColumn } from &#39;typeorm&#39;;<br><br>@Entity()<br>export class Category {<br>  @PrimaryGeneratedColumn()<br>  id!: number;<br>  @Column()<br>  name!: string;<br>  @Column()<br>  description!: string;<br>}</pre><p><strong>Category Repository Provider:</strong></p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { InjectRepository } from &#39;@nestjs/typeorm&#39;;<br>import { Category } from &#39;./category.entity&#39;;<br>import { Repository } from &#39;typeorm&#39;;<br><br>@Injectable()<br>export class CategoryRepository {<br>  constructor(<br>    @InjectRepository(Category) private categoryRepository: Repository&lt;Category&gt;<br>  ) {}<br><br>  findAll(): Promise&lt;Category[]&gt; {<br>    return this.categoryRepository.find();<br>  }<br><br>  async findOne(id: string): Promise&lt;Category&gt; {<br>    const Category = await this.categoryRepository.findOne({<br>      where: { id: +id },<br>    });<br>    if (!Category) {<br>      throw new Error(&#39;Category not found&#39;);<br>    }<br>    return Category;<br>  }<br><br>  create(Category: Category): Promise&lt;Category&gt; {<br>    const newCategory = this.categoryRepository.create(Category);<br>    return this.categoryRepository.save(newCategory);<br>  }<br><br>  async update(id: string, Category: Partial&lt;Category&gt;): Promise&lt;Category&gt; {<br>    const updatedCategory = await this.categoryRepository.preload({<br>      id: +id,<br>      ...Category,<br>    });<br>    if (!updatedCategory) {<br>      throw new Error(&#39;Category not found&#39;);<br>    }<br>    return this.categoryRepository.save(updatedCategory);<br>  }<br><br>  async remove(id: string): Promise&lt;void&gt; {<br>    const Category = await this.findOne(id);<br>    await this.categoryRepository.remove(Category);<br>  }<br>}</pre><p><strong>Category Data Access Module:</strong></p><pre>import { Module } from &#39;@nestjs/common&#39;;<br>import { TypeOrmModule } from &#39;@nestjs/typeorm&#39;;<br>import { Category } from &#39;./category.entity&#39;;<br>import { CategoryRepository } from &#39;./category.repository&#39;;<br><br>@Module({<br>  imports: [TypeOrmModule.forFeature([Category])],<br>  providers: [CategoryRepository],<br>  exports: [CategoryRepository, TypeOrmModule],<br>})<br>export class DataAccessCategoryModule {}</pre><p>For the many-to-many relationship between Article and Category, we create a data access library as well:</p><p><strong>ArticleCategory Data Access Library:</strong></p><pre>yarn nx generate @nx/nest:lib data-access-article-category</pre><p><strong>ArticleCategory Entity:</strong></p><pre>import { Entity, PrimaryColumn } from &#39;typeorm&#39;;<br><br>@Entity()<br>export class ArticleCategory {<br>  @PrimaryColumn()<br>  articleId!: number;<br><br>  @PrimaryColumn()<br>  categoryId!: number;<br>}</pre><p><strong>ArticleCategory Repository Provider:</strong></p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { InjectRepository } from &#39;@nestjs/typeorm&#39;;<br>import { ArticleCategory } from &#39;./article-category.entity&#39;;<br>import { Repository } from &#39;typeorm&#39;;<br><br>@Injectable()<br>export class ArticleCategoryRepository {<br>  constructor(<br>    @InjectRepository(ArticleCategory)<br>    private articleCategoryRepository: Repository&lt;ArticleCategory&gt;<br>  ) {}<br><br>  findAll(): Promise&lt;ArticleCategory[]&gt; {<br>    return this.articleCategoryRepository.find();<br>  }<br><br>  create(article: ArticleCategory): Promise&lt;ArticleCategory&gt; {<br>    const newArticle = this.articleCategoryRepository.create(article);<br>    return this.articleCategoryRepository.save(newArticle);<br>  }<br><br>  async remove(articleId?: string, categoryId?: string): Promise&lt;void&gt; {<br>    let options = {};<br>    articleId ? (options = { ...options, articleId: +articleId }) : options;<br>    categoryId ? (options = { ...options, categoryId: +categoryId }) : options;<br>    const articleCategory = await this.articleCategoryRepository.findOne({<br>      where: options,<br>    });<br>    if (!articleCategory) {<br>      throw new Error(&#39;ArticleCategory not found&#39;);<br>    }<br>    await this.articleCategoryRepository.remove(articleCategory);<br>  }<br>}</pre><p><strong>Article Data Access Module:</strong></p><pre>import { Module } from &#39;@nestjs/common&#39;;<br>import { TypeOrmModule } from &#39;@nestjs/typeorm&#39;;<br>import { ArticleCategory } from &#39;./article-category.entity&#39;;<br>import { ArticleCategoryRepository } from &#39;./article-category.repository&#39;;<br><br>@Module({<br>  imports: [TypeOrmModule.forFeature([ArticleCategory])],<br>  providers: [ArticleCategoryRepository],<br>  exports: [ArticleCategoryRepository, TypeOrmModule],<br>})<br>export class DataAccessArticleCategoryModule {}</pre><h4>Application Layer: Managing Relationships</h4><p>The application layer, built on top of these data access libraries, is where the relationships between entities are actively managed. This design choice allows for a clear separation of concerns, where the data access layer remains agnostic of the business logic and inter-entity relationships, enhancing modularity and reusability.</p><ul><li><strong>Business Logic Implementation: </strong>Services within the application layer are responsible for implementing the business logic of the application. These services interact with the repositories provided by the data access libraries to perform CRUD operations and more complex business operations.</li><li><strong>Handling Entity Relationships:</strong> By managing entity relationships at the application layer, we maintain the independence of our data access libraries. Services can use multiple repositories in conjunction to manage related data, enforcing business rules without directly linking entities at the database level. This flexibility is crucial for scenarios where entities might be used in isolation or in different contexts across the application.</li></ul><p>Create a library for the business logic, injecting data access libraries’ providers to manage operations and relationships at this layer.</p><pre>yarn nx generate @nx/nest:lib business-logic-blog</pre><p>We import all the previously created data access libraries into the Blog business logic module.</p><p><strong>Blog Business Module:</strong></p><pre>import { DataAccessArticleModule } from &#39;@my-blog/data-access-article&#39;;<br>import { DataAccessArticleCategoryModule } from &#39;@my-blog/data-access-article-category&#39;;<br>import { DataAccessCategoryModule } from &#39;@my-blog/data-access-category&#39;;<br>import { DataAccessCommentModule } from &#39;@my-blog/data-access-comment&#39;;<br>import { Module } from &#39;@nestjs/common&#39;;<br>import { BlogService } from &#39;./blog.service&#39;;<br><br>@Module({<br>  imports: [<br>    DataAccessArticleModule,<br>    DataAccessCommentModule,<br>    DataAccessCategoryModule,<br>    DataAccessArticleCategoryModule,<br>  ],<br>  providers: [BlogService],<br>  exports: [BlogService],<br>})<br>export class BusinessLogicBlogModule {}</pre><p>We create a blog interface for a consistent data structure.</p><p><strong>Blog Interface:</strong></p><pre>export interface IBlog {<br>  id: number;<br>  title: string;<br>  content: string;<br>  author: string;<br>  comments: {<br>    id: number;<br>    author: string;<br>    content: string;<br>  }[];<br>  categories: {<br>    id: number;<br>    name: string;<br>    description: string;<br>  }[];<br>}</pre><p>We then encapsulate all business logic into a service.</p><p><strong>Blog Service:</strong></p><pre>import { Injectable } from &#39;@nestjs/common&#39;;<br>import { ArticleRepository } from &#39;@my-blog/data-access-article&#39;;<br>import { CategoryRepository } from &#39;@my-blog/data-access-category&#39;;<br>import { CommentRepository } from &#39;@my-blog/data-access-comment&#39;;<br>import { ArticleCategoryRepository } from &#39;@my-blog/data-access-article-category&#39;;<br>import { IBlog } from &#39;./blog.interface&#39;;<br><br>@Injectable()<br>export class BlogService {<br>  constructor(<br>    private articleRepository: ArticleRepository,<br>    private categoryRepository: CategoryRepository,<br>    private commentRepository: CommentRepository,<br>    private articleCategoryRepository: ArticleCategoryRepository<br>  ) {}<br><br>  async findAllPosts(): Promise&lt;IBlog[]&gt; {<br>    const articles = await this.articleRepository.findAll();<br>    return articles.map((article) =&gt; {<br>      return {<br>        id: article.id,<br>        title: article.title,<br>        content: article.content,<br>        author: article.author,<br>      };<br>    });<br>  }<br><br>  async findPostById(id: string): Promise&lt;IBlog&gt; {<br>    const article = await this.articleRepository.findOne(id);<br>    const comments = await this.commentRepository.findAll();<br>    const categories = await this.categoryRepository.findAll();<br>    const articleCategories = await this.articleCategoryRepository.findAll();<br><br>    return {<br>      id: article.id,<br>      title: article.title,<br>      content: article.content,<br>      author: article.author,<br>      comments: comments<br>        .filter((comment) =&gt; comment.articleId === article.id)<br>        ?.map((comment) =&gt; {<br>          return {<br>            id: comment.id,<br>            author: comment.author,<br>            content: comment.content,<br>          };<br>        }),<br>      categories: articleCategories<br>        .filter((articleCategory) =&gt; articleCategory.articleId === article.id)<br>        ?.map((articleCategory) =&gt; {<br>          return categories<br>            .filter((category) =&gt; category.id === articleCategory.categoryId)<br>            .map((category) =&gt; {<br>              return {<br>                id: category.id,<br>                name: category.name,<br>                description: category.description,<br>              };<br>            });<br>        })<br>        .flat(),<br>    };<br>  }<br><br>  // ... other methods<br>}</pre><h4>Presentation Layer: Exposing Functionality</h4><p>The presentation layer, typically consisting of controllers in a NestJS application, exposes the application’s functionality to the outside world, be it through RESTful APIs, GraphQL endpoints, or other means. Controllers communicate with the services in the application layer, abstracting the complexities of business logic and data management from the client.</p><p>Generate a library for the presentation layer to expose API endpoints, utilizing services from the business layer.</p><pre>yarn nx generate @nx/nest:lib presentation-blog</pre><p><strong>Blog Presentation Module:</strong></p><pre>import { Module } from &#39;@nestjs/common&#39;;<br>import { BlogController } from &#39;./blog.controller&#39;;<br>import { BusinessLogicBlogModule } from &#39;@my-blog/business-logic-blog&#39;;<br><br>@Module({<br>  imports: [BusinessLogicBlogModule],<br>  controllers: [BlogController],<br>  providers: [],<br>  exports: [],<br>})<br>export class PresentationBlogModule {}</pre><p><strong>Blog Controller:</strong></p><pre>import { BlogService, IBlog } from &#39;@my-blog/business-logic-blog&#39;;<br>import { Controller, Get, Param } from &#39;@nestjs/common&#39;;<br><br>@Controller(&#39;blog&#39;)<br>export class BlogController {<br>  constructor(private blogService: BlogService) {}<br><br>  @Get()<br>  async findAllPosts(): Promise&lt;IBlog[]&gt; {<br>    return this.blogService.findAllPosts();<br>  }<br><br>  @Get(&#39;:id&#39;)<br>  async findPostById(@Param(&#39;id&#39;) id: string): Promise&lt;IBlog&gt; {<br>    return this.blogService.findPostById(id);<br>  }<br><br>  // ... other methods<br>}</pre><h4>Achieving Maximum Modularity</h4><p>This architecture — separating data access into individual libraries, managing relationships at the application layer, and abstracting business logic through services — ensures maximum modularity. It provides several advantages:</p><ul><li><strong>Flexibility: </strong>Entities can be modified, extended, or reused without affecting other parts of the application,</li><li><strong>Maintainability:</strong> Changes in business logic or data relationships can be managed centrally in the application layer, without needing to overhaul the data access layer.</li><li><strong>Scalability:</strong> New features or entities can be added as separate libraries, making it easier to scale the application over time.</li></ul><p>By meticulously aligning library types with the architectural layers of a three-tiered system and adopting a modular approach to entity relationships, we lay a foundation for building complex, scalable, and maintainable backend applications. This strategy not only streamlines development processes but also enhances the adaptability of the application to meet evolving business needs.</p><h3>Best Practices for Maximum Modularity</h3><ul><li><strong>Decouple Entities:</strong> Avoid direct relationships in entities to ensure libraries can be used independently.</li><li><strong>Centralise Business Logic: </strong>Manage entity relationships within services in the business layer for flexibility and maintainability.</li><li><strong>Use NX for Dependency Management:</strong> Leverage NX to enforce boundaries between libraries, preventing circular dependencies.</li></ul><h3>Conclusion</h3><p>Adopting a modular approach with NX, NestJS, and TypeORM not only streamlines the development process but also significantly enhances the scalability and maintainability of backend applications. By carefully structuring data access, business logic, and presentation layers into separate libraries and managing entity relationships at the application layer, developers can achieve a high degree of modularity. This strategy not only facilitates easier updates and scalability but also ensures that components can be reused and repurposed across the application ecosystem, embodying the principles of efficient software architecture.</p><h3>Disclaimer</h3><p>Please note that the code snippets and architectural patterns presented in this article serve primarily as conceptual examples to illustrate the principles of implementing a modular, three-tier architecture using NX, NestJS, and TypeORM. These examples may not adhere to best practices, might lack optimization for performance, and could require adjustments to be fully functional. Furthermore, comprehensive testing has not been covered, which is a critical aspect of reliable software development.</p><p>As someone who is journeying through the vast and intricate world of web development, I am not yet a seasoned web developer. My passion lies in learning and exploring the myriad possibilities that modern development frameworks and architectures offer. Sharing my experiences, even as I navigate through my own learning process, is a way for me to contribute to the community and perhaps inspire others on a similar path. I welcome constructive feedback, insights, and suggestions from more experienced developers, as I believe that we grow best through collaborative learning and exchange of ideas.</p><p>Thank you for engaging with my exploration, and I hope it serves as a stepping stone for your own experiments and learning in the world of web development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebf4d5ffdd0d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Data Warehousing: A pragmatic view of a data architect — Production and Maintenance]]></title>
            <link>https://medium.com/@johanvrolix/data-warehousing-a-pragmatic-view-of-a-data-architect-production-and-maintenance-d1bbfaa60d1?source=rss-347bd5be549e------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1bbfaa60d1</guid>
            <category><![CDATA[data-modeling]]></category>
            <category><![CDATA[data-warehouse]]></category>
            <category><![CDATA[data-analytics]]></category>
            <category><![CDATA[data-architecture]]></category>
            <category><![CDATA[data-warehouse-automation]]></category>
            <dc:creator><![CDATA[Johan Vrolix]]></dc:creator>
            <pubDate>Fri, 11 Aug 2023 06:57:58 GMT</pubDate>
            <atom:updated>2023-08-11T06:57:58.308Z</atom:updated>
            <content:encoded><![CDATA[<h3>Data Warehousing: A pragmatic view of a data architect — Production and Maintenance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gBv4aCXaX0-fdMy2" /><figcaption>Photo by <a href="https://unsplash.com/@glenncarstenspeters?utm_source=medium&amp;utm_medium=referral">Glenn Carstens-Peters</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Production and Maintenance in Agile Data Warehousing: Empowering Continuous Data-Driven Growth</strong></p><p>In the context of Agile methodologies, the Production and Maintenance phases take on a dynamic and iterative nature, aligning seamlessly with the principles of adaptability, collaboration, and continuous improvement. These phases are instrumental in harnessing the power of data for agile decision-making while ensuring the data warehouse’s resilience, performance, and alignment with ever-evolving business requirements.</p><p><strong>1. Production Phase: Agile Data Activation</strong></p><ul><li><strong>Enabling Agile Decision-Making:</strong> In the Production phase, the data warehouse comes to life as a dynamic hub for agile decision-making. It serves as the nexus of structured and integrated data from diverse sources. The Agile approach emphasizes delivering incremental value, making the data warehouse a valuable asset for business users to access insights and drive decisions based on the latest available information.</li><li><strong>Continuous Data Evolution:</strong> Agile methodologies highlight the importance of flexibility and responsiveness. In the Production phase, continuous data updates are facilitated through iterative ETL/ELT processes. This iterative nature ensures that the data warehouse remains up to date with the most recent transactions, supporting real-time insights and responsive decision-making.</li><li><strong>Quality Through Collaboration:</strong> Collaborative efforts in Agile extend to the Production phase. Data quality and governance remain vital as Agile teams collaborate to ensure data consistency, integrity, and adherence to standards. Agile principles of transparency and collaboration promote cross-functional communication, contributing to data quality assurance.</li><li><strong>Performance Optimization as a Collective Effort:</strong> Performance and scalability are iterative pursuits in Agile. The iterative nature of Agile methodologies allows teams to continually monitor, optimize queries, and fine-tune data processing to ensure optimal performance. Collaboration between development and operations teams ensures that performance enhancements are part of the continuous improvement cycle.</li><li><strong>User-Centric Support and Training:</strong> Agile’s focus on end-user collaboration is mirrored in user support efforts. Dedicated support teams work closely with business users, addressing queries, resolving issues, and ensuring that users can extract maximum value from the data warehouse. Regular training sessions empower users to navigate the data warehouse efficiently and independently.</li></ul><p><strong>2. Maintenance Phase: Iterative Excellence</strong></p><ul><li><strong>Continuous Monitoring and Learning:</strong> The Agile approach extends to the Maintenance phase, emphasizing continuous monitoring and learning. Agile teams use monitoring tools and feedback loops to detect anomalies and areas for improvement. This proactive approach aligns with Agile’s commitment to addressing issues early, minimizing disruptions, and fostering a culture of learning.</li><li><strong>Agile Resolution of Issues:</strong> The Maintenance phase embodies Agile principles in issue resolution. Agile teams collaborate to swiftly address and resolve bugs or challenges that may arise. This iterative problem-solving approach ensures that the data warehouse remains robust and responsive to changing requirements.</li><li><strong>Evolving to Business Needs:</strong> Agile embraces the inevitability of changing business needs. In the Maintenance phase, changes and enhancements are treated as opportunities for evolution. Agile’s adaptive planning accommodates modifications to data models, ETL processes, and reporting functionalities while ensuring that each change is seamlessly integrated into the existing framework.</li><li><strong>Agile Performance Optimization:</strong> Agile’s iterative mindset extends to performance optimization. Agile teams continually seek ways to optimize the data warehouse’s performance. This proactive approach to performance aligns with Agile’s philosophy of delivering value at a sustainable pace.</li><li><strong>Continual Innovation and Learning</strong>: The Agile spirit of continual improvement drives innovation in the Maintenance phase. Regular retrospectives encourage teams to reflect on their practices, identify areas for improvement, and introduce innovative solutions to enhance the data warehouse’s effectiveness.</li></ul><p><strong>Conclusion: Agile Data Empowerment</strong></p><p>In Agile Data Warehousing, the Production and Maintenance phases epitomise the agile principles of adaptability, collaboration, and continuous improvement. The Production phase empowers agile decision-making through real-time data insights, while the Maintenance phase ensures that the data warehouse evolves harmoniously with changing business dynamics. By embracing Agile principles throughout these phases, organizations can unlock the full potential of their data, fostering agility, innovation, and sustained growth.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1bbfaa60d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>