<?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 Garrett James Cassar on Medium]]></title>
        <description><![CDATA[Stories by Garrett James Cassar on Medium]]></description>
        <link>https://medium.com/@garrett-james-cassar?source=rss-925e3db50a98------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*V5Rf8tgKtVi6iBt08CQCqQ.jpeg</url>
            <title>Stories by Garrett James Cassar on Medium</title>
            <link>https://medium.com/@garrett-james-cassar?source=rss-925e3db50a98------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 16:10:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@garrett-james-cassar/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[Enterprise AI Strategy: The Federated Champion Model]]></title>
            <link>https://levelup.gitconnected.com/enterprise-ai-strategy-the-federated-champion-model-5f41f03932e0?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f41f03932e0</guid>
            <category><![CDATA[governance]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Mon, 16 Feb 2026 19:26:56 GMT</pubDate>
            <atom:updated>2026-02-16T19:26:56.844Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Scale adoption and eliminate shadow AI through decentralized business champions.</em></p><p>Enterprise AI breaks at the chasm between infrastructure and operations.</p><p>80% of AI projects fail — twice the rate of traditional IT. Deloitte identifies the root cause as technical and business misalignment. IT builds; the business ignores.</p><p>Bridging this gap requires an architectural shift: centralize guardrails, decentralize execution. Forrester data shows baseline enterprise AI deployment yields a 132% ROI. Embedding a decentralized “AI Champions” network to translate that technology locally drives that ROI to <strong>353%</strong>.</p><p>Meaning People free themselves from drudgery and focus on what they love and are good at — the hard bits.</p><p>The solution is a federated AI championship, with a central governance to do the “boring parts”.</p><h3>The Core: Central AI Governance</h3><p>Transform your governance layer from a boring compliance bottleneck into an exciting infrastructure accelerator. This is not a gatekeeper; it is an aggressive enablement engine. To empower the edge, this central hub must provide:</p><ul><li><strong>Data Safety:</strong> Strict enforcement of data lineage, encryption, and privacy protocols.</li><li><strong>Resource Allocation:</strong> Aggressive, continuous review of tool usage and API costs to ensure ROI.</li><li><strong>Provisioning:</strong> Vetting and deploying sanctioned foundational models and tools.</li><li><strong>Demos and sharing: </strong>Generalized demos of new security sanctioned tooling such as Openclaw, Claude Browser, LangGraph, CrewAI</li></ul><blockquote><em>A great way to do this is to create a ticketing system that is accessable to all champions. Where they can raise new tooling and models which they could make cases for.</em></blockquote><p><em>Follow me for an upcoming article on </em><strong><em>AI Governance Committees</em></strong></p><h3>The Edge: Embedded AI Champions</h3><p>Push optimization to the edges. Federate AI execution to dedicated “Champions” embedded within specific business functions — Finance, Operations, Marketing, Coding, Product Ownering.</p><p>Do not hire for this. Source volunteers. Internal surveys consistently show that over 75% of active enterprise AI users already self-identify as potential champions. Moreover volunteers live and understand the realities of their day-to-day. Deploying this internal network unlocks four strategic advantages:</p><p><strong>1. Immediate Use-Case Fit</strong> Central IT builds solutions looking for problems. Champions live the problems. They guarantee immediate, high-impact use-case fit because they own the functional domain.</p><p><strong>2. Precision Upskilling</strong> Stop blanket enterprise training. Train the targeted champion audience on specific deployed tools. They become the local translation layer, accelerating departmental AI adoption.</p><p><strong>3. The 20% Innovation Mandate</strong> Give champions the freedom to spend 20% of their time exploring AI applications within their function. Unstructured sandbox hours yield asymmetric returns and surface ground-level efficiencies.</p><p><strong>4. Cultured Velocity</strong> Scale behavior through visibility. Elevate champions via dedicated internal AI meetups and company-wide newsletters. Make them the recognized vanguard of organizational transformation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/0*z4vHmKRxuSh0twFl.png" /><figcaption>AI Initiatives</figcaption></figure><h3>Conclusion</h3><p>Centralize the guardrails. Decentralize the execution. Give your best operators the tools, the time, and the authority to optimize their own domains.</p><p>My LinkedIn: <a href="https://www.linkedin.com/in/garrett-cassar-55648b67/">https://www.linkedin.com/in/garrett-cassar-55648b67/</a></p><p>Follow me for similar upcoming articles.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f41f03932e0" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/enterprise-ai-strategy-the-federated-champion-model-5f41f03932e0">Enterprise AI Strategy: The Federated Champion Model</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibes to Metrics: Measure What Matters in AI]]></title>
            <link>https://levelup.gitconnected.com/vibes-to-metrics-measure-what-matters-in-ai-a660c1895d75?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/a660c1895d75</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 15:27:29 GMT</pubDate>
            <atom:updated>2026-01-28T15:27:29.518Z</atom:updated>
            <content:encoded><![CDATA[<p>In 2026, experimentation with AI is not your goal. The goal is to urgently secure <strong>leverage</strong> and realise productivity growth.</p><p>Wise sages will warn that at the cost of speed you’ll be sacrificing quality. Generating a mountain of AI slop rather than a useful sliver of well thought through and well-designed solutions. Hold on to these people. Promote them. But they’re wrong.</p><p>AI tooling has moved beyond copy-pasting into LLMs. We are in a world where carefully directed AI is integral to production <strong>and</strong> quality assurance. AI provides velocity; people direct it.</p><h4><strong>Why record metrics?</strong></h4><p>AI can actually lead to productivity loss.</p><p><a href="https://newsroom.workday.com/2026-01-14-New-Workday-Research-Companies-Are-Leaving-AI-Gains-on-the-Table">The “Rework” Trap by Workday</a> — 40% of time saved is lost due to rework.</p><p><a href="https://hbr.org/2025/09/ai-generated-workslop-is-destroying-productivity">Harvard Business Review reports</a> — AI Generated Slop incidents are numerous and take on average 2 hours to rectify.</p><p>Failures aren’t a reason to give up. They are a reason to track what works and iterate fearlessly.</p><h3>Measuring Speed</h3><h4>AI Velocity Gain</h4><p><strong>Time without AI — Time with AI = AI Velocity Gain</strong></p><p>The trick is consistent tracking. Recording this manually is a nightmare that leads to messy data and complaining employees.</p><p>Although potentially acceptable for ring fences pilots, recording this data manually would be a nightmare.</p><p>Never compromise data consistency.</p><p>Integrate metrics into the workflow. Seed a simple agent with baseline times for standard actions, compare them to generation times for accepted solutions, and output the delta.</p><p>More on that in my article on self-reporting AI workflows.</p><h4>Rework Tax</h4><p>Speed is irrelevant if the user rejects the output. It won’t all be positive</p><p>The Number of times (n) a human needed to review the work before accepting the final draft.</p><ul><li>Pass@n = (n * rework time) = Rework tax</li></ul><p>Measured simply in an AI workflow, by counting the number of iterations before a human accepted the work produced by the AI.</p><h3>Measuring Quality</h3><p>Speed is irrelevant if the product suffers.</p><p><strong>Metrics</strong>: Sentiment, AI Confidence Rating, Adherence to central standards, Other use case specific tools.</p><h4>Sentiment</h4><p>Employees know best what makes them faster. While informal and unstructured, qualitative feedback belongs in 1:1s, not dashboards. Track general happiness regularly and encourage people to verbalise their pain points.</p><h4>Deterministic Automated Tools</h4><p>Quality must be measurable. This is the domain of <strong>AI Champions</strong>.</p><p>What’s an AI Champion?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*fgkY3_bh4ue7m1seTd-FGg.png" /><figcaption>Champions are SMEs that promote AI</figcaption></figure><p>AI Champions are subject matter experts that accelerate their AI use case, share success and help iterate.</p><p>A developer can’t help automate “Legal”. They don’t know what “Legal” do.</p><p><strong>Tooling:</strong> Champions must identify automated quality checks. For software, this is SonarQube (cyclomatic complexity) or ArchUnit tests. Champions must find the equivalent for Legal, HR, and Finance. [See Article on software guardrails for Agentic AI]***</p><h4>Sentinel AI Agents</h4><p>Standards are fantastic, they simplify delivery, ensure high quality and solve common problems.</p><p>The problem is nobody follows them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*bkcW_YFhaXzaqXM4lZV5xQ.png" /><figcaption>Sentinel Pattern</figcaption></figure><p><strong>AI Sentinels</strong> compare output against grounding standards that describe perfect structure. They check operator output, provide feedback, and force iteration.</p><p>That can check the output of the operator, provide feedback and force an iteration.</p><p>This is a strong pattern for particularly long contexts and difficult pieces of work. Often a single Agent works out fine.</p><p><strong>What’s an AI Sentinel?</strong></p><p><strong>Upcoming</strong>: [Article on Self Managing Agentic AI Systems]</p><p><strong>TLDR</strong>;</p><p><strong>Helper Agents</strong> are domain competent, creative problem solvers.</p><p><strong>Sentinel Agents</strong> are the sort of agents you wouldn’t go to the pub with. Boring, pedantic and domain-agnostic. They ensure work follows standards to a tee.</p><h3>Metadata</h3><p>Raw numbers mean nothing without context.</p><p>To <em>really</em> gain actionable insights, you must capture <strong>Grounding principles</strong>, the <strong>RAG</strong>, the <strong>Prompt</strong>, the <strong>Model, </strong>and<strong> </strong>the use case.</p><p>That’s a lot to report on.</p><p>Ring-fence this implementation within the Agent boundaries and version it for tracking.</p><h4>Example output</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/965/1*wP6diu76JQTIsvlX_lO0cw.png" /></figure><h4><strong>Insight Example</strong></h4><p><strong>High Velocity:</strong> Case Law Search produced an 800% time efficiency when using the JuristSearch Agent — v3. This is a 4x increase from JuristSearch Agent — v2.</p><p><strong>Failure:</strong> LexReview Agent — v6 consistently produced poor output. <br><strong>Actions: </strong>Promote JuristSearch Agent — v3 to officially represent all jurisdiction search use cases.</p><h4>Optimize</h4><p>Use your insights to optimize with these simple rules:</p><ul><li>If an agent results in a negative productivity gain or Pass@n &gt; 3. Kill or iterate.</li><li>If an agent results in a productivity gain of more than 200%. Promote, share success.</li></ul><h3>Conclusion: The New Bottom Line</h3><p>The difference between a toy and a tool is measurement.</p><p>Ai champions need to name your best-performing agent for a particular task and iterate. Otherwise you risk burning your budget with zero return and embedding AI disillusionment within your company.</p><p>CAIOs need to embed this mentality and seed it across the organisation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a660c1895d75" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/vibes-to-metrics-measure-what-matters-in-ai-a660c1895d75">Vibes to Metrics: Measure What Matters in AI</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Escape Velocity Playbook: Building a Company That Thinks]]></title>
            <link>https://levelup.gitconnected.com/ai-escape-velocity-playbook-building-a-company-that-thinks-95bd5fa43edc?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/95bd5fa43edc</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Wed, 21 Jan 2026 03:14:49 GMT</pubDate>
            <atom:updated>2026-01-21T03:14:49.304Z</atom:updated>
            <content:encoded><![CDATA[<p>Companies will soon be divided into two groups: those that embraced AI and turned their products into spaceships, and those that failed.</p><p>This isn’t hyperbole. AI is not just raw speed; it is recursive improvement. Tight feedback loops. Exponential Time to Value for fractional cash burn.</p><p>This blog series details how to integrate AI into an organization to achieve velocity, focusing largely on accelerating the Software Development Life Cycle (SDLC).</p><h3>AI Monoliths are your enemy</h3><p>The advantages of AI are universal.</p><p>But treating “AI” as a monolithic initiative is a mistake. It creates confusion around ownership, muddies ROI calculation, and results in one-offs and generic tools that solve nothing.</p><p>Subdividing initiatives creates <strong>focus</strong>. It forms pods with clear outcomes, clear owners, evaluation methods and self defined goals within that pod. It also creates a natural subdivision for agent profiles that are trained on particular data sources, prompted with particular prompts and have access to particular tools.</p><p>You wouldn’t want your Legal Agent writing code would you?</p><h3>The 3 Pillars of AI Integration</h3><p>Categorize AI integration into three distinct buckets based on value add, human interaction, and evaluation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/896/1*jBomFTXw79bmKnaV4hzXug.png" /><figcaption>AI Integration subdivison</figcaption></figure><h4>1. Internal Velocity (Employee → AI Workflow)</h4><ul><li><strong>Examples:</strong> SDLC acceleration, legal contract review.</li><li><strong>Ownership:</strong> Department Heads (e.g., Head of Software Engineering).</li><li><strong>Evaluation: </strong>% of time saved on day to day. Quality of outcome. Cost to value.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/405/1*YJvUJ1On4Pyx_9EByZxD1w.png" /><figcaption>Internal Velocity</figcaption></figure><h4>2. Operational (User → Back-end)</h4><ul><li><strong>Examples:</strong> Product Support Agents.</li><li><strong>Ownership:</strong> Customer Success or Operations leads.</li><li><strong>Evaluation: </strong>% of successful outcomes. Customer Satisfaction. Cost to Serve.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/634/1*o11QcjST1C6nGBF82T8whQ.png" /></figure><h4>3. Product (User → Product)</h4><ul><li><strong>Examples:</strong> Generative design tools, AI-driven analytics.</li><li><strong>Ownership:</strong> Product Managers.</li><li><strong>Evaluation: </strong>Success Score, user feedback ratings</li></ul><h3>The Series Focus: SDLC</h3><p>While these evaluation frameworks apply to every vertical — Legal, HR, Sales — the highest leverage point for immediate transformation is internal velocity.</p><p>I will focus specifically on the <strong>Software Development Life Cycle (SDLC)</strong>. This is the domain I know best, and it is where organizations have the longest cycles with the largest cash burn.</p><p>In this series I’ll explore how you can run pilots, not get bogged down by complex architectural requirements, measure success and talk about the important of securely saying yes.</p><p>Don’t miss it</p><p><strong>The Series Roadmap:</strong></p><ol><li><strong>Measure What Matters in AI:</strong> From Vibes to Metrics: ROI, Correctness, Quality.</li><li><strong>Scaling AI Adoption: Your AI Library:</strong> Repository of tools, prompts + agent profiles and the AI feedback cycle.</li><li><strong>Governance:</strong> Enabling the latest tools securely.</li><li><strong>Agent Profiles + Principles:</strong> Grounding agents with the right principles.</li><li><strong>Fast feedback in an AI Augmented SDLC:</strong> Tightening feedback loops and reducing time to value.</li><li><strong>Creating a Strong Relay:</strong> Documenting hand-offs between Product, Design, and Engineering.</li><li><strong>Human in the Loop Systems (The Triad):</strong> Pointing the AI cannon in the right direction.</li></ol><p><strong>Please:</strong></p><ol><li>♻️ <strong>Share</strong> this with your engineering lead.</li><li>👏 <strong>Clap</strong> (50x) if you agree that AI Monoliths are dead.</li><li>🔔 <strong>Follow</strong> to catch Part 2 later this week.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=95bd5fa43edc" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/ai-escape-velocity-playbook-building-a-company-that-thinks-95bd5fa43edc">AI Escape Velocity Playbook: Building a Company That Thinks</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Fat Contracts Are Killing Your Architecture — And How To Fix It]]></title>
            <link>https://levelup.gitconnected.com/why-fat-contracts-are-killing-your-architecture-and-how-to-fix-it-1ef544287af8?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ef544287af8</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Sun, 22 Jun 2025 22:27:12 GMT</pubDate>
            <atom:updated>2025-06-22T22:27:12.112Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why Fat Contracts Are Killing Your Architecture — And How To Fix It</h3><p>What does Carlo Ancelloti and Bad architectures have in common?</p><ul><li>They both have fat contracts and love spaghetti.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HXgrhaqp9VX0OJeH" /></figure><p>Systems grow, Systems fragment.</p><p>What starts as a clean, focused codebase can become a jungle of services.</p><p>It’s important to fight this natural decay with intelligent design, foresight and domain driven design.</p><h3>The Problem: Car Rental App</h3><p>The App Needs to know:</p><ul><li>Is the renter an adult?</li><li>Clean driving record?</li><li>Eligible for premium rental rates?</li></ul><pre>Request<br>{<br> &quot;userId&quot;: &quot;1234&quot;,<br> &quot;isAdult&quot;: true,<br> &quot;hasGoodDrivingRecord&quot;: false,<br> &quot;isOverBeneficialRateAge&quot;: true<br>}</pre><pre>Response<br>{<br> &quot;canRent&quot; : true,<br> &quot;beneficialRates&quot; : false,<br>}</pre><p>Looks tidy and logical. But there is a huge flaw here.</p><p>What does it mean to have a good driving record? <br>To qualify for a beneficial rate? <br>What does it even mean to be an adult?</p><p>Are these all consistent everywhere? Potentially Not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7eoIPGSIdFOjGyjw" /><figcaption>Fat Contracts - Dumb Services</figcaption></figure><p>Responsibility is pushed to the caller. And now therefore repeated — everywhere.</p><p>Logic will drift. Rules will change. Someone, somewhere, will get it wrong.</p><p>Will you remember to update all the code that calls the service? Is that even in your control? Do you need to wait for third parties? Will they actually do that?</p><h3>What Slim Contracts Do Differently</h3><p>Instead of passing pre-derived fields, slim contracts look like this</p><pre>Request <br>{<br> &quot;userId&quot;: &quot;1234&quot;<br>}</pre><pre>Response<br>{<br> &quot;canRent&quot; : true,<br> &quot;beneficialRates&quot; : false,<br>}</pre><p>That’s it. The RentalEligibility service:</p><ul><li>Pulls in the user data itself</li><li>Applies its own rules for age, tier, and history</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yz-kaqSHFzLVI63m" /><figcaption>Dumb Contracts — Smart Services</figcaption></figure><p>The calling service doesn’t care how eligibility is calculated. It just gets the answer.</p><h3>Data is logic</h3><p>Designing Systems — Having a strong bounded context — is about knowing what a service <em>shouldn’t </em>be doing as much as knowing what it should be doing.</p><p>You think you’re just passing data. But every piece of data implies logic - assumptions, definitions, and decisions made elsewhere — that belongs in the correct domain.</p><p>Realms of expertise are expressed through what I am and am not expecting you to communicate to me.</p><p>As a lawyer, I wouldn’t expect my client to cite the legal references they may expect his opposite to be violating. That’s my job.</p><h4>Fat Contract:</h4><ul><li>Callers must know your domain rules</li><li>Business logic is spread across the system</li><li>You can’t change definitions without breaking things</li></ul><h4>Slim Contract:</h4><ul><li>One place owns the logic</li><li>Callers stay dumb and stable</li><li>You can evolve your domain safely</li></ul><h3>Whisper Sweet DDD to me</h3><p>Domain Driven Design tells us that when logic escapes its bounded context, your system stops being modular — and starts being entangled.</p><p><strong>“A Bounded Context is not merely a module. It is the <em>guard</em> of the model’s integrity.”</strong></p><p>— <em>Vaughn Vernon</em></p><p>If you let other services redefine your logic, you’re no longer guarding anything. When the logic changes that change is duplicated across many, many systems.</p><ul><li>Each Bounded Context should own its data and rules</li><li>Invariants (like “what makes someone eligible”) should be enforced internally</li><li>Exposing derived fields like isAdult: true is a leak of domain logic</li></ul><h3>Does that mean that I should use microservices?</h3><p>No — read my article.</p><p><a href="https://levelup.gitconnected.com/why-you-should-never-default-to-microservices-c952903fbcb6">Why you should never default to Microservices</a></p><p>Whether a service is housed within separate microservices or within the same deployable monolith the principal remains.</p><blockquote>When dealing with microservices, the issue may be easier to diagnose as you data being deserialized into json and reserialized again on the other side. But the differences stop there. Whether your logic leaks through a network boundary or a module boundary is largely irrelevant.</blockquote><p>You can enforce a strong bounded context without having to split modules into separate microservices.</p><h3>TLDR;</h3><p>Data <em>is</em> logic. Contracts are the exchange of data.</p><p>Services should be modular — smart on the inside and dumb on the outside.</p><p>Fat contracts <strong><em>might</em></strong> signal a reversal — That your services are entangled — dumb on the inside and dependent on the outside. Brittle, hard to evolve, over complicated and nasty.</p><h3><strong>Please:</strong></h3><p>👉 Press and hold the 👏 button<br> 👉 <a href="https://medium.com/@garrett-james-cassar">Follow me on Medium</a><br> 👉 <a href="https://www.linkedin.com/in/gary-cassar-55648b67/">Connect on LinkedIn</a></p><h3>Read More:</h3><ul><li><a href="https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8">The one thing you need to do to 10x Development productivity — without AI</a></li><li><a href="https://levelup.gitconnected.com/why-story-points-dont-make-sense-117fabdac8ca">Why Story Points don’t make sense</a></li><li><a href="https://levelup.gitconnected.com/the-planning-board-ba4d469d3b2b">The Planning board</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ef544287af8" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/why-fat-contracts-are-killing-your-architecture-and-how-to-fix-it-1ef544287af8">Why Fat Contracts Are Killing Your Architecture — And How To Fix It</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Planning board]]></title>
            <link>https://levelup.gitconnected.com/the-planning-board-ba4d469d3b2b?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba4d469d3b2b</guid>
            <category><![CDATA[business]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Fri, 20 Jun 2025 02:07:38 GMT</pubDate>
            <atom:updated>2025-06-20T02:07:38.951Z</atom:updated>
            <content:encoded><![CDATA[<p>Software has two feral and naturally antagonistic tribes — Product people (or PPs) and Software people.</p><p>Product people express what they want the product to do. Software people do it. Simple.</p><p>When nothing gets done — Product people blame Software people. Software people say Product people didn’t express the requirements correctly and order is restored to the world.</p><p>The issue comes in when you actually want to deliver things.</p><p><strong><em>Planning is Hard</em></strong> — And everyone’s responsibility (Sorry Software People).</p><p>The best way to do that is</p><ul><li>Product People present the “What”</li><li>Software People take that “What” and uncover the “How”. <em>Before the work starts.</em></li></ul><p>Product people should set the direction at a 10,000 foot view. Software People Should hover at 10 feet with a flashlight to uncover flaws that non-technical planning can not see.</p><p>Ignoring these details doesn’t make them go away. It just guarantees that they’ll crop up at the worst and most disruptive moment.</p><h3>The Planning board</h3><p>The best way to enforce a process is to make it obvious and easy.</p><p>The easiest way to do that is to have a completely separate board from the development board.</p><blockquote>There is always a dichotomy between including people in processes and not boring them to death with 1000 meetings. A planning board enables you to take “these processes offline” and assign it to someone without having 30 developers on a call to discuss every minute detail of every bloody jira.</blockquote><h3>Stages</h3><p>The goals of the planning board are</p><ol><li>Setting Expectations</li><li>Solving problems as cost effectively (early) as possible.</li></ol><p><a href="https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8">The one thing you need to do to 10x Development productivity — without AI</a></p><p>I’ve found the following steps are most representative of this process</p><blockquote>Business Refinement -&gt;<br>Technical Refinement -&gt;<br>Ready for Estimation -&gt;<br>Ready for Prioritization -&gt;<br>Ready for Development</blockquote><h3>Business refinement</h3><p>The ultimate purpose of the business refinement is to</p><ol><li>Set the scene</li><li>Clearly and definitively express business requirements</li></ol><p>And communicate that clearly in a <strong>User Story.</strong></p><p>My favorite format for that purpose is the following.</p><ol><li>Background — Set the context</li><li>Acceptance Criteria — My favorite format for this BDD</li><li>Mock ups (when required)</li></ol><h4>Background</h4><p>Sales Analysts need to perform complex data manipulation on the “Sales Data” screen.</p><p>In order to do this they would like to get this table of information on the web page and export it to a csv and then re-import it.</p><p>This helps them to modify data on an excel sheet — which they feel very comfortable with — and import that again.</p><h4>Acceptance Criteria</h4><p><strong><em>Given: </em></strong>Sales data <strong><em><br>When: </em></strong>I export the data<strong><em><br>Then: </em></strong>It should be exported into a perfect csv representation of the columns and values<br><strong><em>When: </em></strong>I re-import that data<br><strong><em>Then: </em></strong>It should update all the data in our database</p><p><em>Acceptance criteria should communicate to developers a definition of done as well as give instructions to the QA about how to test.</em></p><p>Read</p><p><a href="https://levelup.gitconnected.com/language-has-taken-us-a-long-way-from-the-caves-into-towns-and-cities-and-modern-civilization-82db61f169d2">6 steps to great Functional Requirements</a></p><h4>Mock ups</h4><p>I like wireframes personally</p><h3>Technical Refinement</h3><p>The ultimate purpose of the Technical refinement is to</p><ol><li>Find edge cases in the Acceptance criteria, to feed back to business</li><li>Flesh out the technical tasks into technical subtasks</li><li>Label the technical tasks with a “Competency”</li></ol><h4>Sub Tasks</h4><ol><li>Create Import endpoint (Backend)</li><li>Create Import Button (Frontend)</li><li>Create Import Modal (Frontend)</li><li>Create Export function (Frontend)</li><li>Create playwright test</li></ol><p>My favourite Format for a subtask is the following:</p><h4>Background</h4><p><em>Usually starts with “see Parent” and end with “Why this is needed technical”</em></p><h4>Acceptance Criteria (if needed)</h4><p><em>Not always needed, depends how big the subtask is and who’s doing it</em></p><h4>Technical Steps Required</h4><p><em>Not always needed, depends how big the subtask is and who’s doing it</em></p><h4>Test Evidence Required</h4><p><em>I always like test evidence</em></p><h3>Ready for Estimation</h3><p>The goal of estimation is clear. <em>Provide a T-shirt size for each subtask</em></p><p>Don’t use story points. Read my article about why story points are dumb</p><p><a href="https://levelup.gitconnected.com/why-story-points-dont-make-sense-117fabdac8ca">Why Story Points don’t make sense</a></p><p>This process should be as offline as possible to avoid bogging people down with meetings.</p><p>A meeting before your new sprint starts to scoop up,<em> as well as a punishment</em> for all of the tasks that were not estimated offline.</p><h3>Ready for Prioritization</h3><p>The goal of Prioritization is obvious — <em>when </em>is it needed?</p><p>My favorite way to express this is with a “fix version” which represents a release with a clear release date.</p><p>In order to prioritize you need two pieces of information.</p><ul><li>How important is it?</li><li>How much effort is it?</li></ul><p>At this point you should both pieces of information and should decide whether this should go into this upcoming sprint or a future one.</p><h3>Refinement Tennis</h3><p>Sometimes the Technical refinement process uncovers some details that should be specified by further business refinement.</p><p>This is completely fine and natural, for this Software People should simply ask their questions clearly on the jira and return it to Business Refinement.</p><p>See points 2 + 3 in my Diagram.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZTLyeexHl_wKBVRB" /><figcaption>Refinement Tennis</figcaption></figure><h3>Conclusion</h3><p>There are people who say that you shouldn’t plan because it’s not Agile. Fire those people.</p><p>Planning is incredibly important. Shifting left means you’re taking stock of what you shouldn’t be doing and making sure what you are doing is correct before doing it.</p><p>It means Jiras are more rarely crap and therefore less:</p><ul><li>‘Bugs’ reported are actually new features.</li><li>‘Bugs’ that are actually bugs.</li><li>Starting again. Because the requirements are wrong</li><li>General Misery and heartbreak</li></ul><p>A planning board makes all of this a lot easier. By organising people around a process and enabling you to take meetings offline.</p><h3>If you enjoyed this post…</h3><p><strong>Give it a clap</strong> (or 50 — they’re free)! 👏<br><a href="https://garrett-james-cassar.medium.com/"><strong>Follow me</strong></a> for more.<br><strong>Share</strong> this post with your team.<br><strong>Got thoughts, ideas, or questions?</strong> Drop a comment below.</p><ul><li><a href="https://levelup.gitconnected.com/the-most-underrated-tool-in-engineering-dc3c7f68000a">The Most Underrated Tool in Engineering</a></li><li><a href="https://levelup.gitconnected.com/the-dumbest-phrase-in-engineering-were-too-busy-for-refinement-f1e52ed2195c">The Dumbest Phrase In Engineering — We’re Too busy for Refinement</a></li><li><a href="https://levelup.gitconnected.com/the-essential-overlooked-trick-to-designing-best-in-class-software-a97daa673279">The Essential, Overlooked Trick To Designing Best in Class Software</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba4d469d3b2b" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-planning-board-ba4d469d3b2b">The Planning board</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Dumbest Phrase In Engineering — We’re Too busy for Refinement]]></title>
            <link>https://levelup.gitconnected.com/the-dumbest-phrase-in-engineering-were-too-busy-for-refinement-f1e52ed2195c?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1e52ed2195c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Mon, 24 Feb 2025 14:13:34 GMT</pubDate>
            <atom:updated>2025-02-24T14:13:34.181Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Dumbest Phrase in Engineering — We’re Too Busy for Refinement</h3><p>It’s natural and easy to think ‘we need to get this feature out immediately therefore, we need to start coding straight away’.</p><p>But with any semi-intellectual endeavour a sense of urgency <strong><em>can</em></strong> have the ironic effect of making your team slower. The key isn’t to jump to action immediately, but to build strong feedback cycles so that you can find issues in the most cost effective way possible.</p><h3>Identify Problems Before Committing Resources To Them</h3><p>The further along in the development cycle, the more actions are required to get there. These actions may be high or low effort by themselves, but they accumulate and crucially require the attention of different groups.</p><p>This creates a scheduling problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*cw9x-OBayJHwYGFxrNGJ-w.png" /><figcaption>Scheduling Problem</figcaption></figure><p>As illustrated, every step in the development process requires input from different specialists, each with their own schedules, priorities, and mental bandwidth.</p><p>Each colored arrow represents a real person, each with their own availability, constraints, and unique understanding of the task at hand.</p><p>Every transition requires a pause, a context switch, and a certain amount of time to free up in that persons calendar, life, and head space.</p><p>Maybe your product manager is stuck in meetings all day, maybe your QA is sick, maybe your developer is several miles down a different rabbit hole.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*xpjkRabRFj--1TQzGod5eQ.png" /></figure><p>Therefore, even if the solution to a problem required just 1 hour of continuous work by 5 groups of people, you might require 4–5 days to deliver.</p><p>This transition also requires a leap of communication that risks derailing the entire train of thought or loss of information.</p><p>This game of Chinese whispers can cost millions and be the difference between a project succeeding or burning to the ground.</p><p>The best and only solution to this problem is to involve your best and brightest earlier in the development lifecycle and increase accountability.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/1*ByH8pFpqe_-dZoB4ZxeSjw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/627/1*tUsp0l1YrxNLgZEpAIfQcA.png" /></figure><p>This model doesn’t eliminate roles, but reduces the number of people who are responsible for the outcome. Others take a supporting role as a sort of consultant when questions arise that falls outside the primary persons realm of expertise.</p><p>[article about consultancy model coming soon…. oooo exciting]</p><p>Less context switching and more responsibility to the individual creates a creates a chain of responsibility that is shorter, simpler and more manageable. You are much less likely to create issues with communication through information changing hands and much more likely for people to see the wood through the trees.</p><p>The crucial thing here is those people (technical team leads) who are exchanging information must be <em>excellent communicators</em>. In order to:</p><ol><li>Create surface area for developers to pluck out edge cases.</li><li>Illustrate ideas accurately.</li><li>Eliminate doubt around acceptance testing.</li><li>Encourage simplicity over cleverness.</li></ol><ul><li><a href="https://levelup.gitconnected.com/the-most-underrated-tool-in-engineering-dc3c7f68000a">The Most Underrated Tool in Engineering</a></li><li><a href="https://levelup.gitconnected.com/the-essential-overlooked-trick-to-designing-best-in-class-software-a97daa673279">The Essential, Overlooked Trick To Designing Best in Class Software</a></li></ul><p>Done successfully, this creates <strong>stronger</strong> barriers at each stage of the development lifecycle which enables your team to catch bugs, point out edge cases and catch design flaws <em>before</em> they happen and you committed resources to them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*ClZiUm69S99cpUnDr3hbnA.png" /></figure><h3>There must be Balance</h3><p>Planning is only valuable if it leads to <strong>action</strong>.</p><p>Refinement is crucial, but <strong>overthinking and pontificating without moving forward </strong>can be lethal. Teams can fall into the habit of debating edge cases, reworking plans endlessly and optimizing for imaginary problems (like performance).</p><p>The goal isn’t perfection — but just enough refinement to avoid preventable mistakes, but not so much that progress stalls. Instead of waiting for a “perfect” plan, teams should embrace <strong>iterative learning</strong>:</p><ul><li>Start with a solid but <em>flexible</em> approach.</li><li>Build quickly, but with <strong>feedback loops</strong> in place.</li><li>Accept that early iterations will have flaws and <strong>course-correct fast</strong>.</li></ul><p>Speed and quality aren’t opposites. The best teams <strong>move fast</strong> not by skipping refinement, but by refining continuously as they build. Thinking ahead is smart — getting stuck is not.</p><h3>Conclusion: Cut the Noise, Build the Flow</h3><p>Speed isn’t about how fast you start coding — it’s about how well you set yourself up to finish. The biggest delays in software development don’t come from the actual work, but a lack of accountability, endless back-and-forths, and the dead time spent waiting for someone else to pick up the baton.</p><p>The solution isn’t to push harder or blame individuals — it’s to build smarter processes. Strong feedback cycles and earlier involvement from key players can massively shrink delivery time.</p><p>When developers care about testing and think like product owners, and when leaders facilitate flow instead of roadblocks, everything moves faster — without the scramble.</p><p>Speed doesn’t <strong><em>just</em></strong> come from urgency. It comes from clarity, accountability, and a process that works <em>with</em> people, not against them.</p><h3>If you enjoyed this post…</h3><p><strong>Give it a clap</strong> (or 50 — they’re free)! 👏<br><a href="https://garrett-james-cassar.medium.com/"><strong>Follow me</strong></a> for more.<br><strong>Share</strong> this post with your team.<br><strong>Got thoughts, ideas, or questions?</strong> Drop a comment below.</p><ul><li><a href="https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8">The one thing you need to do to 10x Development productivity — without AI</a></li><li><a href="https://levelup.gitconnected.com/why-story-points-dont-make-sense-117fabdac8ca">Why Story Points don’t make sense</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1e52ed2195c" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-dumbest-phrase-in-engineering-were-too-busy-for-refinement-f1e52ed2195c">The Dumbest Phrase In Engineering — We’re Too busy for Refinement</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Essential, Overlooked Trick To Designing Best in Class Software]]></title>
            <link>https://levelup.gitconnected.com/the-essential-overlooked-trick-to-designing-best-in-class-software-a97daa673279?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/a97daa673279</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Tue, 07 Jan 2025 18:30:59 GMT</pubDate>
            <atom:updated>2025-01-07T18:30:59.282Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JwhL7sFthTpiKPtn" /></figure><p>System Design is hard. Collaboration is harder.</p><p>Discussing system design with five or six people can be very effective.<br>It can also result in five or six wildly different ideas about what you agreed on. After a week or two the discussion could be a distant memory.</p><p>Mutterings like “didn’t we decide to do it like this?” or “hang on, why couldn’t we do it this way?” will emerge and the design session that you did is will be rendered useless.</p><p>Let’s fix that with Design Records</p><h3>Design Records</h3><p>Design Records are visual records that capture, clarify, simplify and document system design decisions. They’re a great centrepiece for any discussion that can be built during a design meeting or prepared beforehand. They reel people back in from dithering, create an engaging and understanding visual aid and a good surface area for scrutiny.</p><p>I like to structure Design Records as follows.</p><p>1. Problem Description (Given, When, Thens)<br>2. Sequence Diagram<br>3. Any Other Diagram<br>4. Design Meeting Recording<br>5. Optional Feedback status for future recordings</p><blockquote>Each of these sections are designed to help</blockquote><blockquote>- Create clarity<br>- Surface edge cases<br>- Solidify requirements<br>- Broaden Perspective<br>- Figure out infrastructure concerns<br>- Remember what the hell you were talking about last week.</blockquote><p>I’ll demonstrate this with an example problem.</p><h3>Example Problem</h3><p>“I’d like to receive a CSV describing an order of burgers after checking inventory.”</p><p>How many edge cases can you find right now without moving forward with the article?</p><p>Let’s spell it out</p><h3>Step 1. Clarify the Problem with “Given-When-Then”</h3><p><em>Given: </em>The inventory is present for the entire order<br><em>When: </em>I receive a valid burger CSV<br><em>Then: </em>I create a burger order<br><em>And: </em>Send it to the kitchen service</p><blockquote>Just structuring the language in this way might prompt a few questions.</blockquote><blockquote>- What happens if the inventory is not there? Do I make as many burgers as I can, or do I reject outright?<br>- What is a valid burger CSV?<br>- What happens if it’s not valid?<br>- Do I validate line by line or as a whole file?</blockquote><p>This is a vital step of creating surface area for scrutiny and should help you fan out your requirements from this base.</p><p>You can read more about that here.</p><p><a href="https://levelup.gitconnected.com/language-has-taken-us-a-long-way-from-the-caves-into-towns-and-cities-and-modern-civilization-82db61f169d2">6 steps to great Functional Requirements</a></p><h3>Step 2. Sequence Diagrams</h3><p>My favourite part.</p><p>Sequence diagrams are great because they are:</p><ol><li>Less boring than text</li><li>Easy to put together</li><li>Easy to Understand</li></ol><pre>sequenceDiagram<br>title Ordering a Burger from file<br>participant S3 as S3 Folder<br>participant BO as Burger Order<br>participant IS as Inventory Service<br>participant KS as Kitchen<br><br>note over BO: Inventory is present for the entire order<br>S3-&gt;&gt;BO: Valid burger CSV<br>BO-&gt;&gt;IS: Check inventory<br>IS →&gt;BO: 200 OK (Inventory valid)<br>BO-&gt;&gt;KS: Burger order<br>KS →&gt;BO: 202 Accepted (Order received)<br>BO →&gt;S3: 201 Created (Order sent)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*169CvCJFxnSwlHHa" /></figure><p>Taking the time to make a diagram like again prompts many questions from many different types of stakeholder.</p><blockquote><strong>Infrastructure</strong>:</blockquote><blockquote>- How does the file get onto s3?<br>- Can files be modified?<br>- How will s3 notify the service of the Order Service?<br>- Permissioning requirements?</blockquote><blockquote><strong>Developers</strong>:</blockquote><blockquote>- What are the validation cases?<br>- What about Error cases?<br>- How should we surface errors?<br>- Will there ever be other ways someone can order a burger, is that accommodated in my design?<br>- Analytics platform Integration?<br>- How and when do we communicate that an order has been accepted or processed?</blockquote><p>Maybe I’m just weird, but I find putting the diagram together fun to do because of how lazy you can be with a combination of copying and pasting and jigging.</p><blockquote>If that’s not lazy enough you can actually ask AI to help both with drawing the diagram and scrutinizing the design itself.</blockquote><blockquote>Communicating an idea clearly to a human is the similar to communicating an idea clearly to an AI. AIs are just better at iterating on those ideas.</blockquote><blockquote>Great questions to ask:</blockquote><blockquote>“Look at each of these system interactions and try to scrutinise the design based on the most common https error codes” — Can you generate error messages for those cases.</blockquote><blockquote>“What infrastructure questions might this raise given an AWS deployment based on lambdas, in a vpc ….. (maybe feed an architecture diagram)”</blockquote><blockquote>“Using the principles of domain driven design, ask me a series of questions to help me identify strong domains and bounded contexts”</blockquote><blockquote>“Generate my code…”</blockquote><p>Learn how to use the most amazing diagram tool in the world, read my post:</p><p><a href="https://levelup.gitconnected.com/the-most-underrated-tool-in-engineering-dc3c7f68000a">The Most Underrated Tool in Engineering</a></p><h3>Step 3. Record Meetings to Capture Decisions</h3><p>Adding a video recording of your design discussion is a simple, but incredibly powerful step for long-term clarity and alignment. It answers the classic “What did we talk about last week/month/year/hour and why were we so giddy with it?” and helps new team members or absent stakeholders catch up quickly.</p><blockquote><strong>Tips for effective recordings:</strong></blockquote><blockquote>Use tools like <strong>Loom</strong>, <strong>Zoom</strong>, <strong>Google Meet, Microsoft Teams</strong> to record meetings seamlessly.</blockquote><blockquote>- Take a transcript. AI Summarize the transcript.</blockquote><blockquote>- Highlight critical decisions or key moments by noting timestamps. For example:<br> — “Timestamp 05:32: Decision to validate the entire CSV as a whole.”<br> — “Timestamp 12:48: Discussion on error codes for inventory mismatch.”</blockquote><blockquote>- While this can be a time consuming process, AI tools are becoming much better at this and can help remove this tedium from your life.</blockquote><blockquote>- Share the recording link alongside the design record so it’s easy to access the context.</blockquote><blockquote>- Remember to stop recording before you start moaning about your colleagues</blockquote><h3>Step 4. Commit this to a repository</h3><p>Git is great. It was designed by Linus Torvalds and everything.</p><p>Why commit design records to a repository?</p><ol><li><em>Versioning</em>: Changes to design documents are tracked with meaningful commit messages. You can always revert or compare past versions.</li><li><em>Accessibility</em>: Stakeholders who missed the meeting can review the design without requiring another meeting.</li><li><em>Collaboration</em>: Pull requests enable comments and reviews before a design is finalised, promoting shared ownership.</li><li><em>Evolution of Ideas</em>: It’s easy to see how designs adapt over time. You can answer questions like, “Why did we change this?” or “What did the previous version look like?”</li><li><em>Easy to find</em>: How many times have you written a good piece of documentation to throw it into the bottomless eternal ether that is confluence?</li></ol><h3>Bonus Step. Share your designs</h3><p>Problems rarely exist in isolation.</p><p>It’s likely, for generic issues, that other teams in your company are presented with a similar problem. If executing a well planned design, you likely have a solution with pre-canned code, infrastructure, scrutiny and thought.</p><p>Examples: Notification Systems, Communications Systems, File sharing systems, event based architectures, centralised logging, metrics systems.</p><h3>Conclusion</h3><p>Having effective design discussions (and remembering them). Is a cornerstone of a good software team.</p><p>Design Records can clarify requirements, surface edge cases, and ensure everyone stays aligned — leading to better designs and fewer mistakes that can increase the cost of delivery by an exponential.</p><p>In my experience, buy-in for this idea comes really easily and people love it.</p><p>You should do it.</p><p>If you enjoyed this post…</p><p><strong>Give it a clap</strong> (or 50 — they’re free)! 👏</p><p><a href="https://garrett-james-cassar.medium.com/"><strong>Follow me</strong></a> for more.</p><p><strong>Share</strong> this post with your team.</p><p><strong>Got thoughts, ideas, or questions?</strong> Drop a comment below.</p><h3>Hungry for More? 🍔</h3><p>Check out these related posts:</p><ul><li><a href="https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8">The one thing you need to do to 10x Development productivity — without AI</a></li><li><a href="https://levelup.gitconnected.com/why-you-should-never-default-to-microservices-c952903fbcb6">Why you should never default to Microservices</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a97daa673279" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-essential-overlooked-trick-to-designing-best-in-class-software-a97daa673279">The Essential, Overlooked Trick To Designing Best in Class Software</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Most Underrated Tool in Engineering]]></title>
            <link>https://levelup.gitconnected.com/the-most-underrated-tool-in-engineering-dc3c7f68000a?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/dc3c7f68000a</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Sun, 29 Dec 2024 16:03:12 GMT</pubDate>
            <atom:updated>2024-12-29T16:03:12.837Z</atom:updated>
            <content:encoded><![CDATA[<p>When optimizing you should consider three things.</p><p>Scarcity, Cost and Value.</p><p>In <em>any</em> project, the scarcest, highest cost, and the most valuable resource are people. Software design is no different. Complexity, feedback cycles and processes are all reasons that software projects slow down and even fail, but it starts with people and how they communicate.</p><p>For that reason, a high performing team requires leadership that doesn’t just set the direction — but clears the path and makes it <em>crystal clear</em>.</p><p>This article is about that very clarity — adjusting your communication style away from tedious, mountainous, tomes no one will read and replacing them with engaging visuals. And the best tool for it.</p><h3>Why Visuals?</h3><p>Your brain is wired to process images faster and retain them longer than text.</p><p>About 50% of your brain is directly or indirectly devoted to visual processing (according to studies from the MIT Department of Brain and Cognitive Sciences). Research shows that people retain visual information significantly better than text alone, with retention rates up to 65% higher for visual content compared to text-only information.</p><blockquote>Incidentally — While our brains love diagrams, AI’s neural nets love the syntax behind the diagrams. They trim the fat around details and limit the solution space, making a great base for code generation — More on that later.</blockquote><h3>Mermaid</h3><p>Mermaid is a brilliant diagramming tool for several reasons.</p><h4>Free and Open Source Standard</h4><p>It’s virtually impossible for your company to say that you’re not allowed to use it or take it away.</p><p>They don’t need to pay for it, and it is not <em>really a</em> tool. It’s a standard. It doesn’t run in an environment, doesn’t require a log in, and using it implies nothing about creepy big tech or hackers peering at your companies private information.</p><p>It is simply a standard that has been established as an extension on markdown. It can run or render where ever you like.</p><h4>Intuitive and easy to use</h4><p>The Mermaid syntax always felt obvious and intuitive.</p><p>It’s really simple. Much simpler than 99% of the things you likely had to learn to get to this stage of your career. Putting a diagram together is an enjoyable, fast experience of copying, pasting, jigging and rejigging that gives you a comprehensive, easily editable and tidy diagram.</p><blockquote>If your really lazy — using Cursor or any LLM platform works really well. Like any AI related endeavor — not perfect but enough to create a base for you to lazily jig from there.</blockquote><h4>Example</h4><p>- Sign up process for a puppy trainer app.</p><p><em>Tedious, Mountainous Tome inbound (feel free to skip):</em></p><blockquote>“When a person decides to sign up as a puppy trainer in the puppy training app, the system performs several steps to validate the signup. First, the app checks if the user input fields (e.g., name, email, bio) are valid. If any of the fields fail validation, the signup is rejected, and an error message is displayed.</blockquote><blockquote>Next, assuming input validation passes, the app prompts the user to answer a set of qualification questions designed to assess their skills, experience, and intent to become a puppy trainer. Once the user submits their answers, the system sends the details to a “Trainer Qualification System” for evaluation. The Trainer Qualification System reviews the responses and determines whether the applicant meets the qualifications. It then responds to the app with either a “qualified” or “rejected” status.</blockquote><blockquote>If the user qualifies, the app initiates a 24-hour waiting period to ensure the applicant is serious and not impulsively signing up. During this period, the app notifies the user to check back later. Once 24 hours have passed, the system proceeds to insert the validated trainer details into the database.</blockquote><blockquote>Finally, the app triggers an email notification service, which sends a welcome email to the trainer, confirming their successful signup and encouraging them to start training puppies. The app then informs the user that their signup process is complete. If the applicant does not meet the qualifications, the app notifies the user that their signup was unsuccessful.“</blockquote><p>Now let’s see how this looks in diagrams</p><h3><strong>Sequence Diagrams</strong></h3><p>Define system interaction</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/898/0*5nGbEaISrDuJEBZg" /><figcaption>Sequence Diagram — Signing up as a puppy trainer</figcaption></figure><p>Sequence diagrams kind of do what they say on the tin.</p><p>Sequencing helps understand interactions between multiple systems. Drawing these help to point out data dependencies, resiliency issues and demonstrate issues with domain concepts.</p><p>I find sequence diagrams easy for my brain to gobble up.</p><p>Drawing these out and putting them in front of people almost always helps them to understand the system better and prompts them to raise questions like “What about data analytics?”, “What if they get stuck”, “What if that system fails”. “How do I express error cases?” Good questions.</p><p>I’ve at times avoided months of work at a time simply by taking 5 minutes to write up a diagram and sticking it in front of the right people.</p><pre>sequenceDiagram<br>participant Trainer as Aspiring Puppy Trainer 🐾<br>participant App as Puppy Training App<br>participant HumanCheck as Trainer Qualification System<br><br>Trainer -&gt;&gt; App: &quot;Sign up!&quot;<br>App -&gt;&gt; App: Validate<br>App →&gt; Trainer: &quot;Confirm you&#39;re not a robot 🧍‍♂️🤖&quot;<br>Trainer -&gt;&gt; App: &quot;I&#39;m human!&quot;<br>App -&gt;&gt; App: Validate humanity ✅<br>App →&gt; Trainer: &quot;Puppy Training Questions.&quot;<br>Trainer -&gt;&gt; App: Answers<br>App -&gt;&gt; App: Initiate 24-hour waiting period ⏳<br>App →&gt; Trainer: &quot;Great! Please check back in 24 hours 🕒&quot;<br><br>Note over App, Trainer: Induce Waiting period to ensure seriousness<br>App -&gt;&gt; HumanCheck: Send answers for evaluation<br>HumanCheck →&gt; App: &quot;Trainer meets qualifications ✅&quot; or &quot;Trainer rejected ❌&quot;<br><br>alt Trainer qualifies<br>  App →&gt; Trainer: &quot;Congrats, you&#39;re all set! 🐶&quot;<br>else Trainer rejected<br>  App →&gt; Trainer: &quot;Sorry, you did not qualify as a trainer. 🐾&quot;<br>end</pre><h3><strong>Flow charts</strong></h3><p>Define internal logic</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/0*CmSakVHOUBz5Wlae" /><figcaption>Flowchart — Signing up as a Puppy Trainer</figcaption></figure><p>Sequence diagrams illustrate interactions between different systems. Flow charts describe how a system works internally.</p><p>Flow charts by definition have smaller scope. I tend to find flowcharts useful for very complex processes (unlike this one) within a single system. In my experience most human bugs and slow delivery happens in the interaction of several systems. For this reason, I find them less useful for documentation purposes as a flow can be made self-evident by reading the code. So really you’re just creating an additional diagram to maintain.</p><p>Having said that, these are great for hashing out and visualizing complicated requirements and serve as a good base for automated code generation and automated test generation.</p><pre>flowchart TD<br><br>A[Start: Aspiring Puppy Trainer Sign Up] → B{Validate Input}<br>B →|Pass| C{Confirm You&#39;re Not a Robot}<br>C →|Pass|D{Confirm You can train puppies}<br>D →|Pass| I[Congrats, You&#39;re All Set! 🐶]<br>D →|Fail| J[Sorry, You Did Not Qualify as a Trainer 🐾]<br>C →|Fail| E{You&#39;re definitely a robot}<br>B →|Fail| K[End: Input Rejected]</pre><h3><strong>Class Diagrams</strong></h3><p>Define logical breakdown and separation of concerns.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oat4hBPWhgplxcmH" /><figcaption>Class Diagram — Puppy Trainer Sign up</figcaption></figure><p>While I find this less useful for senior developers, or for documentation purposes — as the class structure should be self-evident. It can be very useful for suggesting a separation of concerns by function or for working through a game plan with a more Junior developer.</p><p>This is also extremely useful for code generation with AI — Communicating with a junior developer can be very similar to communicating with an AI.</p><pre>classDiagram<br><br>class Trainer {<br>+string name<br>+string email<br>+string bio<br>+boolean isHuman<br>+boolean isQualified<br>+validateTrainer()<br>}<br><br>class QualificationQuestion {<br>+string question<br>+string response<br>}<br><br>class HumanValidationService {<br>+boolean validateHuman(Trainer)<br>}<br><br>class HumanCheckService {<br>+boolean evaluateAnswers(Trainer, QualificationQuestion[])<br>}<br>class SignUpService {<br>+startSignUp(Trainer)<br>+processEvalutation(Trainer, QualificationQuestion[])<br>-requestEvaluation(Trainer, QualificationQuestion[])<br>}<br>class EmailService {<br>+sendWelcomeEmail(Trainer)<br>}<br>SignUpService → Trainer<br>SignUpService → HumanValidationService<br>SignUpService → HumanCheckService<br>SignUpService → EmailService</pre><h4><strong>Experiment</strong></h4><p>Copy and paste the previous three diagrams into the AI of your choice and ask it to generate the code in any language of your choice.</p><p>Then ask it to write some good high level testing for that.</p><h3><strong>Conclusion</strong></h3><p>Mermaid diagrams are brain candy that make complex systems digestible. They’re not just pretty pictures — they’re a powerful way to spot problems before they become expensive mistakes, get everyone on the same page quickly, and even bootstrap your code generation efforts with AI.</p><p>They’re free, work everywhere, and are simple to learn.</p><p>Whether you’re explaining a system to a junior dev, senior dev, a team of devs, planning out a new feature, or trying to spot failures before they happen Mermaid diagrams are your friend.</p><p><em>It’s the easiest thing you can do to optimize your most valuable, scarcest and most expensive resource. People.</em></p><p>Get Started <a href="https://mermaid.js.org/syntax/flowchart.html">Mermaid’s official syntax guide </a>— it’ll take you about 15 minutes to learn the basics.</p><h3>Grovelling</h3><p>If you enjoyed this post and found it helpful…</p><p><strong>Give it a clap</strong> (or 50 — they’re free)! 👏</p><h4>Follow for More Content</h4><p>I write about <strong>system design</strong>, practical tools for developers, and building high-performing teams. Follow me to stay updated on my latest articles.</p><p>🔔 <strong>Hit “Follow”</strong> so you don’t miss the next one.</p><h4>Discuss</h4><ul><li><strong>Got thoughts, ideas, or questions?</strong> Drop a comment below — I’d love to hear them.</li><li>Share this post with your team if you think they’ll find it useful.</li></ul><h4>Hungry for More? 🍔</h4><ul><li><a href="https://levelup.gitconnected.com/language-has-taken-us-a-long-way-from-the-caves-into-towns-and-cities-and-modern-civilization-82db61f169d2">6 steps to great Functional Requirements</a></li><li><a href="https://levelup.gitconnected.com/why-story-points-dont-make-sense-117fabdac8ca">Why Story Points don’t make sense</a></li><li><a href="https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8">The one thing you need to do to 10x Development productivity — without AI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dc3c7f68000a" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-most-underrated-tool-in-engineering-dc3c7f68000a">The Most Underrated Tool in Engineering</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why you should never default to Microservices]]></title>
            <link>https://levelup.gitconnected.com/why-you-should-never-default-to-microservices-c952903fbcb6?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/c952903fbcb6</guid>
            <category><![CDATA[java]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Thu, 03 Oct 2024 20:28:15 GMT</pubDate>
            <atom:updated>2024-10-12T10:00:43.353Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Disclaimer: Grumpy Goose Warning</em></p><p>There’s a prevailing idea that monoliths create bad code. Monoliths don’t create bad code. Developers do.</p><p>Splitting a monolith might improve code quality by creating strong boundaries between different domains. But:</p><ol><li>It also might not. Resulting in a distributed monolith, which is a lose lose.</li><li>You can also do that within a monolith.</li></ol><p>You also run the risk of dramatically increasing the complexity of your project. Hamstringing your testing capabilities, complicating your infrastructure and deployment process, and potentially creating ‘split brain’ between various services.</p><p>This loss of efficiency compounds quickly. And is generally bad vibes.</p><h3>Complexity in Testing</h3><p>Software is hard because you don’t get any points if 99 things go right and 1 fails. It all needs to work.</p><p>Therefore you need to test things all together. Or to have a large test scope.</p><p>Test scope is a measure of how much can be tested within a single test.</p><p>The smaller the scope the further you’re getting from the actual user experience. Meaning the <strong><em>less</em></strong> likely a <strong><em>passing test</em></strong> means the <strong><em>feature works</em></strong> and a <strong><em>failing test </em></strong>means a <strong><em>feature doesn’t work</em></strong>.</p><p>In a monolith, testing a large scope is easy. Because it does everything</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/0*qUokdeQGbPm-ytYX" /></figure><p>Monolith interaction</p><p>However in Microservices, the same process looks more like this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/463/0*SgM6dch6RiXBFKV3" /></figure><p>Microservice Interaction</p><p>Your test scope will naturally be limited by the natural boundaries of your Microservice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/0*SHeitJUifw-jnaeP" /></figure><p>Typical Microservice Test set up</p><p>Forcing us to mock or stub (replace and ignore) the behaviour in the order and fulfilment service.</p><p>Meaning that changing and additional behaviour in the Order or Fulfilment services will be ignored.</p><p>A <strong><em>passing</em></strong> test is <strong><em>less likely</em></strong> to mean the feature works and a <strong><em>failing</em></strong> test is <strong><em>less</em></strong> a feature <strong><em>doesn’t</em></strong> work.</p><p>You could have 10000 passing tests at this level and still face bugs like this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/353/0*jgdj5dDWkC0_vkDH" /></figure><p>Or this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/353/0*MNpJSCGiziQEuhhX" /></figure><p>Or multiple other iterations, due to changes in the business logic in the order service or product service, data or contracts.</p><p>As you aren’t really testing these interactions you are mocking (faking) them.</p><p><em>Even if this isn’t a problem to start — it will become one as processes gain complexity and drift. Causing you to either find more bugs in UAT or to make your mocks more intelligent — which is a great way to waste an afternoon.</em></p><p>This relies on the knowledge and diligence of each individual developer to manually test two things in conjunction before merging in the code. In my experience, that is inconsistent.</p><p>Bugs are inevitably found in UAT through manual testing rather than through automated testing. Which is like spending 100 pounds on a 10 pound burger.</p><p>If that slips through the cracks and gets to production, that’s like spending 1000.</p><p>Read about the exponential cost of fixing a bug here:</p><p>https://garrett-james-cassar.medium.com/the-one-thing-you-need-to-do-to-10x-development-productivity-without-ai-813f6f7437f8</p><p>In a monolith however it is very possible to have a test suite that is scoped as such.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*WSUb7PStqmC4aWsE" /></figure><p>Nothing is mocked, stubbed, faked or hoodwinked.</p><p>Providing a larger test scope.</p><p>Meaning that it is much <strong><em>more </em></strong>likely that a passing test means the feature <strong><em>works </em></strong>and less likely that a <strong><em>failing</em></strong> test means a feature <strong><em>doesn’t</em></strong> work.</p><p>This is a much simpler mode of testing. It doesn’t rely on anyone being perfect, experienced, knowledgeable or sufficiently caffeinated that day.</p><p>It doesn’t require your mocks to be up to date or intelligent.</p><p>And if you really wanted to mock one of your services — you still can very simply.</p><p>While there are ways around this — I’ll address that in another blog post.</p><p>Another advantage is that you don’t need any contract tests — the compiler does that for you. (In a strongly typed language anyway).</p><h3>Complicating your infrastructure</h3><p>Getting caught in a complex web thing that needs to talk to each other gets really complicated really quickly.</p><h3>Adding steps</h3><p>Example: Adding a new endpoint.</p><h3>Monolith</h3><ol><li>Create endpoint</li><li>Create permission for endpoint</li><li>Hook up the endpoint to the front end</li></ol><p><strong>Microservice</strong></p><ol><li>Create endpoint</li><li>Create user permission for endpoint</li><li>Create endpoint infrastructure</li><li>Create pipeline for new microservice</li><li>* n — create permissions for all microservices to talk to this endpoint.</li><li>* n — make sure all the infrastructure as code is updated correctly and nothing was modified directly.</li><li>* n — Hook up the endpoint</li></ol><p>I’ve gone from having 3 steps to 4 + ( 3* n) steps.</p><p>I’ve also created several points of failure in addition to making it very difficult to test.</p><p>Is that a win? Doesn’t feel like a win.</p><h3>Managing split timelines</h3><p>If infrastructure is managed fully by a separate infrastructure team — which I never recommend — delivery will almost certainly be difficult. No matter how good they are.</p><p>You’re not answering the question</p><ol><li>‘Can we get this done in the next sprint?’</li></ol><p>You’re answering the questions</p><ol><li>‘Can we get this done in the next sprint?‘</li><li>‘Can the infrastructure team get this done in the next sprint, and will they put it together in time so as not to block us?’</li></ol><p>It’s inevitable that in the annals of time the answer to the first question will be yes to one and no to the second.</p><p><em>This is not the infrastructure team’s fault, it’s just a reality. You could replace that with a business team, QA team, deployment team or whatever team you want. Managing multiple timelines instead of one will result in clashes of priorities and timelines.</em></p><p>So when the Project manager asks ‘Can you get this done in this amount of time.’ The answer goes from being ‘Yes/No’ to ‘I don’t know, it’s not in my hands’</p><p>Putting your face on a project where your hands are not will make you too — a grumpy goose.</p><p>Splitting timelines might also encourage shortcuts and compromises based on what’s deliverable by any one team. This can lead to worse design — potentially the second most expensive thing you can do on a project.</p><p><strong>Anecdote<br></strong>I once worked at a company where I designed a solution that required a simple s3 bucket. As a qualified aws solution architect I know this is a five minute job.</p><p>So I called the infrastructure team to ask and I asked if they could provide one. They said “Yes, in around 6–7 months”.</p><p>Long story short I quit after 8 months, it still wasn’t done. A year later the tech department had massive layoffs. Related? No idea, but I certainly felt they had a bloated, inefficient tech department.</p><h3>Are Microservices a terrible idea?</h3><p>No. They’re not. They have two irreplaceable advantages and a replaceable one.</p><ol><li>Independent deployability (enjoy your 147 pipelines) — Including independent development teams, yada yada.</li><li>Independent scalability.</li><li>Strong separation of concerns — This can be replaced by a strong, principled development team.</li></ol><p>But they add a lot of complexity.</p><p>If you’re a get things done kind of developer — and I think you should be — Adding complexity always needs a strong justification.</p><p>Jumping in without a strong justification tends towards making decisions based on the dogmatic rather than the logical. That’s a terrible idea.</p><h3>Conclusion</h3><p>My advice.</p><ul><li>Start with a monolith.</li><li>Test well with nice, large scopes.</li><li>Obsess around boundaries.</li></ul><p>Treat boundaries of your monolith as if it <strong><em>was</em></strong> made up of Microservices. Have the boundaries talk to each other through an interface (<em>just not an application program interface — API</em>). So that you can split them whenever you like. But don’t.</p><p>Not until you have a really good justification around deployability, scalability or teams working independently that arises naturally. Justify how you will maintain the same level of testing. Document the necessity and make a case for it.</p><p>If it’s a good one, do it. If it’s not, do the simple thing and stick to a monolith.</p><p>Your job is to get things from A to B as quickly as possible. Make that as easy as possible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c952903fbcb6" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/why-you-should-never-default-to-microservices-c952903fbcb6">Why you should never default to Microservices</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Layer Separation III — Microservices and Workflows]]></title>
            <link>https://levelup.gitconnected.com/understanding-layer-separation-iii-microservices-and-workflows-54218636a990?source=rss-925e3db50a98------2</link>
            <guid isPermaLink="false">https://medium.com/p/54218636a990</guid>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Garrett James Cassar]]></dc:creator>
            <pubDate>Thu, 04 Apr 2024 14:47:20 GMT</pubDate>
            <atom:updated>2024-04-17T09:58:37.498Z</atom:updated>
            <content:encoded><![CDATA[<h3>Microservices, lambdas and workflows oh my</h3><h3><strong>Workflows</strong></h3><p>Workflows are orchestration tools that help to build business processes that look like this.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TjLZBkmcY75UMvGr" /></figure><p>Where bits of ‘glue code’, represented by these little boxes, are connected together via bpmn notation.</p><p>Workflows can be invoked by some action on your UI, that progresses the workflow from the beginning state (thinly outlined circle) on the left to an end (thickly outlined circle) state towards the right and bottom.</p><p>After a workflow is run in production, it allows you to view how tasks have been executed, when they finished and how it ended.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*NF6DRQBMItRkNSkV" /></figure><p>Workflows are great for three reasons:</p><ol><li>Greater visualisation of tasks<br>- Business can understand and help model how a system works</li><li>Auditability and metrics<br>- Clear data and metrics that can be quoted at meetings, support functions, (and lawsuits)</li><li>Long standing and Human related tasks<br>- By leveraging a workflow engine you can model in tasks that need to wait for long running actions or require human interaction</li></ol><h3>AWS Lambdas (Serverless functions)</h3><p>Lambdas are ‘serverless’ functions that are offered by AWS.</p><p>What serverless really means is that your function does not run on a dedicated server, but is an ephemeral bit of code, where the resources for that code are allocated at time of execution.</p><p>This offers 3 awesome advantages:</p><ol><li>They are instantly <em>scalable</em></li><li>They are <em>simple and fast</em>: don’t need to think about infrastructure</li><li>The can be cost effective. They are charged per execution and not per hosting time</li></ol><p>Workflows and lambdas are both great. But but they add complexity in a microservice environment.</p><p>Why?</p><p>Previously, I had several viable options as to where a distinct unit of logic could live. Now I have several viable options and their workflows and their lambdas.</p><p><strong>Workflows, Lambdas and the Layer Cake<br></strong>As I introduce in my OG article <a href="https://garrett-james-cassar.medium.com/understanding-layer-separation-73274e2bee27">Understanding layer separation</a></p><p><a href="https://garrett-james-cassar.medium.com/understanding-layer-separation-73274e2bee27">Understanding Layer separation</a></p><p>Layer separation is the process of separating code into functionally distinct areas that depend on each other in a particular way, to achieve some desirable traits.</p><p><em>TLDR</em>;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/401/0*cvrwo_jZCGn9C7Am" /></figure><p><strong>Connectors</strong> — Communicate to other things<br><strong>Adaptors</strong> — Translate outside messages to internal models<br><strong>Service</strong> — Carry out use cases (aka <em>logic with preconditions</em> aka <em>given/when/thens</em>)<br><strong>Entities</strong> — Carry out domain logic (aka <em>business rules</em> aka <em>when/thens</em>)</p><p>So which logic belongs where?</p><p>After some research [<a href="https://processautomationbook.com/">practical process automation</a>] and some ponderance, I’ve come up with the following.</p><p>Workflows and Lambdas can be best described as a <em>part of the service layer. </em>As they can both be described by a series of use cases by <em>Given/When/Thens</em> format, but because of their distributed nature, they can not hold a domain.</p><p>A Lambdas, Workflows ‘do things’. They aren’t domains. You can’t have a ‘Insurance Lambda.’ Or a ‘Credit Workflow’, you can have a ‘Book insurance Lambda’ or A ‘Do a credit check Workflow’.</p><p>Therefore migrating the logic from a Microservice and into a workflow or a Lambda, has the effect of making the <em>service layer thinner.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/0*Z07uTMicq_24UM0E" /><figcaption>Extracting workflow from a Microservice</figcaption></figure><p>In the case of workflows, use cases or parts of use cases can be extracted from the services layer for the purpose of <em>auditability</em>, <em>visualization</em> and in order to <em>model long standing and human tasks</em>.</p><p><em>Example</em>: I have one use case that involves a insurance manager carrying out a manual credit check.</p><p>Workflows can hold as much control logic as is required and beneficial to be visualized.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*8_fBqX6P29wVEu7cntp3-g.png" /><figcaption>Extracting Lambda from a Microservice</figcaption></figure><p>In the case of lambdas, use cases or parts of use cases can be extracted from the services layer for the purpose of <em>scalability</em>, <em>simplicity</em> and c<em>ost savings</em>.</p><p><em>Example</em>: One particular use case has a process that is very compute intensive and needs to scale out much more than the rest of the use case.</p><p>Lambdas can hold control logic, but they don’t have the advantage of the visualization so can be as dumb as you like.</p><p><strong>Microservices<br></strong>It’s worth reminding ourselves that the advantages of microservices are that it’s independently <em>scalable</em>, independently <em>deployable</em> and <em>functionally distinct</em>.</p><p>Microservices should contain all data related operations including:</p><ul><li>Validation</li><li>CRUD (Create, read, update, delete) operations</li><li>Domain logic — logic without precondition. All domain logic should be stable and consistent, whether I want to invoke these operations from workflow A, workflow B, or microservice C or Lambda D.</li></ul><p>Just like a service layer, it’s important to constantly finely comb your code in order not to allow domain logic to leak into your workflow. This would lead to duplicated and messy code.</p><p>It’s worth noting that any simplicity that is gained from simplifying your infrastructure, will quickly be eroded by a lack of domain.</p><p><strong>Conclusion<br></strong>Workflows — <em>greater visualization</em>, <em>auditability</em> and <em>modeling</em> <em>long standing and human tasks.</em></p><p>Lambdas — <em>Scalable, Simple, Cost Effective.</em></p><p>Microservices — <em>independently deployable, independently scalable, strong single domain.</em></p><p>Workflows and Lambdas can be great to work with, but you need to know what they are and know what they aren’t.</p><p>Workflows And Lambdas:</p><ul><li>Are Not a domain</li><li>Are Not a replacement for a microservice</li><li>Are Not a crud store</li><li>Are Representative of a group use cases</li><li>Can be part of (workflows only) or external to a Microservice</li></ul><p>Please:</p><ul><li>Press and hold the clap button</li><li>Follow me: <a href="https://medium.com/@garrett-james-cassar">https://medium.com/@garrett-james-cassar</a></li><li>Add me on LinkedIn: <a href="https://www.linkedin.com/in/gary-cassar-55648b67/">https://www.linkedin.com/in/gary-cassar-55648b67/</a></li></ul><p><strong>Further Reading</strong></p><ul><li><a href="https://levelup.gitconnected.com/why-story-points-dont-make-sense-117fabdac8ca">Why Story Points don’t make sense</a></li><li><a href="https://levelup.gitconnected.com/language-has-taken-us-a-long-way-from-the-caves-into-towns-and-cities-and-modern-civilization-82db61f169d2">6 steps to great Functional Requirements</a></li><li><a href="https://levelup.gitconnected.com/contract-testing-without-pact-771942355b8f">Contract Testing — Without pact</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54218636a990" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/understanding-layer-separation-iii-microservices-and-workflows-54218636a990">Understanding Layer Separation III — Microservices and Workflows</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>