<?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 Kenzan  + Sourced on Medium]]></title>
        <description><![CDATA[Stories by Kenzan  + Sourced on Medium]]></description>
        <link>https://medium.com/@kenzanmedia?source=rss-5961f8e0b790------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*cBun3AWCvbDpcuVU.png</url>
            <title>Stories by Kenzan  + Sourced on Medium</title>
            <link>https://medium.com/@kenzanmedia?source=rss-5961f8e0b790------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 02:27:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kenzanmedia/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[DevOps: Small Deployment Size and Low Work-in-Progress Drive Success]]></title>
            <link>https://kenzanmedia.medium.com/devops-small-deployment-size-and-low-work-in-progress-drive-success-8ef8d580124e?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ef8d580124e</guid>
            <category><![CDATA[devops-practice]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[conways-law]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Fri, 26 Aug 2022 20:20:42 GMT</pubDate>
            <atom:updated>2022-09-08T21:02:09.545Z</atom:updated>
            <content:encoded><![CDATA[<p>By <a href="https://www.linkedin.com/in/michael-james-ryan/">Michael Ryan</a>, Head of Architecture and Managing Principal Consultant</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i3xCLGJyak89zTCq" /></figure><h3>Fast and Frequent: Is There Really a Need For Speed?</h3><p>Most DevOps transformations focus on speed. The primary goals are often to:</p><ol><li>Shorten the time between code being committed to code running in production(Lead Time for Changes).</li><li>Deploy code to production more frequently(Deployment Frequency)</li></ol><p>The 2021 DORA(DevOps Research and Assessment) report shows Elite DevOps teams are fast. They deploy on demand, often multiple times per day.</p><p>On the other hand, Low performing teams are slow. They deploy less than once per 6 months.</p><p>Elite DevOps teams quickly push code through DevOps pipelines and into production. Their Lead Time for Changes is less than one hour.</p><p>Low performing teams take more than 6 months to get code from commit to production.</p><p>From the <a href="https://cloud.google.com/blog/products/devops-sre/announcing-dora-2021-accelerate-state-of-devops-report">DORA 2021 Report</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lfr7YbhtxHsqk6i5" /></figure><p>Much of the tooling and practices built around DevOps pipelines focus on quickly validating code and deploying to production. Practices like “shifting left” on testing — automatically validating code on developer’s laptops before it is even committed — detects and fixes defects before code even gets into a DevOps pipeline. This reduces Lead Time for Changes and increases Deployment Frequency.</p><p>Overall, the industry emphasis is on being fast and frequent: quickly getting code from engineer laptops to production and doing this dozens, even hundreds, of times per day.</p><p>But what is the point of deploying fast and frequently? High Deployment Frequency and low Lead Time for Changes are very important but do not provide value in themselves. Instead, increases in team productivity and software quality are driven by the combination of <strong>small Deployment Size</strong> and low <strong>work-in-progress (WIP)</strong>.</p><blockquote><strong>Work-In-progress (WIP)</strong> is a concept that comes from the Lean manufacturing movement. WIP is considered a form of waste — work that has been done and paid for but is providing no benefit to the customer or the company.</blockquote><blockquote>In a software development context, WIP is written code that is not yet in production. It can be on an engineer’s laptop but not committed to a repository, committed to a repository but not yet in a DevOps pipeline, or code in a DevOps pipeline waiting to be deployed. Essentially, WIP represents completed work that is already paid for by the business but is not providing value for a customer.</blockquote><blockquote>More important than financial considerations, WIP requires cognitive bandwidth to manage. In manufacturing, partially finished items need to be moved and stored until they can be completed. In software, partially finished items often end up in long running code repository branches. A team needs to keep track of what features are in what branch and be aware of any interactions between branches. The cognitive load this imposes on a team takes away from providing value to the customer and company.</blockquote><h3>Deployment Size and WIP are What Matters</h3><h4>Deploying Small and Single Piece Flow</h4><p>The benefits of DevOps are not derived from going fast, but from continuously pushing <strong>small</strong> amounts of code to production in a process similar to single-piece flow in manufacturing. Within limits, the smaller the amount of code pushed through a DevOps pipeline into production the better.</p><p>Small deployments are better than large deployments. Why?</p><ul><li>Small amounts of code are easier to develop and test than large amounts of code. Testing small amounts of code is simpler and less error prone than testing large amounts of code.</li><li>Small chunks of code are easier to build and deploy. The time to deploy is less because the complexity is less.</li><li>Monitoring and defect detection are easier. In the event a defect is released to production it is much easier to pinpoint the problem when only a small amount of code has been released. This reduces the DORA metric Mean Time To Resolution.</li><li>It is easier to roll back small amounts of code if there is a production defect. In practice, changes in a small deployment model are often so incremental that the customer impact of any defect is negligible. A “fix forward” approach is often used instead of a rollback.</li><li>It is easier and quicker to get customer and stakeholder feedback on the deployment of a small feature, and easier to implement future changes based on that feedback.</li><li>Constant small deliveries of value to customers increases both customer satisfaction and the developer experience of engineers.</li></ul><blockquote><strong>How small a deployment is small enough?</strong> One quick test is if a single person fully understands all the code being deployed. It is nearly impossible for one person to fully understand everything in a deployment that combines code from multiple teams each contributing several features. If a team’s deployments are not passing this test it is a warning the deployments are too large.</blockquote><blockquote>Work to deploy smaller — there are tips to do so throughout this article.</blockquote><p>Many of these benefits disappear with larger deployments. Small Deployment Size drives value, but…</p><h4>Deploying Small is Not Enough: How High WIP Increases Decreases Team Effectiveness</h4><p>The benefits of small deployments are greatly reduced if Lead Time for Changes gets so large that multiple deployments are stacked up in a DevOps pipeline. Stacked deployments means WIP increases, and when WIP increases the cognitive load on a team increases and software quality tends to suffer.</p><p>Large deployments and high WIP increase cognitive load on a team while also increasing the complexity of the tasks the team must handle. They kill productivity and harm the overall developer experience. This is a form of Extraneous Cognitive Load(described below) and can cause the performance and morale of a team to deteriorate badly.</p><p>On the other hand, low WIP reduces cognitive load on a team. Limiting WIP shortens the lead time for new features, reduces context switching, and allows engineers to concentrate resources and attention on the tasks that are most important. When team members focus on only one thing at a time they are more productive and generally more satisfied with their work. Developer experience is enhanced.</p><p>Low WIP is correlated with, but does not automatically come with, small Deployment Size. Small Deployment Size is critical — but the amount of un-deployed code a team is responsible for also needs to be minimized to get the full benefit. An engineering group could deploy 10 times per day but if those deployments each take a week to get through testing and another day waiting for manual approval there will still be a high level of WIP. The team will suffer under the increased cognitive load and become frustrated.</p><p>Of course WIP can be reduced by having engineers stop writing code — and this approach is used more often than realized. The better solution is to automate and optimize the team’s DevOps pipeline so code gets through as rapidly as possible. When code flows rapidly through a DevOps pipeline at any point in time there is very little code (WIP) in the pipeline itself. Deployment size is small. This is why the DORA Lead Time for Changes metric is important but not itself a driver of software quality.</p><p>In the end it is coupling small Deployment Sizes with low WIP that reduces team cognitive load, improves software quality and enables a team to reach elite status.</p><blockquote>Cognitive load is a concept introduced in 1988 by psychologist John Sweller and recently made more popular by the book Team Topologies: Organizing Business and Technology Teams for Fast Flow by Matthew Skepton and Manuel Pais.</blockquote><blockquote>There are three different kinds of cognitive load:</blockquote><blockquote><strong>Extraneous Cognitive Load</strong> — items that demand attention but do not add much value. An example would be typing a lengthy and arcane set of commands to deploy an application to a test environment. This sort of load should be minimized through automation or better tooling. A high level of extraneous cognitive load can be very demotivating for experienced developers. They want to work on tasks that provide high value not waste time on manual work or bureaucratic tasks.</blockquote><blockquote><strong>Intrinsic Cognitive Load</strong> — mental capacity related to foundational elements of the current task. In software engineering these are items an engineer should “just know”. Examples would be debugging with an IDE, knowledge of a particular language, commonly used libraries or other specialized tools. Teams should try to minimize this kind of cognitive load through training, hiring talented staff, proper tooling, etc.</blockquote><blockquote><strong>Germane Cognitive Load</strong> — this is where most of an engineer’s cognitive capacity should be spent. Examples are higher level “value add” thinking on architectural concerns or code-level tactical decisions like API design. This is where deep understanding of a code base takes place.</blockquote><blockquote>A team’s capacity to handle cognitive load is very limited and must be consciously managed. Try to eliminate Extraneous Cognitive Load, minimize Intrinsic Cognitive Load and maximize Germane Cognitive Load.</blockquote><h4>Know Where The Constraints Are</h4><p>Now we understand why rapidly moving code through a pipeline (Lead Time for Changes) is so important — it reduces cognitive load by reducing WIP and also results in small deployments.</p><p>In most real-life scenarios there will be a number of pipeline improvements to choose from. How does a team know which change will most reduce WIP or Deployment Size? This is the crucial question. “Improvements” that do not reduce WIP, do not reduce Deployment Size, do not reduce the cognitive load on a team or provide other benefits are a form of waste. It is very easy to spend much time and money improving the wrong thing.</p><p>This is where the Theory of Constraints can play a role. Focusing on constraints is the fastest and most effective way to improve performance of a pipeline or any other process.</p><blockquote><strong>Theory of Constraints</strong> states that in any process there is usually one most important limiting factor (the constraint). Only improvements to this constraint will translate into maximal improvement of the whole process. Improvements to factors that are not constraints provide less benefit if any at all.</blockquote><p>When one constraint is removed then another step becomes the constraint — the new most important limiting factor. Focusing on removing constraints ensures improvements are always made on the most important factor — and what is the most important factor often changes as improvements are made to other steps in the process.</p><p>A high level of WIP often means there are significant constraints in the system. Early in a DevOps transformation these constraints are often manual steps.</p><p>For example, waiting one week for manual approval of a release may be the constraint in one deployment system. It would probably not be a wise investment if a team were to spend two weeks improving a different part of the system so work got to the manual approver in three hours instead of four. The constraint in this system is manual approval of deployments — working to eliminate or greatly optimize that step will provide the most value to the team.</p><p>In some processes there is a single constraint, which is the case when multiple processes are run in parallel. In that case only improvement in the longest process will result in time savings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/514/0*dhmyQuRYp5gt82fJ" /></figure><p>More rarely processes may have more than one constraint, such as when tasks are arranged linearly with no buffer time between them. In this case time savings on any task results in overall time savings. The choice of which constraint to optimize may come down to the cost of improvement.</p><p>In most real-world scenarios <a href="https://www.lean.org/lexicon-terms/value-stream-mapping/">Value-Stream Mapping</a> can help identify these bottlenecks. Value-Stream Mapping originated in the Lean manufacturing movement. It is a technique that creates a visualization of all the components and steps necessary to deliver a product or service. Once the visualization is created the goal is to analyze and optimize the entire process.</p><h4>The Wrong Branching Model Can Increase Deployment Size and WIP</h4><p><strong>Gitflow vs Trunk-based Development</strong></p><p>Time and again teams use finite cognitive bandwidth to coordinate multiple “release” code branches, each scheduled for deployment on a different date. By definition each release branch is WIP. Engineers have to keep track of what features are in each release branch while also developing new features. This sort of structure creates distraction and requires frequent context switching. It can be very error-prone.</p><p>Using the right branching strategy is critical to deploying small. Some branching models like <a href="https://nvie.com/posts/a-successful-git-branching-model/">Gitflow</a> optimize on protecting a release from engineers the team doesn’t know or trust. This is often the case in a large open-source project with thousands of committers.</p><p>With Gitflow the code base is split into several long running branches, each designated for a future release. The cognitive load on a team using Gitflow tends to be high. They have to remember what each branch is for, what features are included in each branch, and how code in each branch interacts with other branches. There are many checks as code winds its way to production.</p><p>Gitflow is the right tool for certain use cases, but the payment for all the protection it offers are often very large, infrequent releases. This is the opposite of what will drive value for most DevOps teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dHtIsEUyn7PHAMzY" /><figcaption>Typical Gitflow pattern. Image by Toptal</figcaption></figure><p>Instead, look at <a href="https://trunkbaseddevelopment.com/">Trunk-based development</a>. Trunk-based development is a practice where developers merge small, frequent updates to a core main branch. Trunk-based development has strong support in the DevOps community as it streamlines merging and reduces cognitive load. It is designed for speed and frequent small deployments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/386/0*nYZpRNnEx7viOJhy" /><figcaption>Typical Trunk-based workflow. Image by Vincent Driessen</figcaption></figure><h3>The Deployment Death Spiral</h3><h4><strong>Deployment Frequency is Still Very Important</strong></h4><p>To review, deployments of small amounts of code drive improvement in software quality, developer experience and customer satisfaction. A team has to deploy frequently if they want to continually deploy small amounts of code while maintaining good productivity. Frequent deployments enable small deployments which improve software quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4IN4GIRUJi-p632V" /></figure><p>The reverse is also true: when a team deploys less frequently their Deployment Size tends to increase, developer experience worsens and software quality goes down. A decrease in software quality leads to more of a team’s capacity spent fixing defects instead of building features that provide value to customers. Things can unravel quickly from here.</p><p>In practice this anti-pattern often unfolds as follows: A team deploys on a set schedule (weekly, monthly or quarterly). In one cycle a defect is found in testing just before the deployment date and the deployment must be delayed. As the diagram below illustrates, something as simple as delaying a deployment can sometimes create a downward spiral that is hard to escape from.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_gwDLs_CneotOouA" /></figure><p><strong>Decreased Deployment Frequency.</strong> When defects are discovered prior to a deployment the application needs to be re-tested. This takes time even if all testing is automated. If testing is manual it can take weeks to get even small changes or bug fixes through validation. Much of this work may have to be repeated if the defect is not completely fixed on the first try. As a result, production <strong>Deployment Frequency</strong> slows.</p><p><strong>Increased Deployment Size. </strong>Let’s say there are 10 engineers working on a software system. Most of those engineers are evaluated on producing features or fixing defects — evaluated at least in part on writing code.</p><p>This team of engineers continues to churn out code and features whether they are deployed quickly or not. All this code is WIP. Deployment delays often result in more WIP building up. The size of the next deployment increases.</p><p><strong>Increased Production Defect Rate.</strong> As the size of deployments increase the likelihood defects are released to production also grows. Each team has an error rate which could be expressed as defects per line of code or defects per story point. Either way, the more lines of code or story points deployed the odds the deployment contains a defect increase. Some defects will be trivial, others more serious and require immediate re-deployments.</p><p>Larger deployments increase the percentage of production deployments resulting in customer complaints and emergency hot-fixes increases.</p><p><strong>Increased Time to Fix Production Defects.</strong> A larger deployment makes fixing production defects more difficult. There is more code to inspect and more possible interactions between features being deployed. It is simply harder to find and fix defects when a large amount of code is deployed. This increases the Mean Time to Resolution metric used by DORA.</p><p><strong>Increased Testing Time. </strong>When more defects are released to production the natural impulse is to fix the problem by testing more. If this involves manual testing, even manual spot checking “just to be sure” the automated tests are working correctly, then Deployment Frequency is slowed and Deployment Size and WIP increases. Paradoxically, this extra testing effort can increase the odds a production defect is released and increases the time to find and fix that defect.</p><p><strong>The Spiral Worsens.</strong> With more time spent on testing, Deployment Frequency drops again. This causes another corresponding increase in the size of each deployment and increases the odds of a defect being released to production. The time to fix any defects also increases, more restrictions and checks are made before each deployment (perhaps a second level of approval by rarely available senior management) and the cycle repeats itself.</p><p>All the while the original 10 engineers are working earnestly and continue to churn out more features and bug fixes for the next release. Deployments grow bigger and more complex each cycle.</p><p>This can become a downward spiral. Engineers become frustrated and look for other work, taking their domain knowledge with them. Dissatisfied customers don’t understand why the software can’t be made to work properly. They are aggravated by the overall poor quality and are likely to switch to other providers if given the chance.</p><p>Sure, a team may not fall into the death spiral on their first large deployment. Many teams skate by for some time and suffer no ill effects. But sooner or later serious defects emerge, fixing them takes longer, the amount of WIP grows, deployments get larger and the Deployment Death Spiral takes hold.</p><h4>Four Steps to Escape the Deployment Death Spiral</h4><p>Being trapped in the Deployment Death Spiral is painful. There are no cookie-cutter solutions to this problem. Each engineering group and company are different, as are the demands placed upon them. Political considerations are different everywhere.</p><p>A common counterproductive approach is an attempt to “catch-up” by adding new features on top of any rework from the previous deployment. The appeal is with a little extra work over the next few releases the team can get back on schedule. In fact, this approach only perpetuates the Deployment Death Spiral by simultaneously increasing the size of the next deployment while increasing WIP. It often fails.</p><p>Instead, take care that each step to escape the Deployment Death Spiral either <strong>reduces Deployment Size, lowers WIP, or both</strong>.</p><p>Below are some concrete techniques to pull out of the death spiral. They have worked for other successful teams and may work for the reader’s team as well.</p><p><strong>Step 1: Do not make matters worse by continuing to merge new code into the pipeline.</strong></p><ul><li>Merging new code into the DevOps pipeline just increases WIP and increases the size of the next deployment. This is exactly what a team wants to avoid. Only merge code for absolutely “must have” features or bug-fixes. This reduces WIP in the pipeline and the size of the next deployments.</li><li>WIP still exists in the form of features waiting to be merged into the DevOps pipeline, but for now this form of WIP is easier to manage than WIP in the pipeline itself.</li><li>This step reduces Deployment Size and lowers WIP.</li></ul><p><strong>Step 2: Assign a portion of the team to automating testing and optimizing the DevOps pipeline.</strong></p><ul><li>This step can sometimes be done concurrently with Step 1.</li><li>This step can be politically challenging to implement. However, if 100% of an engineering team is always putting out fires there will never be any capacity to improve.</li><li>Moving engineers from writing application code to work on DevOps pipelines or automated testing reduces WIP (by not creating it in the first place) and reduces the size of the next deployment.</li><li>Automating the DevOps pipeline makes it run faster. This reduces WIP and reduces Deployment Size by getting code to production faster. Value-Stream Mapping can identify constraints to be removed.</li><li>Automating testing reduces overall WIP by getting code through the DevOps pipeline and into production faster. It can take some time to automate testing in a large application, so one good first step is to require <strong>any new feature or defect fix be tested entirely through automation</strong>. Just this one practice can make a profound difference in Deployment Frequency, Deployment Size, Change Failure Rate and WIP.</li><li>This step lowers WIP and reduces Deployment Size.</li></ul><p><strong>Step 3: Commit to reducing Deployment Size by increasing Deployment Frequency</strong></p><ul><li>Remember that high Deployment Frequency leads to low Deployment Size. Low deployment Frequency leads to high Deployment Size.</li><li>Use increasing Deployment Frequency as a forcing function. If a team is deploying quarterly, challenge them to deploy monthly. If they deploy monthly, challenge them to deploy every two weeks. The team provides a list of steps to meet the Deployment Frequency goal and then implements those steps. This can be very effective at identifying waste in the entire code/build/deploy process.</li><li>Working on increasing Deployment Frequency also keeps engineers from adding code to the DevOps Pipeline, which reduces WIP and the size of the next deployment.</li><li>Keep challenging the team to reduce Deployment Size. The optimal way to do this is to deploy very small chunks of code virtually on demand. However, a team does not need to deploy on demand to see substantial improvements in application quality and overall work life.</li><li><strong>Important Note:</strong> this isn’t about forcing engineers to work harder or produce more features. The amount of work produced by the team should be constant. Instead, the team is simply reducing Deployment Size by deploying the same amount of work to production more frequently.</li><li>This step reduces Deployment Size and lowers WIP.</li></ul><p><strong>Step 4: Pay Attention to Conway’s Law</strong></p><ul><li>Use cross-functional teams to design and construct a DevOps pipeline. This team’s objective is reducing WIP and reducing Deployment Size by rapidly moving code through the pipeline.</li><li>Fight against any manual checks or approvals. If a human can test quality, so can a machine. But a machine can do it over and again without getting bored, distracted or tired.</li><li>Reduce hand-offs to a bare minimum, even in an automated process. Hand-offs are weak points in any process.</li></ul><blockquote><strong>Conway’s Law</strong></blockquote><blockquote>​​Conway’s Law was created by Melvin Conway in 1967. Conway’s Law states that “Organizations, who design systems, are constrained to produce designs which are copies of the communication structures of these organizations.” In software architecture, this means any architectural design tends to mimic the structure of the organization designing it.</blockquote><blockquote>Many companies manually pass each deployment through multiple teams: Dev hands-off the deployment to QA, QA hands-off to Performance, Performance hands-off to Security and so on. The work is done sequentially and involves manual hand-offs. Any additional steps are simply added to the chain.</blockquote><blockquote>When it comes to automating this process the hand-of pattern often repeats itself. Work is not done in parallel because each team is accountable for their own results and therefore insists on having their own isolated step of the process. The hand-offs between teams tend to become manual. This slows the entire process. It is better than when all work was manual, but still not very effective.</blockquote><blockquote>The problem is not each team zealously making sure their responsibilities are met. The problem is how the pipeline team itself is constructed. A cross-functional team with representatives from each group (Dev/QA/Performance/Security) charged with maintaining high quality while reducing WIP will likely come up with a better pipeline design.</blockquote><h3>A Virtuous Upward Spiral Begins</h3><p>Implementing these steps can produce a virtuous upward spiral, essentially the reverse of the Deployment Death Spiral. The team’s capacity to produce quality software is increased at every step.</p><p>This pattern often unfolds as follows:</p><ul><li>The faster a team deploys the smaller their deployments become.</li><li>Smaller more frequent deployments reduce WIP.</li><li>WIP is further reduced by automating DevOps pipelines and testing.</li><li>Small deployments and lower WIP lower Change Failure Rates (odds of a defect released to production). The team spends less time fixing defects after every production release and more time providing value to customers.</li><li>Even if a defect is released to production, it is easier to find and fix the defect because less code was released. This lowers Mean Time To Resolution.</li><li>An organization’s confidence in automated DevOps pipelines and automated testing increases as the quality of deployments increases. More and more testing is automated, which reduces WIP and reduces Change Failure Rate.</li><li>The cognitive load on the team continues to decline. They have more time and capacity to further decrease Deployment Size and reduce WIP. Software quality increases.</li><li>Production defects become very rare. Instead of spending engineering capacity putting out production fires, engineers are continually seeking new ways to improve their processes and delight customers.</li></ul><p>Why does this even matter? In most cases if a team deploys small it has to deploy fast (increase Deployment Frequency). Increasing Deployment Frequency tends to make deployments smaller and also reduce WIP. Deploying small and deploying fast seem like two sides of the same coin. Does keeping the team’s focus on small deployments and low WIP really matter?</p><p>It does matter. Here’s why:</p><p><strong>Benefits are Easy to Explain to Stakeholders. </strong>Stakeholders can understand the benefits of small deployments. A team deploys small because small deployments are easy to understand, easy to test, easy to rollback, and make it is easier to find and fix defects. High Deployment Frequency is one of the things that enable small deployments, but high Deployment Frequency is not the goal in itself. It’s important that stakeholders understand this.</p><p><strong>Ease Fears of Recklessness.</strong> Very frequent deployments worry stakeholders. Speed seems reckless. If some stakeholders learn the team wants to deploy multiple times a day they will worry the team won’t be testing carefully.</p><p>Stakeholders aren’t irrational. Sometimes they don’t understand how software quality is improved because no one has properly explained it to them.</p><p>Demonstrate to these stakeholders how large deployments are inherently risky. Describe the Deployment Death Spiral to them. Let them know the team is proactively reducing risk by breaking up large deployments into smaller and more manageable chunks that are easier to test. Hopefully they better understand the benefits small deployments and low WIP provide.</p><p>Think of it as the difference between someone memorizing and then perfectly reciting a hundred lines of poetry all at once versus memorizing and reciting three or four lines of poetry at a time until the poem is completed. Which approach is going to be less error-prone and more likely to succeed?</p><p><strong>Measure what matters.</strong> If small Deployment Size and low WIP drive quality, shouldn’t the team measure them along with the other DORA metrics?</p><p>Admittedly, measuring Deployment Size and WIP is hard and might require tracking lines of code deployed or something more indirect like story points or <a href="https://www.fingent.com/blog/function-point-analysis-introduction-and-fundamentals/">function point analysis</a> . Even if Deployment Size and WIP are hard to measure, we recommend teams consider tracking them along with the other DORA metrics.</p><p><strong>When things go sideways.</strong> Even with great engineers, superior automated processes and the most agile of practices a team will run into stretches where a few non-trivial defects are released to production. Perhaps Deployment Size has inched up and now the team is paying the price.</p><p>Stakeholders might again think the team is not being careful enough. These stakeholders might be senior people in the company who strongly suggest the team reduce its Deployment Frequency and be more careful. They want to personally approve each release. In their minds frequent deployments are reckless because in many areas of life speed IS reckless. It is the team’s job to explain why frequent, small deployments reduce risk.</p><p>By arguing the focus is on continuously deploying small chunks of code and reducing WIP the team might keep from falling into the Deployment Death Spiral.</p><p>In Kenzan’s experience engineering organizations can be broken down into three groups:</p><p><strong>Base-level </strong>engineering organizations employ many manual processes. Performance declines rapidly under a limited amount of change or load. Their capacity for improvement is small and they can only recover to baseline performance with extreme difficulty.</p><p><strong>Effective </strong>engineering organizations produce good quality software while enduring a moderate amount of change or load. If either exceeds a certain threshold performance rapidly declines. These organizations use some automated processes while still depending on manual work for important tasks. Their capacity for improvement is modest and they can recover to baseline performance with moderate difficulty.</p><p><strong>Elite </strong>engineering organizations grow stronger the more change or load is applied to them, in the same way the human body grows stronger through rigorous exercise. They actively seek to learn from mistakes and incorporate those learnings into future work, often embracing cloud infrastructure and cloud-native architectures. These organizations depend heavily on automation to increase quality while reducing cognitive load on teams and individuals. Their capacity for improvement is great and they can recover to baseline performance with relative ease.</p><p>Getting DevOps right is critical to becoming an elite engineering organization. If you’d like to discuss these concepts further please reach out to the author at mryan@kenzan.com. Michael Ryan is Head of Architecture and Managing Principal Consultant at Kenzan.</p><p><em>Originally published at </em><a href="https://medium.com/@michaeljamesryan/devops-small-deployment-size-and-low-work-in-progress-drive-success-5fda8768b7ce"><em>https://medium.com</em></a><em> on August 26, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ef8d580124e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Driving Growth with Data Mesh Architectures]]></title>
            <link>https://kenzanmedia.medium.com/driving-growth-with-data-mesh-architectures-e10a009dc7e?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/e10a009dc7e</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[data-mesh]]></category>
            <category><![CDATA[data-analysis]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Tue, 09 Aug 2022 18:48:36 GMT</pubDate>
            <atom:updated>2022-08-09T19:44:26.976Z</atom:updated>
            <content:encoded><![CDATA[<p>By <a href="https://www.linkedin.com/in/michael-james-ryan/">Michael Ryan</a>, Head of Architecture</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JELbyMRrf_LPCS4n" /></figure><h3>Why read this article?</h3><p>If you are perfectly happy with your company’s data analytics capabilities and you’re using data to effectively drive business decisions, you can stop reading now.</p><p>Unfortunately, few readers are in this category. In our experience, even clients with sophisticated data architectures sometimes struggle utilizing their data. The following examples may sound familiar:</p><h4>Company A: Sophisticated, but reaching the limits of current technology</h4><p>Company A has multiple domain specific applications streaming data into an ETL pipeline and then into a data lake. A team of highly skilled data engineers analyzes the data and generates reports for various internal consumers. The capabilities of Company A’s data team and data lake infrastructure are very impressive, but their data analytics system is becoming the victim of its own success. Their useful reports simply spur demand for even more reports. On one hand, more domains want to pump data into the lake; on the other, the demand for more variety and more reports keeps growing. The data analytics system cannot scale; lead time for new reports grows, and report quality declines. Shadow data analytics takes hold — reports created by data consumers who cannot wait for the data team. These consumers get their data from other sources, causing a security and governance nightmare. In this case, a data mesh can be a low-cost way of siphoning off the more routine reporting tasks from the data lake, saving the data lake and the efforts of the highly skilled data engineers for the more analytic work they are meant for.</p><h4>Company B: Data silos pose barrier to growth</h4><p>Company B has a collection of domain-specific applications for HR, Legal, Sales, Shipping, and other departments. Each application has its own data store constructed of a number of available technologies: relational, noSQL, graph databases, flat files, and event streams stored both on-premises and in a public cloud. While each domain-specific application adequately reports on its own data, Company B struggles to generate actionable insights by combining data across domains. For Company B, a data mesh is perfect for aggregating data products generated by each domain in ways that provide insight into the business as a whole.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n69lG-GRSfeaWHCq" /></figure><h4>Company C: Small but growing rapidly</h4><p>Company C is not yet using on-demand reporting to drive business decisions. Reports might be generated by hand at a weekly or longer cadence. This approach can work in the early phases of growth but the demand for actionable data will soon grow faster than the company’s ability to generate it. In this case, building a simple data mesh is an inexpensive way to enter the realm of on-demand analytics and reporting. Company C can get the immediate benefits of a data mesh and then let it grow and adapt in response to future demands. Best of all, the initial investment in a data mesh paves the way for more substantial investments in traditional data architectures if that becomes desirable.</p><p>If any of these examples sound familiar, a data mesh may provide immediate value and a foundation for future growth for your company.</p><h3>What is a Data Mesh?</h3><p>A data mesh is not a product. You cannot download data mesh software. While there is a common set of tooling used to build data meshes, there is no one-click install.</p><p>A data mesh is an architectural pattern made popular by Zhamak Dhaghani of Thoughtworks. Despite all the attention and commentary around data mesh architecture, it can be hard to understand exactly what a data mesh is and whether it is something that might benefit your company.</p><p>Simply put, the data mesh pattern operates much like microservices do; it can be similar to a network of read-only microservices focused on data. While the pattern is often described as an almost revolutionary approach to using self-service platforms to embrace the distributed nature of data, data meshes use the same industry-standard tools and techniques that have been used at scale by microservices for almost a decade.</p><p>We view data mesh as an <em>evolutionary</em> application of widely used techniques and technologies, not a risky revolutionary re-write of current data analytics architectures. A small data mesh can be up and running in a short period of time. Maintenance is often limited to adding new data products or altering others if the underlying data structures change in some way. In either case, risk is reduced because changes are made by domain experts familiar with the data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pBY92RBAOIgg0LxC" /></figure><p>As is often the case with microservice architectures, each node uses its preferred set of technologies and techniques to meet their specific requirements. Also like microservices, the technologies and techniques used by each node are often subject to some degree of engineering or architectural governance. The data mesh architecture does not mandate means of communication or API standards, but nodes often employ RESTful APIs documented through tools like Swagger as well as various streaming techniques.</p><p>While this example is simple, data mesh topologies can quickly become complex as more varied types of data are added. We recommend starting small and letting your data mesh evolve with demand. The actual topology of mesh nodes will depend on your company’s unique needs and its layout of data sources. Obviously, this topology will change over time; the data mesh architecture allows for that.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JzgwETgb0eKSzHip" /><figcaption>Data product combining data from events and serverless function.</figcaption></figure><h3>Data Products and Data Nodes</h3><blockquote><strong>What is a Data Product? </strong>A data product is defined as the code, data and infrastructure required to deliver in a self-service manner a domain-specific data structure that produces business value to a consumer. Data products can be relatively simple (for example monthly sales by office) but are often complex combinations of smaller, simpler data products ( for example quarterly sales trends by office correlated to regional demographics and sales incentives).</blockquote><blockquote>Data products are used for both analytical and operational purposes.</blockquote><blockquote><strong>What is a Data Node?</strong> Multiple data products can be combined in a single data mesh node. A data mesh node can be thought of as a read-only microservice.</blockquote><p>An important notion in data mesh architecture is the concept of data products. Each node in a data mesh exposes a collection of data products to the end user as well as to other data products in the mesh. In this way, each data product can become a building block for larger and more useful data products. When data products build blocks into arbitrarily complex structures, one of the most useful aspects of a Data Mesh is born: customized cross-domain data products.</p><p>Highly customized data capabilities arise when one Data Product is able to incorporate other data products into itself. In the above illustration, the Finance Node retrieves data from the Sales Node, combines that data with its own, and returns the resulting data product to the data dashboard.</p><h3>Advantages of a Data Mesh</h3><h4>Data Meshes Scale Better than Traditional Data Pipelines or Data Lakes/Warehouses.</h4><p>The anti-patterns described for the companies above are typical. They are not the result of bad engineering or insufficient budgets; they are not even a drawback of traditional data architectures. We believe these anti-patterns arise from an attempt to utilize traditional data architectures to meet all the varied demands for data and analytics that come from even small businesses.</p><p>The following sequence of diagrams illustrates a common experience with a data lake architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aRAraiY7XtHqx97O" /><figcaption>Stage One: This configuration is often successful with a small number of internal providers and consumers.</figcaption></figure><p>There is often success in the beginning phases of a data lake architecture. The number of data providers and data consumers is low and the specialized data team can keep up with the supply of data and the demand for reports and analytics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9G8UB6vpFhoafDEi" /><figcaption>Stage Two: Both publishers and subscribers grow. Workload on small data team increases. The architectural and organizational model does not scale.</figcaption></figure><p>In the second phase, success stimulates more demand for data insights. The number of publishers and subscribers grows, and workload on the data team increases. The architectural and organizational model does not scale; delays in generating analytical insights increase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_p2fFn0YbgxUR-PB" /><figcaption><em>Stage Three: More providers and subscribers overwhelm pipelines. Shadow Data Analytics takes hold.</em></figcaption></figure><p>In the final phase, there is a growing backlog for adding new data sources and generating new reporting insights. Long waits to get needed data often lead to shadow data analytics, where teams turn to unofficial sources of data. This can lead to severe security and governance issues.</p><h3>Data Mesh Encourages Domain Ownership of Data</h3><p>A more traditional approach to data analytics might attempt to combine data from multiple sources into a single monolithic data lake or data warehouse. In a data mesh, domain experts own the data and package it in ways that maintain the data’s integrity and fitness for purpose.</p><p>A common drawback to traditional ETL pipelines and data analytics architectures is that the data engineers are not familiar with the data they process; they are not domain experts and do not have ownership of data. When a traditional ETL pipeline and its data lake is new, this is not as much of an issue because the pipelines are not processing that much data yet. Data engineers tend to be highly intelligent and can easily learn about the small amount of data they process. But after the wave of initial successes, when more business domains and more and more data is pushed through the pipeline, problems can begin. The volume of data challenges even the most talented data engineering team. A common symptom of this is longer lead times to generate even simple reports coupled with lower quality of the data included in the reports. The distributed nature of the data mesh helps eliminate this problem. In a data mesh, domain teams own their own data and control how it is exposed to the rest of the system.</p><p>Domain-driven design can play an important role in defining corporate domains, and well-defined domains are critical to implementing an effective data mesh. See our <a href="https://kenzanmedia.medium.com/building-software-that-shouts-the-language-of-your-business-by-michael-ryan-head-of-architecture-567a76757e58">domain-driven design article</a> for more information.</p><h3>Data Mesh Limits Coupling of Resources and Promote Maximum Flexibility</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*xb2HyJ1y-K_16UQ3" /><figcaption><em>Monolithic ETL and Data Lake Architecture with many Publishers and Subscribers</em></figcaption></figure><p>As with microservices, tight coupling is the enemy of a highly functional data mesh. The Independently Deployable Rule as applied to microservices also applies to data meshes; every node on a mesh should be deployable without making corresponding changes to other nodes in the mesh. In the example above, a deployment to the Finance node should always be made by itself, independently, without a corresponding deployment to the Sales node, and vice versa.</p><p>Coordinating deployments of individual data mesh nodes can be difficult. Adhering to the independently deployable rule in a data mesh often implies some versioning scheme applied to data products. One important aspect of each domain implementing their own data products is that each domain is responsible for its own pipelines. Distributed pipelines tend to eliminate the tight coupling of ingestion, storage, transformation and consumption of data typical of traditional data architectures like data lakes.</p><p>The design influence of microservices on a data mesh is apparent in its flexible nature. A data mesh can expand and contract to match your data topology as it grows in some areas and shrinks in others, the way different technologies like streaming can be used where needed or how nodes can horizontally scale to meet demand.</p><h3>Data Mesh Facilitates Creation of Data Products through Domain Ownership of Data</h3><p>In data mesh parlance, a data product is a node or portion of a node on the data mesh. It is the code and infrastructure required to deliver data to a consumer as well as the data itself. This is the smallest deliverable unit a data mesh can provide. Because the data product is created by domain experts who own the data, the quality of the product tends to be much higher than data provided by other architectures.</p><p>Data products must be easily discoverable to maintain the usefulness of the mesh. Most implementations will use some sort of data catalog or registry of data products. To make the catalog useful, information like description, owners, component data products, and lineage are all included and often updated as part of a build pipeline.</p><p>The docs-as-code pattern is an excellent practice to employ when building a data mesh. Quick and accurate discoverability is key: if a data product’s meta data is allowed to become out-of-date, the usefulness of the data mesh will dwindle.</p><h3>Meet Business Needs by Combining Data Products in Arbitrarily Complex Ways</h3><p>Distributed data mesh nodes can call one another just like microservices call one another, and together they can generate and collate data products from multiple sources to deliver on-demand actionable reporting. A data mesh can even be used to increase observability of a company’s activities — a simple use case would be ordering more inventory depending on an analysis of sales patterns over the last few days. Though this is not a typical use of a mesh, it shows the flexibility of the solution.</p><p>The diagram below illustrates how data products in various domains can call other data products and integrate the responses into their own offerings. This capability not only promotes code reuse allows for arbitrarily complex data structures to be composed with relative ease.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BGqONfBAlU8Tg0nQ" /></figure><h3>Scale Each Data Node as Required</h3><p>Some nodes on a data mesh may provide important data products but are accessed infrequently. Other nodes may provide access to event streams and be accessed constantly. Each data node needs to scale independently in the same way any microservice in a microservice architecture needs to scale independently of other microservices. Independent scalability of application components is a core tenet of cloud-native applications (see <a href="https://12factor.net/">https://12factor.net/</a>).</p><p>Container management tools like Kubernetes that automatically create, delete and scale data nodes fit well in a data mesh architecture. A Kubernetes pod can house a data mesh data product. The Kubernetes horizontal pod autoscaler (HPA) will monitor resource demand and automatically scale the number of pod replicas, which independently scales copies of any one data node. By default, the horizontal pod autoscaler will determine every 60 seconds whether scaling up or down is necessary. When changes are required, the number of replicas is increased or decreased accordingly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rahuOvN5q9izDBQq" /></figure><h3>Data Mesh Governance is Implemented at the Data Product Level</h3><p>In a data mesh, governance is federated within each data product. It’s best to have the most knowledgeable team responsible for implementing governance; this reduces centralized bottlenecks like data review meetings. Although some bottlenecks can be avoided, be aware that in most cases federated governance places an extra demand on the domain team.</p><h3>Data Mesh is Built Using Industry standard tooling</h3><p>Data meshes are built using microservice technologies, patterns, and DevOps pipelines that are all well known and heavily used in industry for nearly ten years. A data mesh employs tools and principles commonly used in microservice architectures such as containers, Kubernetes, service meshes (Istio, Consul, Linkerd), and zero-trust security measures such as continuous verifications, identity-based segmentation, least privilege principle and automated context collection and response.</p><p>Container management tools like Kubernetes or service meshes like Istio have tens of thousands of successful installations. RESTful APIs and streaming have been in use for over twenty years. The risk profile of adopting a data mesh is comparable to adopting microservices. It is not new technology; it is a new way of approaching data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RUGjBDc7JAD33cmL" /><figcaption><strong>Example data mesh using Kubernetes</strong></figcaption></figure><h3>Direct communication between Domain Experts and Data Consumers</h3><p>Once parts of a business enjoy the benefit of data analytics, other parts will want to join in. Demand for new and more involved reports and analytics grows. Just as a small team of data engineers cannot understand all the sources of data in a company, they also cannot completely understand how the data is used. The demand for new and varied forms of data expands beyond the data team’s capability to understand the nuances of the data they provide to consumers. Errors in understanding data lead to errors in reports and or delays in generating reports.</p><p>A data mesh architecture helps avoid this problem by forcing domain experts to speak directly with consumers. It does this by having those who understand the data best be the owners of the data and be responsible for composing it into data products for others to consume in a self-service way. Unlike a small team of specialized data engineers struggling to keep up with ever increasing supply and demand for data, domain experts are best suited to understand consumer’s needs and build the data products that meet them.</p><h3>Start Small and Grow Your Data Mesh According to Demand</h3><p>A company can begin with a small data mesh of just a few nodes and see value almost immediately. Though a data mesh can be thought of as microservices for data, the reality is a little more complex than that. With the principles described in this article, you’ll be able to start your mesh small and let internal demand drive growth according to demand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bxPld8CerW5G6jzS" /><figcaption>Data Mesh adds business domains and data products as it shows value.</figcaption></figure><h3>Common Challenges When Adopting a Data Mesh</h3><p>Your company once prided itself as a place where data drives innovation, but as the company grows the reality seems different. Many symptoms of data-related problems loom on the horizon:</p><ul><li>organizational silos and lack of data sharing</li><li>no shared understanding of what data means outside the context of its business domain</li><li>incompatible technologies prevent gaining actionable insights</li><li>data is increasingly difficult to push through ETL pipelines</li><li>a growing demand for ad hoc queries and shadow data analytics</li></ul><p>Limited budget was used up in previous failed experiments with expensive data technologies. Any new solution will need to start small, prove its worth and scale as the company grows. The best solution for these problems would be an architecture that emphasizes democratization of data at the business domain level while accommodating different technologies and data analytic approaches.</p><p>A data mesh architecture may be the best hope for solving your data problems. A data mesh can start small and grow as needed, providing a budget-friendly option for proving value and then growing to meet your company’s needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*IU20JVVw1KFbyhdN" /><figcaption>Decentralized Data mesh topology showing relationship between data products and business domains.</figcaption></figure><p>A data mesh is a distributed approach to data management that views different datasets as domain-oriented “data products”. Each set of domain data products is managed by product owners and engineers with the best knowledge of the domain. The idea is to employ a distributed level of data ownership and responsibility sometimes lacking in centralized, monolithic architectures like data lakes. In many ways a data mesh architecture is similar to the microservice architectures commonly used throughout the industry.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8D6rfvYTS04m1gA0" /><figcaption>A more traditional monolithic data lake architecture.</figcaption></figure><p>Each business domain in a data mesh implements their own data products and is responsible for its own pipelines. The focus on domain-specific data products tends to avoid the tight coupling of ingestion, storage, transformation and consumption of data typical in traditional data architectures like data lakes.</p><p>Your company is eager to start enjoying the benefits of a data mesh but wants to avoid beginner mistakes. Below are ten common problems when moving to a data mesh architecture and how to avoid them.</p><h3>Follow DATSIS Principles</h3><p>DATSIS stands for Discoverable, Addressable, Trustworthy, Self-describing, Interoperable and Secure. Failure to implement any part of DATSIS could doom your data mesh.</p><ul><li><strong>Discoverable</strong> — consumers are able to research and identify data products produced by different domains. This is typically done with a centralized tool like a data catalog</li><li><strong>Addressable</strong> — like microservices, data products are accessible via unique address and standard protocol (REST, AMQP, possibly SQL)</li><li><strong>Trustworthy</strong> — domain owners provide high quality data products that are useful and accurate</li><li><strong>Self-describing </strong>— data product metadata provides enough information that consumers do not need to query domain experts. In other words, data products are self-describing</li><li><strong>Interoperable</strong> — data products must be consumable by other data products</li><li><strong>Secure</strong> — access to data products is automatically regulated through access policies and security standards. This security is built into each data product</li></ul><h3>Automatically Update Data Catalogs with every Release</h3><p>Data product discoverability is part of DATSIS and a key element of data meshes. Most data meshes employ a data catalog or other ad hoc mechanisms to make their data products discoverable. A data catalog can be used as an inventory of data products in a data mesh, most often using metadata to help organizations support data discovery and governance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o2OHs-B_ZqMynjDD" /><figcaption>A simple data mesh using <a href="https://azure.microsoft.com/en-us/services/purview/?&amp;ef_id=CjwKCAjwi8iXBhBeEiwAKbUofYpC80WdKg7WxfNRndZK7V2oF9lMlAJ15i8_Bp6hx7X1hfRVb7tQZBoCnGMQAvD_BwE:G:s&amp;OCID=AIDcmm5edswduu_SEM_CjwKCAjwi8iXBhBeEiwAKbUofYpC80WdKg7WxfNRndZK7V2oF9lMlAJ15i8_Bp6hx7X1hfRVb7tQZBoCnGMQAvD_BwE:G:s&amp;gclid=CjwKCAjwi8iXBhBeEiwAKbUofYpC80WdKg7WxfNRndZK7V2oF9lMlAJ15i8_Bp6hx7X1hfRVb7tQZBoCnGMQAvD_BwE#customer-stories">Azure Purview</a> as a data catalog.</figcaption></figure><p>Any mechanism used for discoverability must be kept up to date to protect the usefulness of the data mesh. Out-of-date documentation is often more damaging than no documentation.</p><p>For this reason, we recommend data meshes employ a docs-as-code scheme, where updating the data catalog is part of the code review checklist for every pull request. With each merged pull request updated meta data enters the DevOps pipeline and automatically updates the data catalog. Depending on the data catalog, it may be updated directly through API, pulling JSON files from an S3 bucket, or other methods.</p><h3>Invest in Automated Testing</h3><p>A data mesh is by definition a decentralized collection of data. An important issue is how best to ensure consistent quality across data products owned by different teams, that may not even be aware of one another.</p><p>Following these principles helps:</p><ul><li>Every domain team is responsible for the quality of their own data. The type of testing involved depends on the nature of that data and is decided upon by the team.</li><li>Take advantage of the fact the data mesh is read-only. This means that not only mock data can be tested but tests can often be run repeatedly against live data as well. Take advantage of time based reporting — test on historical data that is immutable makes for an easy test and detects things like data structures changing.</li><li>Run data quality tests against mock and live data. These tests can be plugged into developer laptops, CI/CD pipelines or live data accessed through specific data products or an orchestration layer. Typical data quality tests verify a value should contain values between 0–60, or alphanumeric values of a specific format, or that the start date of a project is at or before the end date. Test-driven design is another approach that can be used successfully in a data mesh.</li><li>Include business domain subject matter experts (SME’s) when designing your tests.</li><li>Include data consumers when designing your tests. Data meshes should be driven by data consumers and it is important to make sure your data products meet their needs. Otherwise, why build the mesh in the first place?</li><li>Use automated test frameworks that specialize in API testing. We recommend the Karate framework (<a href="https://github.com/intuit/karate">https://github.com/intuit/karate</a>). Other useful tools are:<br>- SoapUI: <a href="https://www.soapui.org/">https://www.soapui.org/</a><br>- Postman: <a href="https://www.getpostman.com/">https://www.getpostman.com/</a><br>- Apigee: <a href="https://cloud.google.com/apigee/">https://cloud.google.com/apigee/</a><br>- Rest-Assured: <a href="http://rest-assured.io/">http://rest-assured.io/</a><br>- Swagger: <a href="https://swagger.io/">https://swagger.io/</a><br>- Fiddler: <a href="https://www.telerik.com/fiddler">https://www.telerik.com/fiddler</a></li></ul><h3>To someone with a hammer, everything looks like a nail</h3><p>When people become very proficient with one set of tools, they tend to use those tools even in situations where they are not appropriate. Many companies struggle with scaling data analytics because they try to use their data infrastructure to solve every need for information. An architecture where ETL pipelines pump data into a data lake is in many ways monolithic and has a finite capacity to deliver value. It simply does not scale well. A data lake excels at ad hoc queries and computationally intensive operations, but the centralized nature of the lake can make it hard to include pipelines from every domain in the company.</p><p>On the other hand, the decentralized nature of a data mesh allows it to include data from an almost arbitrary number of domains. However, the drawback to the data mesh is that very computationally intensive operations can be time consuming. Use the right architecture to solve the right problems.</p><p>Politically you also need to recognize the value of your data engineers. They play an important role. If they don’t feel valuable, or if they feel their jobs are threatened by a data mesh, they will act against it — even though data mesh and data lake architectures can be complimentary.</p><h3>Data Mesh Requires Extra Work by Domain Teams</h3><p>In a data mesh, domain teams maintain ownership of their data and create data products that expose that data to the rest of the company. If an engineering team handles the data mesh work, their capacity for other engineering work will decrease — at least at the beginning.</p><p>However the alternative is often a tightly coupled data pipeline. Such a system is inherently fragile and changes to data at the application level can result in erroneous data being fed into data lakes, and subsequent defects in reports produced by data engineers. Troubleshooting these defects is time consuming and frustrating. When the source of the defect is found to be something like a change in a field type or the way a particular field is used there can be a lot of friction between the engineering team and data team.</p><h3>Tight Coupling Between Data Products</h3><p>The design influence of microservices on a data mesh is apparent in its flexible nature. A data mesh can expand and contract to match your data topology as it grows in some areas and shrinks in others. Different technologies like streaming can be used where needed and data products can scale up and down to meet demand.</p><p>As with microservices, tight coupling is the enemy of a highly functional data mesh. The independently deployable rule as applied to microservices also applies to data meshes; every data product on a mesh should be deployable at any time without making corresponding changes to other data products in the mesh. Adhering to the independently deployable rule in a data mesh often implies some versioning scheme applied to data products.</p><h3>Shadow Data Analytics and Mandates</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PsXCpMzqdA0ybQgz" /><figcaption>Stage One: This configuration is often successful with a small number of internal providers and consumers.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*o4o7xpJ-DawupgFL" /><figcaption>Stage Two: Both publishers and subscribers grow. Workload on the small data team increases. The architectural and organizational model does not scale.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*b9ZjWsKpZaxuefpM" /><figcaption>Stage Three: More providers and subscribers overwhelm pipelines. Consumers bypass approved pipelines and Shadow Data Analytics takes hold.</figcaption></figure><p>Many companies suffer when their current data architecture and data team have reached their scale limits. Growing delays when adding new ETL pipelines, generating new reports, and running ad hoc queries lead consumers to find their own sources of data. This is known as “shadow data analytics”.</p><p>Shadow data analytics is understandable. People need data to do their jobs. But the practice of shadow data analytics often bypasses any sort of data governance or data security. It also tends to result in erroneous use of data. It is obviously counterproductive.</p><p>When faced with shadow data analytics, one approach is to mandate all staff use the sanctioned data analytics system — or else. Mandates might be necessary for a short period of time, but they exact a toll in employee autonomy and initiative. A better approach is to build a comprehensive data architecture (often including data lakes) that is accurate and responsive to consumer’s needs so they won’t be tempted by shadow analytics at all. Such a system has the following characteristics:</p><ul><li>Follow DATSIS principles and the independently deployable rule as described above</li><li>Enforce SLA’s for minimum performance requirements for all data products</li><li>Employs a transparent process to request, schedule and implement new data products.</li></ul><h3>Accurately Evolve Data Products</h3><p>Data evolves as a company evolves, often in unpredictable ways. Changes often fall into two types:</p><ol><li>Changes in the domain structure of your company</li><li>Changes in the structure and nature of the data itself within each domain</li></ol><p>Data meshes should be built to adapt to these changes. Adding domains to a data mesh is simple: add data products, ensure they are discoverable in a data catalog or similar product, and build dashboards or other types of display as necessary.</p><p>Removing data products occurs less frequently and is a little more difficult. It is usually done manually. If another data product consumed the removed data product then it needs to be examined. Does it still make sense to expose the consuming data product to users? How are consumers of that data product notified about changes or complete removals of data products? The answers will be different for each company, and must be considered carefully.</p><h3>Accurately Version Data Products</h3><p>Data products will need to be versioned as data changes at your company, and users of that data product (including maintainers of dashboards) are notified about changes, both breaking and non-breaking. Consumed data products need to be managed like resources in Helm charts or artifacts in Maven Artifactory.</p><h3>Sync vs Async vs Pre-assembled Results</h3><p>If a data mesh uses synchronous REST calls to package the output from a few data products, chances are the performance will be acceptable. But if the data mesh is used for more in-depth analytics combining a larger number of data products (such as the analysis typically done by a data lake), it is easy to see how synchronous communication might become a performance issue.</p><p>So what are the options?</p><p>One would be a solution similar to a Command and Query Responsibility Segregation (CQRS) to pre-build and cache data results on a regular cadence. The cached results could be combined into a more complex data structure when the data product is run. This is an effective approach unless you literally require up to the moment results.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BowBTlGM-8YMRorZ" /><figcaption>Datamesh using cached data</figcaption></figure><p>Another approach is to break apart the operation into separate pieces that can be run asynchronously using a Asynchronous Request-Reply pattern. Using this pattern implies a few things:</p><ul><li>There are no ordering dependencies between the datasets you construct. In other words, if you concurrently build five datasets, the content of Dataset #2 cannot be dependent on the content of Dataset #1.</li><li>Most likely the caller will not receive an immediate response to their request. Instead, some sort of polling technique returns successfully only when all datasets are built and combined. If the dataset is very large, it may be stored somewhere and a link to the dataset provided to the user. This implies appropriate infrastructure and security is in place.</li></ul><p>A big advantage of the data mesh architecture is that it can start small and grow as demand grows. Early mistakes tend to be small mistakes and teams learn through experience how to manage increased demand for data while avoiding the political and technical pitfalls inherent in providing actionable data to business users. Data lakes and meshes are excellent solutions for different problems; it’s important to understand which is best for your employees and their data needs.</p><h3>Use the Right Tool for the Job</h3><p>Data lakes or data warehouse architecture could be right for the job. They are just not the right tool for <em>every</em> job — just as a data mesh is not the right tool for every job. In fact, it’s easy to see scenarios where a data mesh and data lake coexist and make each other stronger. Data lakes or warehouses require an investment of hundreds of thousands of dollars and hiring experienced data engineers before seeing any return on investment, but they do have a place in today’s data architectures.</p><p>A data mesh can be an excellent tool for on-demand reporting, analytics, and streaming. However, performance can be limited by slow queries in any node. Building the infrastructure to run ad-hoc queries against a data mesh would be difficult, although new techniques show promising results. Data lakes shine when they house large data sets that can be queried in computationally intensive ways. If this matches your needs, a data lake architecture may be right for you.</p><p>The following table provides a useful comparison between a Data Lake and Data Mesh architecture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6JF7PKqQFCBWqFkVwCpsA.png" /></figure><p>If you’d like to discuss the concepts included in this article, please reach out to the author at <a href="/service/mailto:mryan@kenzan.com">mryan@kenzan.com</a>. Michael Ryan is Managing Principal Consultant and Head of Architecture at Kenzan.</p><p><strong>Author linkedin page: </strong><a href="https://www.linkedin.com/in/michael-james-ryan/"><strong>https://www.linkedin.com/in/michael-james-ryan/</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e10a009dc7e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Software that Shouts the Language of your Business
By Michael Ryan, Head of Architecture…]]></title>
            <link>https://kenzanmedia.medium.com/building-software-that-shouts-the-language-of-your-business-by-michael-ryan-head-of-architecture-567a76757e58?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/567a76757e58</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[microservice-architecture]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Mon, 11 Jul 2022 16:34:24 GMT</pubDate>
            <atom:updated>2022-07-11T16:34:24.562Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Building Software that Shouts the Language of your Business<br></strong>By <a href="https://medium.com/u/b2540fecb619">Michael Ryan</a>, Head of Architecture and <a href="https://medium.com/u/2173880331a">Robin Morrison</a>, Managing Director of Kenzan</p><h3>Your Company Struggles</h3><p>Your company struggles to build quality software.</p><p>The problem is not staff — you have talented engineers, knowledgeable agile professionals and top business leadership. They are all paid at or above the market rate. Everyone is very motivated to succeed — and frustrated with lack of results.</p><p>Yet when engineers, agile professionals and business leaders work together they fail over and over again. Ask each group what the most important features of the software are and why they are not implemented correctly; they all answer as if they worked at different companies. They don’t even use the same language to describe the problem. Your company is stagnating as a result.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pyOXKQFOk_hAJcYEVw-6nA.jpeg" /></figure><h3>Your Software Disappoints</h3><blockquote><strong>“If you think good architecture is expensive, try bad architecture”</strong></blockquote><blockquote>- Brian Foote, Chairman/President/CEO at HUMBL Inc.</blockquote><p>Your software suffers from one or more of the following problems.</p><p><strong>Software can’t be updated to perform required business functions. </strong>Some of our clients struggle with software that was once acceptable but no longer meets current business needs:</p><ul><li>Manual entry of data or cumbersome workarounds are necessary to get customers through basic workflows.</li><li>Meeting new regulatory requirements or even adding new features require tedious manual workarounds by engineering or other staff.</li><li>Staff end up entering information customers could have entered for themselves if the software provided for it.</li><li>Attempts to incorporate new features either fail or can’t be attempted because engineering resources are fully occupied just keeping the software running.</li></ul><p><strong>Software poorly integrated into existing systems.</strong> Integration with existing systems can be difficult. The result is often unnecessary workarounds or poor performance. Symptoms include:</p><ul><li>Requiring customers to take unnecessary actions such as entering the same information multiple times in the same workflow.</li><li>Poor integration with existing systems slows the flow of actionable information to key decision makers.</li><li>Upgrades to one system require corresponding upgrades to multiple systems. Each upgrade needs to be intricately sequenced to accommodate a complex web of dependencies.</li></ul><p><strong>Software cannot be updated without introducing new defects.</strong> You have good engineers but, quarter by quarter, their performance degrades:</p><ul><li>It takes weeks to get even small changes or bug fixes through development and testing.</li><li>As a result the number of production deployments per quarter decreases. The <strong>size</strong> of each deployment grows correspondingly, increasing both the time and difficulty to test and the odds a defect is released into production.</li><li>With more code and more defects released with each production deployment, the percentage of deployments resulting in customer complaints and emergency hot fixes increases.</li><li>Because the amount of code released with each production deployment is increasing the time to investigate, fix and test production defects also increases.</li><li>The increase in production defects prompts management to increase the amount of time spent on testing, most often manual testing “just to be sure” the automated tests are running correctly. This further slows the deployment rate, increases the amount of code in each deployment, increases the odds of a production defect, and increases the time to fix that defect.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*33scb2UWtQh79IiOHIMG-Q.png" /></figure><p>This becomes a downward spiral. Dissatisfied customers don’t understand why your software can’t be made to work properly. They are aggravated by wasted time, expense and overall poor quality. Your customers are likely to switch providers if given the chance.</p><h3>Your Teams Fail to Deliver — or Even Understand One Another.</h3><h4>Why is all this happening?</h4><p>One problem is developers, product owners, and business people each have a different understanding of how the software actually works and what it is supposed to do.</p><p>Each group has their own name for particular software features and there is little shared knowledge or even language. <strong>Worse, each group doesn’t realize the extent to which they disagree with the other groups on what is most important to build or fix first.</strong> Each group not only thinks their perceptions are correct but those perceptions should be intuitively obvious to all.</p><p>When developers, product owners, or business people speak about the software, they use terms and language only understood by themselves. Listeners from other groups are left to translate into their own terms as best they can. Getting agreement on implementing even small changes is very difficult when no one even uses the same language.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*894H_K9oT4HtJwp_WGtjOQ.png" /></figure><h4>Talented team members but ineffective teams</h4><p>As a result engineering teams are unable to build essential features, repeated attempts to solve the same problem always end in failure, and adding new features or fixing defects is time consuming and error-prone. Every production release is followed by a wave of calls to customer support.</p><p>The problem is often not with your engineers, your agile professionals or business stakeholders. The problem is the way each group works with one another — a symptom of their lack of shared understanding about the business and the software it builds. They don’t speak the same language and the software reflects that.</p><h3>Domain-Driven Design Leads to Better Software</h3><p>You are not alone, and many of our clients have found themselves in similar situations. Kenzan has taken an industry-standard approach, Domain-Driven Design, and tailored it to solve exactly this sort of problem.</p><p>Domain-driven design can be a complex process. Kenzan has broken it down to a few critically important steps that produce rapid results.</p><h4>Bring domain experts and technologists together.</h4><p>“Domain experts” are people who know the business, the products and the customers. Domain experts know your core competency, what the customer needs and how that maps to what your software does.</p><p>Domain experts and the technologists who design and build the software need to be aligned as one team. In many companies software architecture is disconnected from the business. Domain experts do not understand the software — even in technology driven businesses. This is obvious when a business user speaks about software functionality using one set of terms and then a developer speaks about the same functionality using a completely different set of terms.</p><p>To bring domain experts and technologists together can be a lengthy process, but it always starts with the next step: building a common language.</p><h4>Build a common language.</h4><p>It is very hard for a team to fix a problem if they don’t even use the same terms. So our first step is to create a dictionary of agreed-upon terms so everyone speaks the same language. We call this dictionary of terms a “ubiquitous language”, meaning the same terms are used by everyone associated with the software.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L2xvMrnah0SeLucn78FJbA.png" /></figure><p>Simple misunderstandings can cause expensive software defects. For example, software that manages corporate sales contests and prizes might integrate with both the Sales and Finance departments. In this case the simple term “close” could refer to finalizing a sale, the end of a business quarter or when a sales contest concludes. Disambiguating the term “close” is critical to avoiding defects as well as having each department fully understand what the software is doing. Multiplying this example by dozens or hundreds of overloaded terms provides a glimpse into the problem many companies face.</p><p>The ubiquitous language is embedded in the software code as well as documentation. Software’s code must speak the language of the business — not the language of the engineers who write it. As staff comes and goes it will be the ubiquitous language encapsulated in code and documentation that results in continued understanding of the software and often continued culture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oswn-hAzeaXrqbma0Yma1g.png" /></figure><h4>Build a domain model of real world needs.</h4><p>Once everyone agrees to speak the same language a real world model of business needs can be created. We call this a Domain Model.</p><p>Domain models vary between two extremes:</p><ul><li><strong>Anemic models</strong> that lead to architectures with multi-purpose common components handling most of the logic and domain objects that end up being little more than POJO’s or the equivalent (simple data objects with getters and setters and little logic). Since there are no clear responsibility boundaries, logic related to any one domain is often scattered across multiple components.</li></ul><p>Anemic models fare poorly when mapped to distributed architectures like microservices. The result is often a “distributed monolith” that is worse than the application you started with.</p><ul><li><strong>Rich or robust models</strong> where domains are represented by self-contained components with a single business purpose that contain both the data and logic necessary to perform their function. Rich models tend to map well to distributed architectures like microservices.</li></ul><p>The Kenzan approach is to analyze, design and refactor only those domains that will provide the biggest return to our clients. We call these “Core” domains — domains that are fundamental to your company’s position in the marketplace that give it a critical edge over the competition.</p><p>“Generic” domains (domains that facilitate the operation of the business that can often be performed with off-the-shelf software — such as an invoicing system) or “Supporting” domains (domains that relate directly to core business functions but do not require your top engineering talent to build or maintain) are often not fully modeled and refactored.</p><blockquote><strong>“The design is the code, and the code is the design. The design is how it works.”</strong></blockquote><blockquote>-Vaughn Vernon, Implementing Domain-Driven Design</blockquote><h4>Map the domain model to software architecture.</h4><p>There are exceptions, but most often the target architecture is some form of microservices. In such an architecture each microservice has the following characteristics:</p><ul><li>A small but complete application in itself.</li><li>Is as decoupled from other microservices as possible.</li><li>Has a single business purpose.</li><li>The service’s single business task is meaningful to business users — there should be no services with only a technical or infrastructure purpose.</li><li>Has all the data and logic required to perform this business purpose.</li><li>Has a clear interface and dependencies so it runs independently of other services and an engineering team can maintain it independently of other engineering teams.</li></ul><p>There are well designed and poorly designed microservice architectures. A poorly designed microservice architecture is often worse than whatever architecture you started with.</p><p>To build a good microservice architecture it is important to accurately model the underlying domains. Unlike earlier modeling paradigms, Domain-Driven Design practitioners realized that accurately modeling an entire enterprise is theoretically possible but not practical.</p><p>The better approach is to break apart the larger domain model into smaller sections called “bounded contexts”. Bounded contexts often are drawn around functional areas of a company, for example a “sales” bounded context or a “shipping” bounded context. A group of bounded contexts are arranged in what is called a “Context Map”.</p><p>One of the interesting things about bounded contexts is they help determine how microservices communicate with each other and the granularity of information exchanged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KFLb5YY29V0BQtuZCSSzFQ.png" /></figure><p>For example, when a sale is completed communication between microservices <strong>within</strong> the sales bounded context tends to be synchronous and fine grained. A sales representative’s commissions need to be updated, territory sales numbers recalculated, pipeline information brought up to date, customer information modified. It’s possible to accomplish this through an asynchronous messaging scheme but messaging disparate pieces of information all related to one action can become cumbersome. Often it is easier and more direct to accomplish this with synchronous interactions between services.</p><p>On the other hand, when a sale is made communication <strong>between</strong> bounded contexts tends to be coarse-grained and asynchronous. In this case all the “shipping”, “inventory”, “finance” and other bounded contexts need to know is something like “10 widgets were sold on 12/01/22 for $150 each to customer X”. There is often no need to acknowledge receipt of the message. Once the message is received shipping proceeds to send customer X the 10 widgets, inventory decrements its totals by 10, finance records $1,500 in new revenue and other bounded contexts perform their own business tasks on the same information. We could accomplish this through synchronous interactions, but it would be slow and there is no need. It is easier and faster to post the message and let each subscriber act on the information as they need to.</p><p>As you can see, in this case going through the domain-driven design process has allowed for groupings of services that interact with each other in an optimal way, a way that accommodates future changes to your business model. Success in software and business is often won by those who adapt to change the best.</p><p><strong>Implementation: Building software that shouts the language of your business.</strong></p><p>Using the Context Map as a guide, your software is gradually altered to increasingly reflect the real world needs of your business while maintaining continuity of service.</p><p>It sounds easy but it is not. There is a lot of work and a lot of negotiation that goes into this process.</p><p>Domain modeling provides other benefits aside from well designed software that meets customer needs. These include:</p><ul><li>When a company knows what its most important tasks are it can assign the best engineers, agile professionals and product owners to those tasks.</li><li>There is less miscommunication between technical and non-technical staff. When everyone speaks the same ubiquitous language the shared understanding extends to front line engineers. The code they write uses the same terms and is so clear even business people can understand it. Engineers and business people use the same terms everywhere — no special terms are used by either group.</li><li>The same terminology carries forward as staff enter and leave the company. There is no drift in understanding as time passes.</li></ul><p>To be successful all staff must understand what the software <strong>needs to do </strong>as well as what the software<strong> does not need to do </strong>— and why. This becomes possible when your software is modeled on the real world needs of your business.</p><p>The end result is software that reflects the mental model of the business experts. The design is the code, and the code is the design. The design is simply how it works.</p><p>If you’d like to discuss the concepts included in this article, please reach out to the authors below:</p><p><strong>Michael Ryan<br></strong>Head of Architecture<br><a href="/service/mailto:mryan@kenzan.com">mryan@kenzan.com</a></p><p><strong>Robin Morrison<br></strong>Managing Director of Kenzan<br><a href="/service/mailto:rmorrison@kenzan.com">rmorrison@kenzan.com</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=567a76757e58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Seven Pillars of a Successful Cloud Environment: Security]]></title>
            <link>https://kenzanmedia.medium.com/the-seven-pillars-of-a-successful-cloud-environment-security-1a2c83e4d192?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/1a2c83e4d192</guid>
            <category><![CDATA[cloud-security]]></category>
            <category><![CDATA[it-security]]></category>
            <category><![CDATA[cloud-migration]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Thu, 29 Apr 2021 17:16:31 GMT</pubDate>
            <atom:updated>2021-04-29T17:16:31.442Z</atom:updated>
            <content:encoded><![CDATA[<h4>By <a href="https://medium.com/u/b2540fecb619">Michael Ryan</a>, Director of Engineering and <a href="https://medium.com/u/eeeff908b230">Andrew VanLoo</a>, Backend Developer III</h4><p>Many clients begin cloud migrations after hearing stories of increased up-time, reacting quickly to changing market demands, increased ability to attract the best and brightest candidates and substantial cost savings over their on-premises data center.</p><p>It sounds easy — just move assets to the cloud and the benefits will follow.</p><p>But gaining the benefits of cloud computing is not as easy as simply “lift &amp; shifting” applications from data center to a public cloud. A successful cloud environment is built on a solid foundation that extends and enhances your current infrastructure in a way that supports phased migration of assets without disruption or inconvenience to your users.</p><p>Unfortunately, many companies fail to build their hybrid cloud on a solid footing — and then pay the price later when they try to retrofit essential capabilities into a moving target.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZGS5U8-5-FWuoL1fv7D22g.jpeg" /></figure><p>Kenzan has guided many clients through successful cloud migrations. Along the way we have identified the seven pillars on which a successful cloud environment is built. Each pillar is important and none can be skipped.</p><p>The Seven Pillars are:</p><ol><li><strong>Infrastructure Security</strong></li><li>Identity &amp; Access Management</li><li>Governance</li><li>Observability</li><li>Agile Best Practices</li><li>DevSecOps</li><li>Everything-as-Code</li></ol><p>The interesting thing about the Seven Pillars is they are self-reinforcing. Effective security cannot be implemented without robust automation (everything-as-code). Automatic self-healing of infrastructure cannot take place without highly advanced observability. Identity cannot be the control plane of a modern cloud environment without a robust security infrastructure behind it. A cloud environment cannot quickly respond to changes in market demand without agile best practices or an effective DevSecOps practice. None of the above is possible without a robust governance posture that both provides guardrails against bad practices and encourages best practices.</p><p>This article is the first of a series on the Seven Pillars and will discuss Security.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CaMJczv4Xafd9CxiduUFIQ.jpeg" /></figure><h3><strong>Security: The Foundation of Everything</strong></h3><p>If your cloud environment cannot be made secure, there is little reason to invest more time or money. Security breaches not only impact individual users of your applications but can inflict reputational and monetary damage on your company. Many careers have been upended by failure to take security seriously.</p><p>Security has to be planned from the beginning and woven into all aspects of your cloud environment. It is critically important and hard to retrofit afterwards. Your applications can take advantage of all the latest technologies and techniques — but if they are not secure, they are not worth having.</p><h3><strong>Zero-Trust Security</strong></h3><p>For years security was based on a perimeter defense model. The basic idea is simple — a secure system should let authorized users pass through the perimeter while keeping malicious users outside the perimeter. If more security was needed a company could find ways to make the perimeter stronger (stricter password requirements) or add extra perimeter boundaries (firewalls on both sides of a jump server). The strategy was to either make the perimeter harder to breach or force an intruder to invest more time by having to breach multiple perimeter layers before accessing valuable resources.</p><p>At the heart of the perimeter model is the assumption a perimeter can be identified — a simple barrier between “us” and “them.” Such a perimeter may have been common in years past, but modern IT is no longer structured like that. Where is the perimeter when employees work from home, or connect to a corporate network with their personal devices? Where is the boundary when one company’s microservice system makes calls to another company’s API?</p><p>A changing world requires a new way of thinking about security. Kenzan recommends following a Zero Trust security philosophy. In traditional security models once a user passes through the perimeter they are trusted to be who they say they are. In a Zero Trust environment there is no trust — “verify then trust” is replaced by “always verify, trust no one.” No user is trusted ever, no matter who they are or how long they have been in the system.</p><p>Instead trust is re-generated with every interaction to an endpoint, server, or IP address. This is accomplished through techniques like multifactor authentication, IAM, behavioral analytics, encryption, micro-segmentation of virtual networks. All information is encrypted at rest and in transit. Only users who generate trust are capable of decrypting that information.</p><p>Zero-trust embraces context-based security. This takes into account a user’s past behavior as well as authentication and authorization when generating trust. As an example take a user who has access to sensitive documents but has never accessed them before. Suddenly that user starts accessing those documents. In this scenario the change in behavior might require a further generation of trust. This could be by using a card/token or external key through an authenticator application.</p><p>Zero-trust relies on technologies like distributed and automated mutual Transport Layer Security (mTLS) between every service; entity authorization run by Encrypted JSON Web Tokens (JWE) with verifiable and rejectable nonces; and a robust automation suite to detect and respond to threats to the network in a fine-grained fashion utilizing machine learning to track deviations in typical user or service behavior all mediated by an identity-aware proxy, such as Istio.</p><p>Zero Trust is not an academic theory. Google has its own implementation of zero-trust called BeyondCorp. It is considered state of the art and shared publicly here: <a href="https://cloud.google.com/beyondcorp">https://cloud.google.com/beyondcorp</a>. The goal of BeyondCorp was to create a network so secure employees can work from any location without the need for a traditional VPN.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Xkax2hWzL34t8LhgGyv1g.jpeg" /></figure><h3><strong>Identity-based Microsegmentation</strong></h3><p>Microsegmentation is a cornerstone of Zero Trust security. Microsegmentation is a practice focused on logically creating finely grained network segments and completely controlling traffic within and between those segments. Lateral traffic is avoided.</p><p>Virtual networking can be a complex topic, but the principles all center around reducing the attack surface accessible by an intruder. The attack surface is reduced by limiting internet access to internal resources, limiting internal resources access to the internet, and strictly controlling corporate resources’ access to each other. Any internal or external access is limited to what is specifically needed and nothing else.</p><p>A secure network topology often follows a hub and spoke model, which looks a little bit like a multifaceted bicycle wheel. All traffic enters through a central hub and depending on the request is funneled to one or more spokes. Communication between spokes is strictly limited. In this way any breach is restricted to one of the spokes and cannot spread.</p><p>Implementing point-to-point networking secured by mTLS also mitigates lateral movement across networks that is typically employed by hackers to irreparably breach networks. All of this secure topology is robustly and flexibly managed by network-as-code enabling threats to be detected; mitigated; and dealt with in a dynamic, distributed, and automated fashion.</p><p>There are several less desirable network topologies from a security perspective. For example, a mesh model where every application has access to every other application. In some situations, such as a microservice architecture, this topology might be necessary. In this case vulnerabilities are reduced by restricting the services any one service can access and requesting a new generation of trust at every interaction. Without these protections, once an intruder enters a true mesh topology they have access to a wide range of resources which nullifies many of the benefits of adopting Zero Trust over the traditional perimeter defense method.</p><p>Microservices are an example of where identity-based microsegmentation takes everything a step further. Instead of allowing access based on IP address or port, access is allowed depending on the workload context of the caller. In short, the caller’s identity determines access. For example, instead of using network addresses in a microservice system (which are often ephemeral) identity-based microsegmentation are enforced using Kubernetes pod identity. This simplifies security by allowing for unified security policies to protect VMs and containers across multi-cloud environments.</p><p>To summarize, building the virtual network right the first time is important. Tweaks will always be made as the architecture evolves, applications added and removed, and improvements implemented. But a poor network structure invites attacks, and a substantial reconstruction or repair of a poorly constructed complex network is very difficult and expensive. Often these repairs take place after a breach has been discovered and the resulting pressure makes the work even more difficult.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mM70rr8vZySNPiIK9jfk6w.jpeg" /></figure><h3><strong>Security Automation</strong></h3><p>Automating the creation and maintenance of infrastructure and provisioning of resources is not often discussed as part of a security practice. However, Kenzan believes automation is the cornerstone of an effective security posture. This doesn’t mean simply adding automated security tools, although these are important. Kenzan advocates automating your infrastructure and development processes as well as testing and security checks.</p><p>In a number of industries repetitive manual tasks end up being a security risk. Repetitive manual tasks are tedious and boring. When humans engage in tedious and boring tasks they tend to make mistakes. In the right scenario these mistakes end up being a security risk. This is why TSA luggage screeners are rotated at airports — looking at luggage is boring and repetitive and after a while screeners make mistakes and miss potentially dangerous items.</p><p>These benefits can be enhanced in synergistic ways with everything-as-code(EaC) by implementing techniques such as regular and automated network defense, key management, and regular mulching of systems. Automated network defense can be used to destroy private keys stored in random access memory (RAM) when breaches are suspected which can be in-turn replaced by an automated key management system to renew and refresh existing keys. An additional layer of security is gained by EaC through mulching all server instances in the entire infrastructure on a regular basis to destroy persistent threats such as root-kits and other advanced persistent threats.</p><p>The 2017 hack of Equifax is a good example of a manual practice being a security vulnerability. This breach impacted 148 million people worldwide and was caused by one low level technician failing to manually update Apache Struts to fix a vulnerability found months before. As a result hackers were able to rifle through the company’s systems by obtaining an unencrypted file of passwords on one server and using them to gain access to more than 48 databases containing unencrypted consumer credit data. There were layers of poor security practices at Equifax, but the fact remains that had updates to critical systems been automated this hack may not have occurred at all.</p><p>By following these Seven Pillars from the outset of your cloud migration, you’ll lay a solid foundation for feature enhancements, agility, and scalability of your core business domains.</p><p>As a reminder, the Seven Pillars are:</p><ol><li><strong>Infrastructure Security</strong></li><li><strong>Identity &amp; Access Management</strong></li><li><strong>Governance</strong></li><li><strong>Observability</strong></li><li><strong>Agile Best Practices</strong></li><li><strong>DevSecOps</strong></li><li><strong>Everything-as-Code</strong></li></ol><p>Infrastructure security and Identity &amp; Access Management are two inseparable pieces of an overall security posture. The next article in this series will dive into the second of our seven pillars: Identity &amp; Access Management.</p><p>Subscribe to Kenzan to keep up with the next in our Seven Pillars series.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1a2c83e4d192" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservice Design Patterns: Single Database Per Service]]></title>
            <link>https://kenzanmedia.medium.com/microservice-design-patterns-single-database-per-service-bfa36728e862?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfa36728e862</guid>
            <category><![CDATA[microservices-platform]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[microservices-application]]></category>
            <category><![CDATA[cloud-migration]]></category>
            <category><![CDATA[microservices-pattern]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Wed, 14 Apr 2021 13:40:11 GMT</pubDate>
            <atom:updated>2021-04-14T13:40:11.957Z</atom:updated>
            <content:encoded><![CDATA[<h4>By <a href="https://medium.com/u/b2540fecb619">Michael Ryan</a>, Director of Engineering</h4><p>This is the first of a series of articles on Microservice Design Patterns. The articles center around the growth of a fictional video streaming service, Day After Sports. Day After Sports streams college and professional sports games in the days after they are played — if someone misses a game they can still watch it “the day after” on Day After Sports.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*LpBjQEPryn0t8Bdp85axdQ.jpeg" /></figure><p><strong>The Beginning</strong></p><p>When Day After Sports began with a founder and two engineers they needed to quickly launch a web portal to get their business up and running. The architecture needed to be easy to set up, easy for a small group of engineers to deploy and maintain, and they needed to get it done quickly so they could prove they had a viable business model before investing in more expensive infrastructure and processes.</p><p>Faced with these factors, they chose a monolithic architecture. Monoliths get a bad name but they are often a good architecture for a startup — easy to get up and running and easy for a very small group of engineers to work on, deploy and maintain. They don’t have the overhead associated with more popular cloud architectures like microservices and let a start up prove they have a viable business model before investing in more expensive infrastructure and processes.</p><p>But the cat will mew and every dog will have his day. The monolithic architecture that worked well for Day After Sports in their early startup days is now showing wear. As Day After Sports became popular the increased traffic was making it difficult and expensive to scale by simply running multiple copies of the monolith. As the monolith grew in complexity it became increasingly difficult to add and test new features. Deployment frequency decreased. The architecture that helped make Day After Sports a viable company was now an impediment to future growth.</p><p>The engineers met with the founder and discussed these limitations. After considering these issues, they decided to migrate from the monolith to a more flexible microservices architecture. When coupled with DevSecOps practices and cloud technologies like auto-scaling, microservices enable an organization to almost arbitrarily scale their engineering efforts while increasing the productivity and agility of every team.</p><p>You’ve just been hired by Day After Sports as an architect to guide the migration to a microservice architecture. You’re assigned to a new team that is just beginning to work with microservices. The team is composed of newer employees like yourself along with several engineers who created (and still favor) the monolith. After a week of domain modeling exercises, the team is finally ready to start building microservices. They sit at the conference table and start talking.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XOoWUPbIxIOJA0tHjh873w.jpeg" /></figure><p><strong>Problem #1: Handling Data</strong></p><p>Almost immediately the topic of how best to handle data comes up. Sharing data across microservices has some appeal — mostly that data is stored once in a single location and all services have access to a single source of truth. On the other hand, if there are multiple data stores, they might get out of sync with each other — that sounds like chaos! Talk of “eventual consistency” between services just seems like an excuse for sloppy coding. The employees who have been with the company the longest favor a shared data model.</p><p>In response you ask what happens if the needs of one microservice evolve differently from the others? And what if changes are made to the central database? Wouldn’t that mean many microservices using that database might have to be updated all at once?</p><p>You share your painful experiences of what that kind of coupling can do to a microservice system. You mention the “Independently Deployable Rule” — that at any moment in time each microservice must be deployable by itself, without having to make corresponding deployments of other microservices. This helps ensure microservices can be developed and scaled independently, and that every microservice has just one reason to change.</p><p>Some team members think following the Independently Deployable Rule would be a lot of work for little gain. You respond by telling war stories of afternoons spent at a white board disentangling complicated dependency webs before figuring out which services could be deployed in what order.</p><p>Although the best solution is not obvious, the team agrees to follow the “Single Database Per Service Pattern” — but with a caveat.</p><p><strong>Single Database Per Service Pattern</strong></p><ul><li>Design a single database per service</li><li>The database is private to the microservice. Data is only accessed through the microservice API.</li><li>Variants of this pattern for relational databases include private-tables-per-service, schema-per-service, or database-server-per-service. Regardless of the details, any solution should prevent access from other service tables and keep each service’s data private.</li><li>Keep scalability, high availability and disaster recovery requirements in mind.</li></ul><p>You’re happy the team is following your advice, and even happier they proposed a common sense exception to the Single Database Per Service pattern. The solution helps ensure the success of the microservice architecture while also taking into account the intricacies of moving from a monolithic to microservice architecture. Everyone on the team contributed, and everyone is happy with the outcome. The team is coming together.</p><p><strong>The caveat: When it makes sense to use a Shared Database per Service Pattern</strong></p><p>In greenfield development, design a single database per service.</p><p>When decomposing monoliths:</p><ul><li>It often takes several attempts to find the right level of granularity for microservices.</li><li>Decomposing code is much easier than decomposing data. Decomposing data can be very difficult. You only want to do this once if possible.</li><li>Consider using the Shared Database pattern when decomposing a monolith — but only until the code is stable. When the code is stable, decompose the database and move to a Single Database Per Service pattern.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bcAvK5YExxOxP_BmsO_8xg.jpeg" /></figure><p>Adopting a microservice architecture comes with technical and non-technical dangers. These pro tips hopefully provide sound advice in addressing them:</p><p><strong>Pro tip #1: Budget issues</strong>. Every company has competing budget priorities. When you deploy your services with a shared database the system will be “working” — and probably working better than the old monolithic architecture did. Business owners will be happy with the improvements and also happy to spend your remaining budget elsewhere before you can decompose your data. You run the risk of ending up with the dreaded <em>Distributed Monolith.</em></p><p><strong>Pro tip #2: Avoid <em>Distributed Monoliths</em>.</strong> Microservices are meant to provide a company with the highest degree of flexibility in building new features and responding to customer demand. This is one reason why it is important each service be independently deployable. On the other hand, even the smallest change to a monolith requires testing and deploying the entire codebase — a time consuming and error-prone endeavor.</p><p>A Distributed Monolith is created by tight coupling between microservices. Even though code is distributed across multiple services, the system acts like a monolith in that a change to any one service requires deploying all or nearly all the other services. Distributed Monoliths couple the complexity inherent in microservices (different code bases, different build pipelines and deployment models) with the inflexibility of a Monolith. A Distributed Monolith is literally the worst of both worlds.</p><p><strong>Pro Tip #3: Use Allow Lists. </strong>Microservices interact with each other through defined APIs and communication protocols. As long as a service adheres to these standards, everything else becomes an implementation detail. A team is free to use the language, database, development processes and even DevOps pipelines of their choice.</p><p>This freedom is very valuable and a large benefit of microservice architecture. Left unchecked, this freedom can become a maintenance nightmare as each team implements their own favorite solution to every problem.</p><p>Many companies solve this problem by maintaining an allowed list of approved tools in each category. For example, MySQL or MariaDB for relational databases, Mongo or Couchbase for NoSQL solutions, H2 and Redis for in-memory DB, etc.</p><p><strong>Pro Tip #4: Domain Modeling is critical to your success. </strong>A<strong> </strong>single<strong> </strong>microservice is like a neuron in the human brain — interesting in itself, but the real magic happens when neurons and microservices act in concert to produce thought or a scalable, self-healing application.</p><p>Neurons communicate with one another in identifiable patterns that are optimized for human cognition. Like neurons, microservices also have optimal communication patterns that are critical to an application’s performance and success. Services <strong>within</strong> a single domain often communicate better with synchronous communication patterns like REST. Communication <strong>between</strong> domains is often better accomplished through asynchronous eventing schemes.</p><p>Building your microservice architecture and communication patterns to mirror bounded contexts is critical to your success. However, getting domain structures correct can be a difficult process.</p><p>Kenzan conducts the Domain Modeling process as workshops between technical and business teams — based on Vaughn Vernon’s domain-driven-design.</p><p>Stay tuned for our next article: the Strangler Pattern. The Strangler Pattern helps you avoid big bang transitions and reduce risk by gradually evolving your architecture from monolith to microservices.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfa36728e862" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Five Overlooked Tips for Avoiding Cloud Migration Failure]]></title>
            <link>https://kenzanmedia.medium.com/five-overlooked-tips-for-avoiding-cloud-migration-failure-c0c42bc7d3d7?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0c42bc7d3d7</guid>
            <category><![CDATA[cloud-migration]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[agile-transformation]]></category>
            <category><![CDATA[cloud-consulting]]></category>
            <category><![CDATA[ways-of-working]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Tue, 06 Apr 2021 21:23:53 GMT</pubDate>
            <atom:updated>2021-04-06T21:34:10.980Z</atom:updated>
            <content:encoded><![CDATA[<h3>Five Overlooked Tips for Avoiding Cloud Migration Failure: How to Gain Buy-in from Employees and Set Realistic Expectations for Stakeholders</h3><h4>By Robin Morrison, Head of Agile Solutions and <a href="https://medium.com/u/b2540fecb619">Michael Ryan</a>, Director of Engineering</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fJh5JzFnhsihDe_Pr3WndA.jpeg" /></figure><p>In a hurry to get to the cloud? Here’s what you need to keep in mind:</p><ul><li><strong>Tip 1: Gain momentum by addressing others’ points of view up front</strong></li><li><strong>Tip 2: Paint and communicate a vision for the future</strong></li><li><strong>Tip 3: Proactively manage expectations of business stakeholders</strong></li><li><strong>Tip 4: Integrate DevSecOps into your structure</strong></li><li><strong>Tip 5: Adopt agile now — even before cloud migration</strong></li></ul><p>Cloud migrations often pose daunting technical challenges, but the work doesn’t end there. Lack of attention to organizational and political considerations can also lead to suboptimal outcomes or or worse — outright failures.</p><p>At Kenzan, we work with company leaders who are eager to forge ahead to the cloud. However, there are choices companies make that can cause a cloud migration to fail before it ever gets off the ground. Here are some tips we’ve learned along that way that will help you ensure that your cloud migration takes off.</p><h3><strong>Tip One: Everyone is Not as Excited as You are About Adopting Cloud</strong></h3><p>To you, moving to the cloud means a bright future where enhanced organizational agility and superior quality let you win in the marketplace, free up money for new investments, and attract the best engineers in today’s tough labor market.</p><p>Unfortunately, not everyone will share your vision or your enthusiasm. Many will worry their day-to-day jobs will change or that they don’t have the skills and knowledge to handle what’s coming. Some will fear for their jobs and be tempted to slow walk or even sabotage your efforts. At the very least, cloud journeys transform the employee experience across the board, promising a radically different work environment for testers, developers, and managers. This can be jarring.</p><p>You can help make sure your vision becomes reality by having and communicating empathy for employees, finance leaders and other stakeholders. Take the time to understand their concerns so that you can address them upfront and sincerely.</p><ul><li>Communicate early and often about training programs for all affected roles.</li><li>Emphasize that cloud technologies often result in better application performance and almost no downtime — which also means no late nights or weekend work trying to bring up systems that have crashed.</li><li>Stress how learning new technologies make employees more valuable in the marketplace.</li></ul><h3><strong>Tip Two: Paint a Vision for the Future that Includes Benefits to the Company AND the Employees</strong></h3><p>For your vision to become a reality, you have to communicate it first. Communicate your vision for the cloud widely and often. Just as importantly, communicate in a way that helps everyone see how they can help to achieve — and benefit from — the cloud journey.</p><ul><li>Describe how, when managing a public cloud rather than a virtualized data center, day-to-day work will change for employees — but it will be something exciting for them and their careers.</li><li>Talk about new roles that will be needed, like SRE (Site Reliability Engineering).</li><li>Ensure the cloud journey plan includes skill and role development training, and share widely that skills training is part of the cloud journey plan.</li></ul><p>It’s crucial to back up your vision with concrete plans. Be armed with case studies and testimonials from engineers at other companies about how cloud migration has helped them learn new skills and improve their day-to-day work life. Honestly assess your team’s current skill sets, and lay out a detailed learning path for them. Identify the most tedious parts of their current workday and then show how cloud technology can eliminate them.</p><p>After these detailed training plans are developed, communicate them in multiple places. Discuss the training plans in All Hands meetings, and provide guidance on how managers can communicate the details in smaller team meetings and one-on-ones. Make sure to address how managers and employees can plan to sign up and participate in the training to make this feel real for everyone.</p><h3><strong>Tip Three — Proactively Manage Expectations of Business Stakeholders</strong></h3><p>In their excitement, company leadership can sometimes exaggerate expectations of a fast return on investment. The cloud transformation may even have been sold to senior management as a “quick win” with little risk and massive financial gain. Everyone assumes there will be radical savings in going to the cloud. The public cloud providers themselves emphasize savings in their marketing materials. You can and should save costs — but to do so you must implement cloud computing best practices across the business.</p><p>Ensure your transformation lasts longer than a quarter or two by explaining to business stakeholders the true scope of additional change and work required. Also explain that there are many more benefits to a cloud migration than just saving money. The ability to rapidly pivot to meet changing customer demands, improved quality and uptime of existing workloads, the financial benefits of operating expenses vs capital expenses, and the opportunity to recruit top technical talent are all widely-experienced benefits of cloud migrations.</p><ul><li>Help VPs and business owners understand that simply moving workloads to the cloud will not automatically save money or achieve improved velocity. Changes in architecture and engineering practices will likely be required to achieve the full benefit of cloud technologies.</li><li>Help business stakeholders understand the difference between the various paths to cloud: <br><strong>Rehost</strong> means doing a “lift and shift” now and modernizing later. This strategy may result in minimal saves, or no savings at all, because existing applications haven’t been architected to truly take advantage of the cloud. Lift and shift efforts are best used as a precursor for future migration efforts.<br><strong>Re-factor / Re-architect</strong> means redesigning the architecture and code to build a cloud-native application. In this approach, you are essentially rewriting all or part of your application. An example would be moving from a monolithic application to a microservices architecture that can more easily take advantage of the cloud.<br><strong>Re-platform</strong> (sometimes referred to as “lift, tinker, and shift.”) means moving from on-premises to cloud with only modest enhancements to the application. These enhancements can include things like making specific pieces of your application more horizontally scalable.</li></ul><p>Some types of workloads provide more opportunities for savings than others. The cloud lets you increase capacity to meet times of peak demand and then scale down when demand lessens — this is where cost savings can be found. If a workload experiences constant load, then there are fewer opportunities for savings.</p><p>Successfully scaling up and down to meet changes in demand often require changes to an application’s architecture. We typically find that a microservice architecture is often appropriate in these circumstances.</p><h3><strong>Tip Four: Integrate DevSecOps into your Engineering Processes</strong></h3><p>Enable teams to move faster in the cloud by building and integrating DevSecOps into your cloud pipeline. DevSecOps is not a role. Rather, it is a set of practices built on a philosophy of integrating security practices within the DevOps process itself. “Zero trust” security principles are a highly recommended offshoot of DevSecOps.</p><ul><li>Beacheading is important. Trial and error can be expensive. You’ll need an initial team who understands the cloud to develop best practices and implement a good pipeline. Make sure each successive round of teams who join the migration know how to leverage it.</li><li>Implement devops processes by organizing your teams in a way that testing and deploying so that their work can be fully automated. Engineering time spent on wonky, one-off manual processes is time taken away from developing new features, infrastructure, and automations. This sort of work is de-motivating and frustrating for engineers.</li><li>What your organization receives for investing in DevSecOps is the ability to quickly respond to customer demand by rapidly and securely making changes to your infrastructure and applications.</li><li>Just as important as financial and competitive considerations is the ability to recruit top technical talent. Most technology workers want to work on the cloud! These skills are relevant to building their career. Offering work on cloud-native applications is a big recruiting tool if you want to attract top talent to your company.</li></ul><h3><strong>Tip Five: Adopt Agile Now, Even Before Cloud Migration</strong></h3><p>IF you’re not Agile today, begin your Agile Transformation now.</p><p>Migrating to the cloud requires different processes than simply moving a data center to another location. You will not be able to exploit your new ability to deploy faster and improve time to market without also adopting an Agile workflow. Also, keep in mind that Agile methodologies require new training, processes, and transparency into work that may be just as much an object of uncertainty for employees as the cloud itself. So if you aren’t Agile already, start here!</p><p>Migrations benefit from having a solid and detailed plan, and most migrations follow a similar path. But in our experience, migration programs benefit from Scrum and other Agile methods. Cloud migrations have similar complexities compared to new software development — where seemingly simple applications become more complex, dependencies need to be managed, and close collaboration with business owners and end users is necessary. Most migrations experience frequent pivots and changes to the original plan. Constant focus on continuous improvement and supporting teams by removing impediments is as valuable to cloud migrations as it is to new software development.</p><h3><strong>You don’t have to learn through trial and error.</strong></h3><p>Just like with wheels, there’s no need to reinvent the cloud journey on your own. A trusted cloud consultant can help guide you through the myriad people and process considerations of your cloud migration. Having an experienced consultant along on the journey will help you gain the most from your cloud investment and ensure you have the organizational-readiness needed to capitalize on your newfound agility and scalability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0c42bc7d3d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Going to the Gemba in Software and Product Development]]></title>
            <link>https://kenzanmedia.medium.com/going-to-the-gemba-in-software-and-product-development-68f496c4ff05?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/68f496c4ff05</guid>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[agile-solutions]]></category>
            <category><![CDATA[value-stream-mapping]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[product-development]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Thu, 11 Feb 2021 18:21:47 GMT</pubDate>
            <atom:updated>2021-02-11T18:53:33.660Z</atom:updated>
            <content:encoded><![CDATA[<h4>By Robin Morrison, Head of Agile Solutions</h4><p>It is often said that software development and knowledge work is invisible work.</p><p>But as a leader, if you do not see it — how can you improve it? “Going to the Gemba” is one method.</p><p>As an agile solutions consultant, I help solve problems in technology-focused companies by looking for ways process change can positively impact an organization and its people. I have the privilege of working with clients in multiple industries, across the globe. I use both Agile and Lean techniques when I work with technology leaders to improve the quality and speed of their software development life cycle (SDLC), and often utilize Gemba Walks to provide targeted recommendations.</p><p>There is a wealth of information about how to conduct a Gemba Walk in manufacturing, but comparatively little is published about how to do one in the software industry. At Kenzan, we have developed techniques to help ‘see’ the invisible work in technology enterprises, and I will share some guidance here for you to leverage.</p><p>Gemba is a Japanese word for the “real place” — the place where the value-creating work actually occurs. To understand the issues that affect a process, it is critical to go to the gemba and see what is actually happening. James Womack provides inspiring and detailed guidance on this important management method in his book <em>Gemba Walks</em>. Taiichi Ohno, who is considered to be the father of the Toyota Production System is credited with originating the technique and his quote epitomizes the methodology: “Go see, Ask why, Show respect.”</p><p>When ‘outside’ people who don’t live in the process — including managers who don’t do the day-to-day work — intentionally and directly study a work environment, they can often start to ‘see’ the causes for performance problems that would otherwise go unnoticed.</p><p>In a Gemba Walk, leaders visit the work area to glean first-hand knowledge regarding:</p><p>• How products are built</p><p>• How services are provided</p><p>• Current challenges</p><p>• Opportunities for improvement</p><p>The goal of a Gemba Walk is to examine the current state of a particular process by observing it, in action, where it occurs. This aim is narrow, focused, and very specific, yet its purpose is to enable leaders to have a holistic view on how to create improvements across the full value stream. You will be trying to uncover how valuable, available, adequate, flexible, and waste-free each process is, and whether value flows smoothly from one step to the next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*nRunzYxSGILv9uppaybt6g.jpeg" /><figcaption>Robin building an end-to-end map of a client’s value stream before walking the Gemba</figcaption></figure><p>We recommend that you outline a high-level blueprint of the value stream from customer request to the delivery of value. Identify the manager for each area to work with in order to identify and select employees who perform the work in each area to observe.</p><p>When scheduling, try to schedule the Gemba Walks in the order of the value stream OR the backwards order of the value stream. It is not as impactful to do the visits out of order or alone. Your goal should be to optimize the full value stream.</p><p>The Gemba should be viewed in the actual work environment. For example — if people enter forms, observe them entering forms; if they are coding, observe them developing; if key meetings take place, observe their meetings. Unlike a manufacturing line this means your Gemba Walk sessions may need to take place over several days as opposed to all in one day.</p><p>Who should attend the Gemba? In addition to you (or consultants such as Kenzan), other managers who are in the value stream may wish to attend the Gemba Walk. Ideally it is important for the leadership team of a value stream to know the work well. In traditional manufacturing value streams it made sense for the full management team to walk down the manufacturing line. However, in knowledge work, it can be very disconcerting for the employees to have a large group of people observing a person or a team. Therefore, we recommend no more than three people participate.</p><p>You will ask in-depth questions about the process being observed to get a high-level understanding of what is being done to transform an input into an output. At <a href="https://www.kenzan.com/our-work">Kenzan</a>, we prepare specific questions designed to gain insight into the problem we are being asked to help resolve.</p><p>If you are doing your Gemba Walk remotely, be sure to identify a VC tool that will enable the person you are observing to be able to see your face clearly and prepare the participant that you will be asking him or her to screen-share during your session. Remote Gemba Walks can be very effective if they are prepared adequately in advance. One example that we experienced was when we conducted a remote Gemba with a software engineer. We prepared him in advance that we would want to see his entire work screen so that he would not be caught off guard. As a result, we could see the engineer was interrupted multiple times by numerous people with messages sent in all capital letters through a messaging app that stated an urgent issue needed to be addressed immediately. The multiple interruptions made him unable to focus on addressing the actual issue. We also observed that the tracking for all work was in his email, not through a ticketing tool, so he had to sort through lengthy emails for the needed documentation and history. We respectfully paused our Gemba so that he was not distracted by us. The point is that these observations would not have been noticed remotely if we were only talking to the person about his work. (All the types of wastes noticed during this short observation are for another post).</p><p>Preparing for going to the Gemba:</p><ul><li>Ensure communication has been provided to employees, most likely through their managers about your plan. It is important employees understand the objective and the spirit of the visit.</li><li>Prepare the questions you will want to ask and a format for taking notes.</li><li>As a pair or triad — establish roles: who will ask questions and take notes, will you alternate asking questions, will one person lead, etc.</li><li>If there are significant time zone challenges, respect the employee’s time zone over your own.</li><li>Ensure your mindset is to observe and study, not to provide suggestions and demonstrate your knowledge. You are seeking their knowledge. Be humble.</li><li>Read and study all notes, details and documents about the Gemba process you are visiting before you arrive.</li><li>If you are going in person, you will likely end up sitting in people’s cubicles. Limit the items you plan to bring so that you do not overwhelm the person’s personal work space.</li></ul><p>Plan to take notes manually so that you do not have a computer barrier between you and the person you are interviewing and observing. If you are in a remote meeting this will help you be able to focus on the employee’s face and maintain eye contact. People will warm up more easily when you are listening and asking follow-up questions as opposed sitting behind a computer monitor or looking away and typing loudly. Err on the side of listening rather than capturing detailed notes. If you feel that the rapport is ok, it may be absolutely fine for one of you to take notes on your computer to be faster/more complete and still have the people you are visiting be open and honest with you. However, plan on not taking notes on your computer and build in time to write detailed notes after the meeting when your mind is fresh.</p><p>When you open the Gemba session, introduce yourself and why you are there. Remember that this is a very awkward experience for most people. Do everything you can to make this as natural as possible. Work hard to be friendly, establish rapport, and build trust. Be empathetic. Explain why you are there and the goals and benefits you are hoping to be able to support (without making any promises). People may be worried you are judging them or evaluating the importance of their job — so by exuding the intent of the Gemba Walk is to understand the full system and how it operates holistically — not evaluating any one person’s performance — you will put them at ease and enjoy the benefits of gaining deep insights that will help you improve the way work is done at your company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M0fz0cP__9AFSq0iTWML-g.jpeg" /><figcaption>Robin Morrison, Head of Agile Solutions</figcaption></figure><p><em>My goal is to be a thoughtful, fearless leader that disrupts non-value producing activities and recreates a system focused on creating value.</em></p><p><em>I have a pragmatic and joyful approach to:</em></p><ul><li><em>Rapidly redesign the way work is done to create the most value for the customer.</em></li><li><em>Solve big problems by looking at the way process change can be impactful to an organization and its people</em></li><li><em>Redesign the framework companies use to revolutionize their business</em></li></ul><p><em>As a leader of my team, I provide clarity of purpose, and continual coaching and skill growth so that my team is professionally challenged and supported so they can make an impact.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68f496c4ff05" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Found in Translation]]></title>
            <link>https://kenzanmedia.medium.com/found-in-translation-a6381ce79e05?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6381ce79e05</guid>
            <category><![CDATA[esl-writers]]></category>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[international-business]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Tue, 19 Jan 2021 18:43:01 GMT</pubDate>
            <atom:updated>2021-01-19T18:43:01.258Z</atom:updated>
            <content:encoded><![CDATA[<p>by <a href="https://medium.com/u/b52b5703cd1c">Mark Anthony</a>, Senior Technical Writer</p><p>At Kenzan and its parent company Amdocs, I work every day with cloud architects, software developers, and other technology experts who specialize in digital transformation. As a technical writer, my job is to make sure the amazing solutions our team members design come across clearly to our clients and with full impact.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gXqIRJP4xm6KjUc5R0lHiA.jpeg" /><figcaption>Mark Anthony in his home state of Colorado, USA</figcaption></figure><p>More and more these days, our teams and clients are globally distributed. So I often find myself working with both readers and writers for whom English is a Second Language (ESL). I also have to think about making sure the documents we create can be easily translated into other languages. To stay effective in my role, I knew I needed to sharpen my skills in writing for ESL readers. I also needed to be able to write with translation in mind. What I didn’t realize is how working on these skills would help me become a better writer in my own primary language.</p><h3>Keeping it Simple</h3><p><em>Above all, you don’t want your writing to be unclear.</em></p><p>Wait, did you just stumble on that line? Imagine what this sentence might be like for an ESL reader, let alone a machine translation program just trying to make it the end of its algorithm. Double negatives can be difficult to parse and cause confusion for your ESL (or computer) audience. Instead, let’s keep it positive and say: <em>Above all, you want your writing to be clear</em>.</p><p>Great! So what are some other ways to ensure that?</p><p>Well, for one, you can avoid vague pronoun references like the one in the preceding sentence. What does the word <em>that</em> refer to? ESL readers might find it difficult to go back and find the right noun that the pronoun references. Let’s ask instead: <em>What are some other ways to ensure clear writing</em>? Replacing a pronoun with a noun might make you feel like you’re repeating the obvious. But in technical writing, there’s no such thing as being too obvious.</p><p>Finally, try to keep your sentences as short as possible. (20 words or less is a great goal, though longer is fine if your structure is clear.) Short sentences give readers more chances to take a breath and process what they’ve read. You’ll also accelerate any translation work. That’s because simple, grammatical sentences are easier for both machine and human translators to process. <strong>Recently, we were able to save a client thousands of dollars on the cost of translating document deliverables into Japanese.</strong> We achieved these savings just by applying the simple techniques outlined above.</p><h3>Many Authors, One Voice</h3><p>For another recent project, we took content composed by multiple writers in the United States, Israel, India, and Mexico, and collated it into a single report. Naturally, these authors represented an array of backgrounds and writing styles. However, for clarity, the document needed to look like the work of one author. What’s more, the final report was to be presented in Hebrew!</p><p>As humans, we all like to put our mark on things (graffiti on buildings, flags on moons). When it comes to writing for ESL audiences, though, it’s better to be a bit more humble. Are you tempted to use erudite terminology to elucidate a particular hypothesis? You’re better off choosing the smallest word that will make your point. You might feel like you’re losing some of your personal flair. But the fact is, virtually all of your stylistic efforts will be lost in the process of translation anyway. So it’s better to write simply and focus on getting your message across. (You can save the fancy prose for that novel you’ve got in a drawer.)</p><p>By applying our simple writing techniques, we removed style variability and eased the translation effort. As a result, we were able to meet the challenge and present our client with a clear, cohesive report that spoke in two languages but one voice.</p><h3>ESL Writing is Just Good Writing</h3><p>As I practiced my new ESL writing skills, I started to realize there was more going on than just bridging language gaps. When we communicate the design for a cloud-native solution to a client, we’re also bridging gaps in technical experience, business perspective, and corporate culture.</p><p>We encounter these same types of gaps with just about any client, whether they’re down the street or across the globe. Using consistent terminology, avoiding jargon and slang, breaking up long sentences, and choosing simple words isn’t just good when writing for translation. It’s good writing, period.</p><p>For many of our clients, taking the leap into digital transformation or cloud migration is a lot like learning a new language. I started out looking for ways to make our documents easier for ESL readers and translators to understand. Along the way I learned that clear, simple writing makes technical content easier for anyone to read and grasp.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6381ce79e05" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Radical Candor: Rocket Fuel for Your Teams]]></title>
            <link>https://kenzanmedia.medium.com/radical-candor-rocket-fuel-for-your-teams-c300ca6d014c?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/c300ca6d014c</guid>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[radical-candor]]></category>
            <category><![CDATA[team-building]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Mon, 16 Nov 2020 21:30:47 GMT</pubDate>
            <atom:updated>2020-11-16T22:46:29.601Z</atom:updated>
            <content:encoded><![CDATA[<h4>By Elisa Hebert, Head of Operations and Client Solutions</h4><p><em>This is the sixth post in a multi-part series about Radical Candor and authenticity in the workplace. To start at the beginning, </em><a href="https://medium.com/@kenzanmedia/radical-candor-869a205faec4"><em>check out the first post in the series.</em></a></p><p>It’s been a little over a year since I was introduced to Radical Candor, though in COVID times it seems perhaps more like a decade. The book and the practice have helped me level up in ways I hadn’t anticipated, led to conversations I wouldn’t have expected, and given me tools to help me understand myself and my communities more clearly and deeply.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t-1M7iOKWIc85p7MIR46Ow.jpeg" /></figure><p>When I <a href="https://medium.com/@kenzanmedia/radical-candor-the-daily-practice-of-crit-ique-869a205faec4">first started this journey</a>, I promised to report back on how our book club was improving our communication and transparency as a team and an organization. I also promised not to hide the ways we were still working out the kinks. So, here I am, with a readout of some good stuff, some challenging stuff, and teeing up a soon-to-come Book Club Play that we’ll share for you to explore this material (or any) in your organization.</p><h3><strong>Piloting the material</strong></h3><p>Kenzan’s Client Solutions team was my first stop in the journey — ensuring we had a cohort that was willing to muddle through it, workshop and hone the material, and to find our footing as a critical jumping off point. This isn’t just a book club — we were testing the waters on leveraging this material to substantively change our organization’s communication DNA.</p><p>I recruited our incredible Learning &amp; Development Manager, Kate Pisano, to help me facilitate the sessions. (<em>Quick aside — there really is no way for me to overstate how much I appreciate Kate as a trusted advisor and partner as I evolve my approach. I am deeply grateful for her willingness to always jump on Zoom and talk through a crazy idea and help me mature my thinking, and her constant encouragement along the way.) </em>If you’re thinking about kicking off your very own Radical Candor book club series, I cannot overstate how important it is to have a thought partner that you trust and whose input you value deeply.</p><p>We started with a pilot that went like this: the Client Solutions team read the book and then conducted three deep-dive sessions together, each about two hours long, and focused on how to leverage the material:</p><ol><li>With each other</li><li>With our colleagues across Kenzan and our parent company, Amdocs</li><li>With our clients</li></ol><p>I was excited and impressed with how the team dove into the material and the thoughtfulness with which it was considered. It was clear to everyone that I was enthusiastic about the book. I was excited to evangelize it with my team and see them take to it as something that could help them tactically and strategically in their own evolution.</p><p>We shared our experience in an All-Hands meeting, and I was instantly flooded with Slack messages from across the organization asking if we would be doing another round. There was a deep desire to participate and dig into the concepts. Our team discussed the best approach to turning the pilot into a series, and folx took it from there. We’ve since had two more groups, run by members of the Client Solutions team along with Kate, and we’re planning a third. Participants are from all around the organization, crossing locations, roles, and levels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GLqZiOo8DelJZC5ujWxX6g.jpeg" /></figure><h3><strong>What did we learn?</strong></h3><p>Anecdotally, we’ve seen some incredible growth, and some missteps, from folx exploring this material. It’s been encouraging to hear that Radical Candor is helping people think through their relationships (both personal and professional) differently, and what we owe to each other in terms of feedback. It’s also been heartening to see the places we’ve over-extended — sometimes with a preamble that they realize hasn’t been quite tuned enough, like <em>I’m going to be Radically Candid here</em> — and then been self-reflective enough to realize that’s not quite how to apply the concepts in practice.</p><p>I wanted to hear, and share, reflections from participants. Feedback was copious. I’ve selected a few thoughts across the organization that hopefully give a sense of the impact the series has had and why we continue to invest in it.</p><h3><strong>About the material and model</strong></h3><p><em>If a team signs on to implement Radical Candor and has trust in each other to be kind, that team can focus on the work and get more high quality work accomplished. It’s an un-blocker.</em> — <a href="https://medium.com/u/da2a21cad7f5">Jeremy Brett</a>, Software Engineer</p><p><em>Using Radical Candor to constantly point out each and every flaw in a colleague is not helpful. I think the book calls it Obnoxious Aggression and it is definitely both those things. I have also noticed obnoxious aggressors are the least likely to actually take constructive feedback in the spirit it is offered. I think there is this happy middle ground that requires judgment and good intentions to find.</em> — <strong>Mike Ryan</strong>, Director of Engineering</p><p><a href="https://www.radicalcandor.com/growthstabilityandcareer/"><em>Rock Stars have a different motivation</em></a><em>. As an organization, how can we structure our HR tools and techniques to support these concepts? I’d like to use the book when we are recommending new things like our career mapping conversations… how do we align our processes, tools, etc to Rock Stars vs Super Stars?</em> — <strong>Robin Morrison</strong>, Head of Agile Solutions</p><p><em>I tend to think in systems, and I have a hard time with consistency without them. Radical Candor gives me a system for managing interpersonal interactions that I never really had before. It finally made ‘There’s a difference between nice and kind’ make sense.</em> — <strong>Chris Terry</strong>, Platform Engineer</p><p><em>Understanding how other people have the same blockers to being candid helped me acknowledge that discomfort and push through it myself… the harder something is to say, the more important it is for you to give that feedback.</em> — <strong>Kellan Folkers</strong>, Director of Client Solutions</p><h3><strong>About the book club framework</strong></h3><p><em>I got to bounce my interpretations off other people, hear angles I wouldn’t have thought about, and through those, better understand the concept model. It felt especially useful hearing from others who had experiences they could tie Radical Candor to.</em> — <strong>Chris Terry</strong>, Platform Engineer</p><p><em>My learning from the book club was less regarding the book material itself. Instead, I learned more about the people in the book club series within my group: how they think and feel, how they perceived the material of the book, and how they felt challenged by the book</em>. — <strong>Dennis D. Kirkpatrick</strong>, Platform Engineer</p><p><em>The open, honest discussions amongst our cohort were insightful and highlighted that different readers can come away with nuanced understandings of the text. The discussions about those nuances were the highlight of the sessions for me. </em>— <strong>Bill Schwanitz</strong>, Technical Architect</p><p><em>Getting to hear others’ perspectives and insights is always extremely valuable. As we discussed in the CS book club, no two people have the same experience, so hearing these varied perspectives could not only help us expand our insights into the material, in this instance it could help provide fuel for caring personally..</em> — <strong>Jeff Grow</strong>, Senior Manager, Client Solutions</p><p><em>Listening to others enabled me to learn from situations that I may face in the future. Hearing from others how to apply the methodology to situations I haven’t yet faced helped me to speed up maturing as a manager without having to pay the price. </em>— <strong>Jaffid Landeros,</strong> Director of Engineering</p><p><em>Radical Candor needs context — if left unguided it can definitely end up in ruinous empathy or obnoxious aggression. It is an uncomfortable topic and can be hard to operationalize without guidance. To that end, I love that we did it as a book club series and that Elisa championed it around the organization with a rigorous, thoughtful approach. </em>— <strong>Ming Linsley</strong>, Head of Kenzan</p><h3><strong>Paying it forward</strong></h3><p>If you’ve gotten this far, perhaps you are interested in leveraging Radical Candor in your organization to make meaningful change in your operations and communication. No sense in reinventing the wheel… in our next post we’ll share our blueprint for running your own book club.</p><p><strong>Are you using Radical Candor personally or in your organization?</strong> I’d love to hear your thoughts and how it’s working! Find me on <a href="https://www.linkedin.com/in/elisahebert/">LinkedIn</a>.</p><p><em>If you enjoyed this article, catch up on all the articles in Elisa’s series on Radical Candor:</em></p><p><em>Part 1, </em><a href="https://medium.com/@kenzanmedia/radical-candor-the-daily-practice-of-crit-ique-869a205faec4"><em>The Daily Practice of Crit(ique)</em></a><em> <br>Part 2, </em><a href="https://medium.com/@kenzanmedia/radical-candor-calling-yourself-out-8106585297db"><em>Calling Yourself Out</em></a><em><br>Part 3, </em><a href="https://medium.com/@kenzanmedia/radical-candor-management-style-sunny-with-a-chance-of-bananas-67302526398d"><em>Management Style: Sunny With a Chance of Bananas</em></a><em><br>Part 4, </em><a href="https://medium.com/@kenzanmedia/radical-candor-pink-hair-piercings-and-professional-services-c092b9701837"><em>Pink Hair, Piercings, and Professional Services</em></a><em><br>Part 5, </em><a href="https://medium.com/@kenzanmedia/pandemically-candid-2cccec069af5"><em>Pandemically Candid</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c300ca6d014c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Pandemically Candid]]></title>
            <link>https://kenzanmedia.medium.com/pandemically-candid-2cccec069af5?source=rss-5961f8e0b790------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cccec069af5</guid>
            <category><![CDATA[working-from-home]]></category>
            <category><![CDATA[radical-candor]]></category>
            <category><![CDATA[covid19]]></category>
            <dc:creator><![CDATA[Kenzan  + Sourced]]></dc:creator>
            <pubDate>Fri, 15 May 2020 16:44:15 GMT</pubDate>
            <atom:updated>2020-11-16T22:53:53.403Z</atom:updated>
            <content:encoded><![CDATA[<h4>By Elisa Hebert, Head of Operations and Client Solutions</h4><p><em>This is the fifth post in a multi-part series about Radical Candor and authenticity in the workplace. To start at the beginning, </em><a href="https://medium.com/@kenzanmedia/radical-candor-869a205faec4"><em>check out the first post in the series.</em></a></p><p>On the left tail of the COVID-19 bell curve (which maybe we are still in, which is horrifying), when many white collar workers were making moves to work from home for a period of time, I was pretty sure I knew what it would look like. I had, after all, worked from home and far away from my colleagues for 9 years at my last company. I had successfully led the business and operations side of an organization remotely, and I was confident this wouldn’t be so different. I even proclaimed as much in a video meeting with some colleagues — all of whom gave me side-eye as our children ran around in the background. A few adjustments, I thought, and we’d be good to go.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0g7pTflnp1bj-HAhskRrjA.png" /></figure><p>Flash back several months before that. A female leader at Kenzan and I were chatting, and she asked, “How do you do it all?” I was, at the time, in the final throes of getting my MBA, and I have two little girls (8 and 5 years old) plus a demanding job. My answer? I have a wife.</p><p>Now, it just so happens my wife is female, but I’m not talking about her gender. I’m talking about her gender role in our household. My wife is significantly more successful than I am at the balancing act. I’ve had the ability to opt out due to long days at work and long weekends of homework. She is a real estate agent with a flexible schedule. AND she does the full end-to-end gamut of life with a home and kids — the bills, the doctor appointments, the after-school activities, the after-school meltdowns, the permission slips, the scheduling, the laundry, knowing when it’s time to get the house repainted, making sure we have enough milk, storing the 5T clothes and buying the 6Ts (before the 5Ts become high-waters). ALL OF IT.</p><p>Working from home in the era of COVID-19 is a different game. This is <em>not</em> normal working from home. (What is normal, anyway? Different blog post for a different day.) Kids are always underfoot, and the news that school wouldn’t reopen this year hit hard even as we saw it coming. This was one of the great reckonings for me early on. I had to get Radically Candid with myself about how different <em>this</em> work-from-home situation is, even while I am as minimally impacted as a person can be (see above RE: my infinitely capable wife). My colleagues who looked at me like I was nuts when I said this would be fine? <em>They were right.</em></p><p>It’s not fine. It’s not the same. Some days, for many people, it is or feels impossible. Now let’s be honest — the stress of socially isolating and working from home is not in the same ballpark as wondering how we’ll pay the mortgage or the bills. However, for many folx who are privileged enough to make their usual salary working from home, figuring out how to keep that job, stave off loneliness and/or stir-craziness, and (for many) educate (or even just keep busy) their kiddos can be an outrageously difficult hurdle.</p><p>AND (as so many people have written since this all started) it’s highlighting the ways that we can step up and take care of each other. Of all of the moments in time for any business, this one is when the people matter most. This is the one where people will remember how their company reacted. This is the one they’ll viscerally recall if they were truly supported as a whole human.</p><p>I’ve written about how Radical Candor has changed the way I look at my interactions with others, and how I’m trying to operate as a leader, manager, and colleague. It’s said (pretty much everywhere these days) that leaders are forged in crisis. Everyone is watching to see who will rise to the occasion and lead us through whatever comes next — and who can walk that balance between confident reassurance and honest vulnerability.</p><p>As leaders, we are trying to figure out just how to do that. At the same time, leaders are whole humans too. We are afraid for our families and friends. We are lonely, and sometimes bored, and (especially if we have kids) often overwhelmed these days. We are balancing all of the myriad needs that our teams have right now with a basic truth: one of the fundamental things we must do is to <em>keep the lights on</em>. Making sure the business stays healthy means our teams can keep food on the table and keep rent or mortgages paid. It removes one of the most base fears that we all increasingly have as unemployment rates skyrocket. <em>Will I lose my job? Will I lose my home? How do I protect my family?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KTqG_q8V3sHQK_IsG3vIiA.png" /></figure><p>Radical Candor comes into play when we think about how we approach this conversation with ourselves and our teams. Because we have today, and will increasingly have, those among us for whom their job is not the only or most important consideration. We do and will have folx who are struggling with recovery and mental health in this time of isolation. We do and will have folx with friends or family members who are sick. We do and will have folx who are sick themselves.</p><p>Being Radically Candid means sitting with this discomfort, and owning it. We recognize to each other that this time is unprecedented in many of our (American) lifetimes, and we don’t always know the right thing to do, not right away. What we <em>do</em> know how to do is act like whole humans. The same goes in our home lives. Like ourselves, our kids are more stressed, and we share things with them in an age-appropriate way that is balanced with our own anxieties. We acknowledge that while some people want a 24/7 news cycle, others have turned it off because it’s just too much. We look for more creative ways to connect, and give a little more grace all around — to our families, our teams, our colleagues, and most importantly to ourselves.</p><p>This might look different for your organization, but here at Kenzan and Amdocs it means:</p><ul><li>Open and honest all-hands meetings where we talk about what we’re doing in this uncertain time, and folx can feel safe to voice their questions or fears.</li><li>More 1 on 1s that start with a little more chatter and personal silliness than usual, and that we allow to run long to foster real connection.</li><li>Virtual trivia nights and game nights and happy hours, oh my!</li><li>Hangouts and show-and-tell times for the kiddos during work hours, to give parents a little minute to themselves.</li><li>Baby time. Because sometimes seeing a tiny adorable human (even if only over a video call) is just what you need for a pick me up.</li><li>Giving a little extra patience when someone’s louder than usual, and checking in when they’re quieter.</li></ul><p>In a time of crisis, in <em>this</em> crisis, true colors shine through. And what I see when I look at Kenzan and Amdocs, while imperfect (as are we all), brings me significant personal comfort and reassurance. It doesn’t make knowing that school’s (basically) already out for summer any easier. But it does help knowing that I have solid ground beneath my — and my family’s — feet.</p><p><em>If you enjoyed this article, catch up on all the articles in Elisa’s series on Radical Candor:</em></p><p><em>Part 1, </em><a href="https://medium.com/@kenzanmedia/radical-candor-the-daily-practice-of-crit-ique-869a205faec4"><em>The Daily Practice of Crit(ique)</em></a><em> <br>Part 2, </em><a href="https://medium.com/@kenzanmedia/radical-candor-calling-yourself-out-8106585297db"><em>Calling Yourself Out</em></a><em><br>Part 3, </em><a href="https://medium.com/@kenzanmedia/radical-candor-management-style-sunny-with-a-chance-of-bananas-67302526398d"><em>Management Style: Sunny With a Chance of Bananas</em></a><em><br>Part 4, </em><a href="https://medium.com/@kenzanmedia/radical-candor-pink-hair-piercings-and-professional-services-c092b9701837"><em>Pink Hair, Piercings, and Professional Services</em></a><em><br>Part 6, </em><a href="https://medium.com/@kenzanmedia/radical-candor-rocket-fuel-for-your-teams-c300ca6d014c"><em>Rocket Fuel for Your Teams</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2cccec069af5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>