<?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 Vineeth Venudasan on Medium]]></title>
        <description><![CDATA[Stories by Vineeth Venudasan on Medium]]></description>
        <link>https://medium.com/@vyvyd?source=rss-6d7723c134f9------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*OjSvnDbnM47k8uChKLEOOg@2x.jpeg</url>
            <title>Stories by Vineeth Venudasan on Medium</title>
            <link>https://medium.com/@vyvyd?source=rss-6d7723c134f9------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 22:35:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vyvyd/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[Lessons from building a Modular Monolith in Spring Boot 3 — Part 1]]></title>
            <link>https://vyvyd.medium.com/lessons-from-building-a-modular-monolith-in-spring-boot-3-34607fb0cf87?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/34607fb0cf87</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[modular-monolith]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 07:42:50 GMT</pubDate>
            <atom:updated>2026-07-10T10:59:31.920Z</atom:updated>
            <content:encoded><![CDATA[<h3>Takeaways from building a Modular Monolith in Spring Boot 3 — Part 1</h3><h4>Setting up the groundwork</h4><h3>Background</h3><p>Quite recently my team and I built and deployed a greenfield internal application used for physical asset management — as a modular-monolith using Kotlin, Spring Boot 3.4, and PostgreSQL.</p><p>Because we didn’t foresee the need for a highly complex architecture, we made a conscious decision to skip microservices altogether. With a database under 1GB and fewer than 1,000 concurrent users, this was fundamentally what we could call a ‘small’ system. After we took the system live, our predictions were not too far off — they system currently takes about 400 requests every 15 minutes, nothing that any modern stack cannot handle with ease, and the amount of data that we work on a day to day basis was actually much less than what we had planned for.</p><h3>Why did we choose a modular monolith?</h3><p>One of the constraints my last project to setup a replacement system from scratch was the inability to have and in-depth analysis phase, or even event-storming sessions that might have helped us draw more intentional boundaries when we began work.</p><p>And hence we started with a Modular-Monolith.</p><p>A modular monolith allowed us to make mistakes with our boundaries, and keep the cost-of-change low when you need to fix them.</p><h3>Part 1: Structuring the modular-monolith</h3><h4>1. Code Organisation</h4><p>On a broad-level, our modular-monolith looked like this: two distinct kind of modules with the application — application-modules that contained business-logic, and supporting-modules that were generic, re-usable modules within the application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uYXIOBVd0bl1sLmY0F0l2Q.png" /></figure><p>The supporting-modules at this time usually were integration libraries like AG-Grid Integration, or common HTTP-Clients <strong>that were used in more than one core application module.</strong> Also maybe custom thin-wrappers around Quartz-Job Management or Email Clients.</p><blockquote><strong>Takeaway 1: </strong>The idea was that the supporting-modules could be extracted into separate libraries or services, and could be re-used across much more many applications in the future. Set up the supporting modules where this is easy to do — you could consider using Gradle sub-modules for modules like this, especially if you are sure you are building very generic components.</blockquote><blockquote><strong>Takeaway 2: </strong>To keep the system simple, we only had both these categories. Although over time, I thought maybe the system of bifurcating modules could reflect <a href="https://github.com/SAP/curated-resources-for-domain-driven-design/blob/main/blog/0002-core-concepts.md">domains</a> according to well-established DDD principles.</blockquote><blockquote>But this is a something that you could consider based on your project needs.</blockquote><h4>2. What is a Module?</h4><p>On a very high-level, a module is a cohesive ‘unit’ in the application. The entire application is then composed of many such modules. (We will talk about what this ‘unit’ is later on in the section “Module Boundaries”)</p><p><strong>A module must hide it’s internal implementation details behind a well-defined ‘API layer’.</strong></p><p>This means, no direct access to services or repositories to a certain module from any other one — every one talks through an specific API alone. This mechanism controls how coupled modules are to each other.</p><p>In my project we had used just Kotlin packages and specific nomenclature to draw module boundaries (for some initial flexibility), but depending on your project, I would strongly suggest considering having boundaries using build-tooling, like Gradle, Maven (or) Amper.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iIWHXseusaCF9eJvbBQ6PQ.png" /></figure><blockquote><strong>Takeaway 3: </strong>Enforce this API only access in the code, in an automated manner — If you separate your modules by packages, ArchUnit is a lightweight way that you could use to enforce this rule, and you <strong>must</strong> set it up from Day 1.</blockquote><blockquote>Have no exceptions — this will not be easy to fix later in the application.</blockquote><h4><strong>3. Module API and Communication Pathways</strong></h4><p>To keep things simple, the Module-API could be created using</p><ul><li>Kotlin Interfaces</li><li>Kotlin Data-Classes</li><li>Module Exceptions (or) Result Monads</li><li>Module Events</li></ul><p>And we could use a combination of these constructs in three distinct strategies in your application:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l_TrZZ4Lfx5_GTYdUtr1QQ.png" /></figure><p><strong>Strategy 1: Only Kotlin Interfaces, Data-Classes and Errors</strong></p><p>This is a simple, no-frills <em>initial</em> approach you can take.</p><ul><li>First, it provides a single, centralized view of the module’s public contract — more interface methods, bigger DTOs with a lot of exposed fields, a wider contract and maybe something that could use another look.</li><li>Second, it makes it easy to write ArchUnit tests to enforce boundaries — especially if you are only using packages to restrict access from one module to another.</li></ul><p>A general flow of logic with the <strong>module-api</strong> layer in that case looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MT9OqsC2Zgm9B77KpF7cKw.png" /></figure><p>But there two other more benefits to this that I think that are even more important:</p><p><strong>A normalization layer like this removes internal implementation detail from the public API for a module.</strong></p><ul><li>This was especially critical for us because we relied heavily on an “<a href="https://www.martinfowler.com/eaaCatalog/activeRecord.html">active-record</a>” style objects using JPA entities. Allowing database-coupled objects to leak outside the module boundary was a sure way to introduce interesting transaction-boundary errors in our system.</li><li>The other aspect is an implementation-agnostic layer like this makes it much more possible to extract modules into a separate service in the future. These interfaces and DTOs</li></ul><p><strong>Strategy 2 and 3: Module Events</strong></p><p>In my last project that I was talking about, <strong>we started with Strategy 1 </strong>(from the earlier diagram)<strong> </strong>for the module-api — since our original goal was to build modules that could later be extracted to microservices (or) libraries (or) <a href="https://scs-architecture.org/">SCS</a> services if the requirement arose.</p><p>The reason for starting with just <strong>Strategy 1</strong> was very tactical — some of the first modules that were built were purely integration modules, that abstracted away connectivity to a few internal systems, with the data that these modules stored then being made available for synchronous consumption from other modules.</p><p>However, over time, we had introduced Module-Events, and hence I could say we eventually moved to <strong>Strategy 3. </strong>Although in retrospect — I would have personally preferred including Module-Events only a lot later in the system. My take is that we should look to communicating with events between modules only when it was possible to deduce domain events in the code that aligned with real-world business-relevant events.</p><p>Otherwise, what usually ends up happening is that the team chooses to create technical CRUD like entity-created entity-updated or entity-deleted events.</p><blockquote><strong>Takeaway 4: </strong>I have a strong dislike for these kinds of events — broadcasting CRUD events across module boundaries just turns your application layer into a Change-Data-Capture (CDC) pipeline, and it completely misses the point of domain events whose purpose is to capture explicit business intent.</blockquote><blockquote>I highly recommend holding off on an event-driven strategy here, until your domain is mature enough to express real business workflows through a (constrained) set of domain-events</blockquote><blockquote>My personal suggestion would be to start with <strong>Strategy 1,</strong> introduce <strong>Strategy 3</strong>, and then over time, if you model you domain right with keeping logic and data cohesive, you might be able to extract meaningful business-events, and then be able to live with just <strong>Strategy 2</strong>. This is in line with what is known as <a href="https://evolutionaryarchitecture.com/">evolutionary-architecture</a>.</blockquote><h4>4. Module Boundaries</h4><p>This one topic can often open up meta discussions that could entirely be avoided with some sensible agreements within teams.</p><p><strong>My strong preference: Business Aligned Module Boundaries</strong></p><blockquote><strong>Takeaway 5: </strong>My strong preference is to have module-boundaries reflect real-world business-boundaries, with each module only having dependencies towards other modules in a specific (unidirectional) manner.</blockquote><blockquote>The basic principle being, that we model the software on the way the company and it’s business processes <strong>actually</strong> operate.</blockquote><p>This will help you, in turn — have a <em>discoverable</em> code-base, and aligns perfectly well with what Robert C. Martin would call “screaming architecture” —<strong> where the organizational semantics of the code-repository <em>screams</em> what business-problem is actually solves</strong>.</p><p>Without a firm agreement in the team, what I suspect will happen in practice would be the inclination to extract modules out of <em>every</em> technical-component, for example, an HTTP client or another <em>adapter</em> layer.</p><p>I would strongly advocate against a premature split of business-functionality and technical layers within a module, because this goes against keeping cohesive parts of a system together. This is why each module should have a specific place to store integration logic specific to itself.</p><p>We will explore this in more detail in the next section.</p><h4>5. Module Internal Structure</h4><p>After multiple iterations, we arrived at a structure in the project that was fairly similar to this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*52Dl-XLqKexiOAvv12TLKQ.png" /></figure><p>This is not very different from what is called a “sliced-onion-architecture” as mentioned <a href="https://odrotbohm.de/2023/07/sliced-onion-architecture/">here</a> in the linked article.</p><p><strong>Enforcement of project-structure</strong></p><p>For this you can do this in two ways (I would say you should combine them):</p><ul><li><strong>ArchUnit</strong> (<a href="https://www.archunit.org/">https://www.archunit.org/</a>) to enforce code-structure</li><li>Build-Tooling (<strong>Gradle, Amper, Maven</strong>) to divide your application into modules</li></ul><p>One aspect of using build-tooling is that you could enforce something like dependency-direction a lot more easier than using ArchUnit tests (because ArchUnit tests might be too late to catch a code organization violation).</p><p>Also, tooling like Amper might make it simpler to setup multi-module projects — but it’s something that I am trying out on my own right now.</p><blockquote><strong>Takeaway 6: </strong>You will probably face a question over time regarding the internal organization of modules, dependency-inversion, labeling of concepts. <strong>My strong advice is to standardize things like labeling/nomenclature, general concepts like splitting I/O from core-concerns, packaging by feature</strong> — and leave more specific concerns that might affect a single module (like dependency-inversion in our specific case) to individual modules.</blockquote><blockquote>A key takeaway is the need to avoid over-standardization. Applying a rigid, consistent strategy can needlessly complicate processes that require <em>some</em> flexibility. Granted, the <em>some </em>will require some good judgement.</blockquote><h3>Next Topic</h3><p>In the next article in this series, I would like to write about how we can set up testing for such a modular-monolith.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34607fb0cf87" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Focus on outcomes, not activities]]></title>
            <link>https://vyvyd.medium.com/focus-on-outcomes-not-activities-1651e79327e6?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/1651e79327e6</guid>
            <category><![CDATA[business-strategy]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Sun, 10 May 2026 12:11:10 GMT</pubDate>
            <atom:updated>2026-05-10T12:11:10.107Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*E1PfanHi2t-qdW6y" /><figcaption>Photo by <a href="https://unsplash.com/@zorki4?utm_source=medium&amp;utm_medium=referral">Mark Rolfe</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I took this line from an old video Sam Newman made regarding microservices. You can watch the complete video <a href="https://www.youtube.com/watch?v=GBTdnfD6s5Q">here</a>.</p><p>I believe this is very sound advice, and one that is quite often neglected in our industry. In many projects that I have been on, there were technical and well as non-technical aspects that we ended up prioritizing over what those aspects might have provided us in return.</p><p>It’s a repeated trope. Technologists chase after those bright and shiny objects without really thinking if they are actually needed in the first place.</p><p>But as I went further into my career, I have gotten to see that it’s not just technologists who are subject to this criticism. Non-technologists in the software industry fall victim to this phenomenon just as much.</p><p>We might have all come across at least one person who truly believe that shoehorning that latest buzzword into their SDLC process will magically solve every bottleneck they’ve had until then.</p><p>I ask myself three questions to avoid walking into this trap:</p><blockquote><strong>Can we measure the value of the activities we undertake?</strong></blockquote><blockquote><strong>What are the expected returns for the decisions our team has taken?</strong></blockquote><blockquote><strong>If that decision doesn’t give us what we want, can we correct course?</strong></blockquote><p>These questions keep me grounded.</p><p>The central point on my mind is this:</p><ul><li>You could have planet-scale technical architecture that could rival the Netflix-es, Shopify-s, and Cloudfare-s of the world.</li><li>You could get every employee get the tallest stack of the best “agile-certifications” in the market.</li><li>Your developers could be burning through AI/LLM tokens like there’s no tomorrow.</li></ul><p>But if that does not provide you any meaningful result of value to who your <em>intended</em> customer is, it’s just worthless, expensive vanity metrics.</p><p>We should be better than that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1651e79327e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One pattern to rule them all]]></title>
            <link>https://vyvyd.medium.com/one-pattern-to-rule-them-all-f5325d49bfbf?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5325d49bfbf</guid>
            <category><![CDATA[technical-writing]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[planning]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Mon, 26 May 2025 22:13:29 GMT</pubDate>
            <atom:updated>2025-07-21T20:47:27.264Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ADU3CQBBnFdtbaKT" /><figcaption>Photo by <a href="https://unsplash.com/@thiagorobert?utm_source=medium&amp;utm_medium=referral">Thiago Santos</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Over my career, I’ve encountered situations where clients and developers often seek a single concept, pattern or idea to address multiple problems in one go. And often, I have seen these ‘unified’ models break down, sometimes spectacularly.</p><p>Thought it might be something worth writing about.</p><h4>Premature patterns could be risky</h4><p>This ‘search’ for patterns is often a search for efficiency. The wish to do something once and for all, and never having to touch it again. I think this is a very good idea, actually.</p><p>But I also think that it comes with some risk. If we are in a problem-space which is not so well-established, actively seeking out a ‘pattern’ too soon <em>could</em> be driven by assumptions .</p><p>When these assumptions are later found out to be wrong, and when the requirements change — sometimes we become so invested in that premature solution that we would build more and more layers on top of what <em>might </em>the wrong foundation. This is especially true, if the initial pattern took time to build, or was in some way costly.</p><p>We all think we won’t fall victim to sunk-cost fallacy, until it actually happens.</p><h4>What might be an alternative?</h4><p>A piece of advice that a team-lead once told me comes to mind —<strong> “Things <em>become</em> a pattern after they are used for a while”.</strong></p><p>In other words, something isn’t a pattern from day one — it needs to earn that status through practical use over time. The core principle here is <strong>that we should “</strong><a href="https://wiki.c2.com/?UseBeforeReuse"><strong>use before reuse</strong></a><strong>”</strong>.</p><p>Another reason why I resist creating patterns early on is because I am a staunch advocate of the <a href="https://www.oreilly.com/library/view/software-architects-handbook/9781788624060/a844b94f-be9e-456d-8ef0-cd9b46b41c33.xhtml">Last Responsible Moment</a> — where we actively delay a decision until the moment when the cost of not making the decision is greater than the cost of making it.</p><p>And yes, you might end up with duplication until that fabled “Last Responsible Moment”, but I really think that’s okay! I for one would not be so fanatical about the “Don’t Repeat Yourself!” advice, and instead follow <a href="https://en.wikipedia.org/wiki/Rule_of_three_(computer_programming)">Rule of Three</a> — I duplicate twice, but the third time, I make a pattern.</p><p>From my experience, Patterns will, over time, scream at you through everything else in the code or architecture. Until then, resist the urge to <strong>force</strong> them into existence.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5325d49bfbf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microservices: Prioritize Operational Complexity over “Template Projects”]]></title>
            <link>https://medium.com/codex/microservices-prioritize-operational-complexity-over-template-projects-0ffdc9487b61?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ffdc9487b61</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Sun, 31 Dec 2023 13:41:42 GMT</pubDate>
            <atom:updated>2024-04-18T04:54:10.362Z</atom:updated>
            <content:encoded><![CDATA[<h3>Microservices: Prioritize operational complexity over service templates</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-BSpeSjHWLPI95u1" /><figcaption>Photo by <a href="https://unsplash.com/@marvelous?utm_source=medium&amp;utm_medium=referral">Marvin Meyer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>There is a common myth among teams trying to jump into microservices, that the first step required is to have a <em>project template</em>.</p><p>I disagree.</p><h4>But, shouldn’t it be easy to create a new service?</h4><p>Yes, but that is not the first thing you need.</p><p>I think this idea that we must come up with a ‘template’ project first is a result of seeing microservices primarily as separated repositories, before anything more.</p><p>And so a project template is often hastily born, and in many cases it’s just a Hello World application with maybe the infrastructure code that deploys it to an environment.</p><p>But something like that is not very valuable, in my opinion. All that this sort of a “template project” does is to solve a small part of the <em>development complexity</em> involved when considering a microservice style of deployment, but not much more.</p><h4>An alternative approach</h4><p>I think we should be spending more time focusing on <em>operational complexity </em>when considering using microservices to solve business problems.</p><h3>Tackling operational complexity</h3><p>One way to think about the various <em>operational complexities</em> one encounters with microservices is to go back to the often-quoted <em>Fallacies of Distributed Computing.</em></p><p>Let’s go over each of them.</p><h4><strong><em>The network is reliable</em></strong></h4><p>Before we even head out into the world of microservices, do we have the following concerns addressed?</p><ol><li>For read-based remote calls, do you have an established method for <a href="https://resilience4j.readme.io/docs">resilience</a>?</li><li>For write-based calls, do we have a strategy to make repeated calls <a href="https://www.restapitutorial.com/lessons/idempotency.html">idempotent</a>?</li><li>And on the business side, are user flows and business processes set in such a way that they are resilient to technical failures?</li></ol><h4><strong>Latency is zero</strong></h4><p>For every business operation,</p><ol><li>does the team have a way to measure P9x response times for core-business operations, and more importantly,<strong> do we have a baseline for this measure</strong>?</li><li>do we have an SLA for our end users when it comes to response times? Do we have a way to monitor them continuously?</li></ol><h4>Bandwidth is infinite<strong> || Transport Cost is Zero</strong></h4><p>I have had an experience with an engagement that did microservices, with a high throughput of (large) data between services. This had a negative impact on the performance of the application.</p><ol><li>do we know the amount of data that needs to flow in between services?</li><li>do we know the typical pattern of this data-flow on an average day?</li></ol><p>Our technical choices when we do microservices might change based on this answer.</p><h4>The network is secure</h4><p>For every service,</p><ol><li>Do we know how to ensure secure communication between services?</li><li>are these policies signed off by the business/organization?</li><li>do we have the necessary safety nets we have in place to ensure that the team has a multi-layered security approach (since microservices increase the surface area of a possible attack?)</li></ol><p>We must remember that microservices can inadvertently increase the surface area of a potential attack if proper thought is not given to the security aspect of things.</p><h4>The topology does not change</h4><p>When we think of the boundaries between microservices,</p><ol><li>do we have our microservice boundaries where if a single service goes down, the rest of the services or business capabilities can continue as usual?</li><li>do we have the necessary infrastructure and knowledge of tools and techniques that will enable this sort of resilience between services?</li></ol><p>For example, the often-seen ‘Order-Service’ in most e-Commerce platforms is a single point of failure, often because it gets tied to most business processes.</p><p>When the boundaries and dependencies are not thought through, what we have is a setup where most services will require the ‘central’ service to be up and running at all times.</p><p>If the boundaries and the technologies do not support this level of resiliency, microservices provide little benefit when it comes to a blast-radius of failure.</p><h4>There is one administrator</h4><p>If splitting an existing service into different microservices,</p><ol><li>Do we have a monitoring and observability tooling setup for the current service that we can extend to the newly created service(s)?</li></ol><p>And when these new microservices are to be maintained by different teams,</p><ol><li>Is there a way to have end-to-end visibility for the present state of the system at any given point in time? Does every team have a common observability and monitoring tooling setup?</li><li>Do all the teams have the same capability and expertise using monitoring and observability tooling?</li><li>Do all the teams have a similar infrastructure setup, and do we know if there are any downsides (especially around cost or long-term maintenance) to them being different or inconsistent?</li></ol><p>I have come across a couple of microservice setups, where even <a href="https://x.com/samnewman/status/862255875125366786?s=20">basics</a> like having aggregated logging or even having a <a href="https://www.sapphire.net/security/correlation-id/">correlation-id</a> between different services were not implemented before jumping into the world of microservices.</p><h4>The network is homogeneous</h4><p>Sometimes, choosing a single interoperable mechanism to communicate between microservices might not be the best approach depending on your use case.</p><p>For each of these mechanisms (for eg: HTTP based REST API with JSON payloads)</p><ol><li>Do we have a necessary safety net and tooling required to ensure that ‘contracts’ between services are not broken?</li></ol><p>Remember, with microservices, often we split up what could have been a <em>method-call</em> into a call <em>through the wire</em>.</p><p>The former is often more performant, easier to modify and refactor, and often is more maintainable in the long-run. When moving to the latter we should understand the trade-offs and minimize the downsides as much as possible.</p><h3>One step at a time</h3><p>Am I suggesting, that given the opportunity,</p><ol><li>one must not jump into creating a microservice “template” too soon? Yes.</li><li>one must not jump into microservices without considering their operational complexity? <br>Yes.</li></ol><p>Here is my proposal: completely <em>skip</em> creating a template during the initial days, and choose to solve operational complexities <em>while</em> solving business problems.</p><h3>Simpler, adaptable solutions first</h3><p><a href="https://www.jamesshore.com/v2/books/aoad2/book_club/evolutionary_design">As many in our industry advise</a>, prefer to have an evolutionary approach to coming up with designs for a software system.</p><blockquote><strong>Do we even need microservices implemented to resolve some of the operational complexities that we described earlier?</strong><br>In most cases, no. <br>You could surely look into having a <a href="https://martinfowler.com/bliki/MonolithFirst.html">Monolith-First</a> strategy to understand how to split your domains and the communication requirements between them.</blockquote><blockquote><strong>Do we need 5 or 10 microservices implemented already to solve the operational complexities that require multiple services to be in place (eg: maintaining contracts using contract-testing)? </strong><br>I believe the answer is no again. We could start small, with just a separate service to solve these specific operational concerns, and then replicate it to a full-blown microservice setup.</blockquote><p><strong>If you cannot answer some of these questions that help us understand operational complexity, </strong>should you not defer the decision to move to microservices?</p><h3>Conclusion</h3><p>Solve the right problems first, and solve the harder problems earlier.</p><p>Operational complexity is what will backfire if not taken care of early when considering microservices. Template projects ought to come much later, often derived from working solutions.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ffdc9487b61" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/microservices-prioritize-operational-complexity-over-template-projects-0ffdc9487b61">Microservices: Prioritize Operational Complexity over “Template Projects”</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[About  those git-commit messages]]></title>
            <link>https://medium.com/codex/about-git-commit-messages-2ba14e188d4?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ba14e188d4</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Tue, 13 Jun 2023 11:23:18 GMT</pubDate>
            <atom:updated>2024-09-03T17:44:34.709Z</atom:updated>
            <content:encoded><![CDATA[<h3>About those git-commit messages</h3><h4>Tooling and specifications don’t always ensure quality</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hvKjzoRf7IB_MKSL" /><figcaption>Photo by <a href="https://unsplash.com/@yancymin?utm_source=medium&amp;utm_medium=referral">Yancy Min</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Teams often struggle with enforcing a practice of good commit messages. In most cases, it is an uphill battle, with tools like Husky often used to alleviate the problem.</p><p>However, despite tooling, I’ve rarely seen commit messages being good enough for future maintainers of the project.</p><h4>Conventional Commits</h4><p><a href="https://www.conventionalcommits.org/en/v1.0.0/">https://www.conventionalcommits.org/en/v1.0.0/</a></p><p>Having a specification for commit message format is a good idea in many cases. Particularly when you use a commit message format to support versioning tools (for instance, if you update versions automatically depending on the type of commit message).</p><p><strong>However, what it does NOT do is fix the quality of these commit messages.</strong></p><p>By quality, I mean how much it helps a future maintainer of the project to understand <em>the why</em> for a given piece of code.</p><p>As such, I believe that some teams try to fix the wrong problem with a fixed commit message format.</p><p>For context, I developed this thought when a previous team of mine was very much into using <a href="https://gitmoji.dev/">https://gitmoji.dev/</a> — and over time, I had always felt having such an elaborate system provided very little value. Particularly because we had no versioning at all.</p><p>I would have prefered that we spent that time writing detailed and useful commit messages instead of figuring out the best category for every commit. One is clearly more valuable than the other.</p><h4>Should we have no formats at all?</h4><p>No, that is not what I am attempting to say. Consistency is a great quality to have in a code-base.</p><p><strong>However, whatever format/convention you choose as a team should be done with a view to the value that it provides.</strong></p><p>In the absence of constraints, I tend to favor a minimalistic commit message format.</p><pre><strong>TicketNumber: Short description of what changed</strong> (max 70 chars)<br><br>Detailed description of <strong>WHY</strong> the changes were made:<br>  - Use bullet points to aim for easier readability <br>  - An extra line to make the point<br><br>Why did I not follow any alternative approach?<br><br>What will follow in the next commits - you can do this <br>only if you had broken down the work into smaller tasks<br><br><strong>Co-authored-By: Who else worked on this ticket </strong><br>(important if you were pairing)</pre><p>This format makes the point of having the <strong>WHY</strong> for a change firmly within the commit-message.</p><p>As such, I prefer to use a full commit message instead of single-line commit messages. There are, exceptions. Say in case I make simpler commits like variable renames, minor changes in documentation et al.</p><h4>Fix the core issue – quality of commit messages</h4><blockquote><strong>Good commit messages that prove useful in the future don’t come from tooling, it comes from </strong><em>discipline</em><strong>.</strong></blockquote><p>It requires what some call “<strong>empathetic software development</strong>”.</p><p>This often needs to be cultivated. What I often do in my teams:</p><ul><li><strong>Lead by example</strong>. Ensure your commits follow the standard you set for yourself</li><li><strong>Document the commit message format</strong>, and get a consensus from the team. It’s perfectly alright to use existing formats (like conventional commits) — but we need to drive home the point that we must not just stop with a superficial formatting rule.</li><li><strong>Work closely </strong>with the folk who might need more help.</li></ul><p>Please leave a comment if this is a challenge for you too, and what worked for you. Thoughts and ideas are always appreciated!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ba14e188d4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/about-git-commit-messages-2ba14e188d4">About  those git-commit messages</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Help, My Backlog Is Out of Control!]]></title>
            <link>https://experiencestack.co/help-my-backlog-is-out-of-control-68773f812db?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/68773f812db</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Tue, 14 Feb 2023 09:44:02 GMT</pubDate>
            <atom:updated>2024-09-03T17:46:22.211Z</atom:updated>
            <content:encoded><![CDATA[<p>Many teams I have been on have large backlogs that had been quietly growing for months, if not years. This is very detrimental to your agile journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I3Xrt8GP7AZjct3YPrnu7g.png" /></figure><blockquote><strong>If you want to be an effective team, you must </strong><a href="https://konmari.com/"><strong>clean</strong></a><strong> the hell out of your backlog.</strong></blockquote><p>Let’s go over the types of tickets that we often see in bloated backlogs.</p><h4>Placeholder Tickets</h4><p>They should not be there in your backlog.</p><p>How many of us have seen these tickets that were just ‘placeholders’ with no description or additional details whatsoever? Or tickets that just lie around for years, their original creators even having left the company?</p><p><strong>We are keeping tickets around in the expectation that they might come to use <em>someday</em>. </strong>It’s a bad practice because it removes the element of focus.</p><p><strong>Recommendation: </strong>I recommend teams plan short-term tickets and put them in the backlog. These tickets should be very clear as to the value that executing them brings.</p><p>Longer-term plans, or features whose specifics are yet unclear can be left out of the backlog, and they must be tracked elsewhere.</p><h4>Long term planned “Feature” tickets</h4><p>For features that are still being discussed among stakeholders, I choose to have a more “collaboration” oriented tool to solve the job, than one that is primarily used for ticketing.</p><p>So, I choose something like Google Drive + Documents over JIRA to write down details regarding topics that are still under refinement.</p><p>With this, I keep the backlog much more focused, and it does what it is supposed to do — keep track of “things to do”. Not things we <em>might</em> do.</p><h4>Technical Debt tickets</h4><p>I tried to compile a list of actions that might allow us to manage technical debt tickets better.</p><ol><li><strong>Set an expiry date</strong></li></ol><p>My advice to you would be that if you are adding tickets that concern technical task, <strong>you need to ensure that it has a target date</strong>.</p><p>This also gives you an exit strategy for your ticket.</p><p>Often we see tickets that are more than a year old and whose creator might have already left the company.</p><p>Or maybe the technical-task targets something that really isn’t a problem. Why keep it in the backlog?</p><p><strong>2. Keep technical-task tickets together with product-related tickets</strong></p><p>I think there should <strong>not </strong>be a separate technical-debt backlog. Just one combined backlog.</p><p>If technical tasks and product-based tickets are put together developers will have to compete with their product-owners for prioritization.</p><p>This gives us an opportunity to</p><p>i) negotiate on the scope of a technical debt ticket with the PO</p><p>ii) a opportunity to think of thinner slices for fixing the technical debt</p><p>iii) remove the technical debt ticket if we see that it is not required.</p><h4>Tickets after continued “Refinement sessions”</h4><p>I have worked in many teams that continue to have backlog refinement sessions despite having enough tickets that are ready for development.</p><p>In most cases, I would not do this. It is a sure-shot way to lose control of the list of tasks you have to do as a team. Often teams refine and estimate tasks that wouldn’t be picked up any time soon.</p><p>Keep a view of the tickets that we couldn’t still refine, maybe due to the current topics under development.</p><p>This might be a trigger to review those backlog tickets and remove the ones that are not necessary.</p><h3>Conclusion</h3><p>These are simple points that I try to follow and what I advice new teams to keep their backlog under control.</p><p>Are there other approaches that worked for you? If so, I would like to hear them in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68773f812db" width="1" height="1" alt=""><hr><p><a href="https://experiencestack.co/help-my-backlog-is-out-of-control-68773f812db">Help, My Backlog Is Out of Control!</a> was originally published in <a href="https://experiencestack.co/">Experience Stack</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Trunk Based Development is no free lunch!]]></title>
            <link>https://vyvyd.medium.com/trunk-based-development-92bbad4bf7ce?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/92bbad4bf7ce</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[trunk-based-development]]></category>
            <category><![CDATA[team-collaboration]]></category>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Sun, 11 Sep 2022 16:45:14 GMT</pubDate>
            <atom:updated>2023-04-12T13:41:06.968Z</atom:updated>
            <content:encoded><![CDATA[<p>During some instances in my career, “Trunk-Based-Development” usually referred to a code integration process that <strong><em>meant</em></strong>:</p><ul><li>No Pull Requests</li><li>No Feature-Branching</li><li>Always Pair-Programming</li></ul><p>I believe that this is a very naive way of looking at Trunk-Based-Development, and often times, teams miss the forest for the trees.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T6HMKklTeeG6CTPhJphKaQ.jpeg" /><figcaption>Image by <a href="https://pixabay.com/users/ulleo-1834854/?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=2906702">Ulrike Leone</a> from <a href="https://pixabay.com//?utm_source=link-attribution&amp;utm_medium=referral&amp;utm_campaign=image&amp;utm_content=2906702">Pixabay</a></figcaption></figure><p>To do Trunk-Based-Development right — a team must not overlook the following:</p><h4>Discipline is key</h4><p>Trunk-Based-Development as practice demands discipline from individuals.</p><ul><li><strong>Task out their work</strong> and develop in <strong>small </strong>batches</li><li><strong>Ensure quality checks</strong> and safe-guards are in place for new features (TDD is a must!)</li><li><strong>Document</strong> enough for the next person working on that code</li></ul><p>Teams adopting Trunk-Based-Development in name but not practice, I usually see:</p><ul><li>Massive code-commits <em>encompassing changes from a day or more</em></li><li>Code or new features often tested <em>by-hand </em>or manually, which implies lack of safety nets for the future.</li><li>Severely <em>under-documented code</em> and very <em>unhelpful git-commit messages</em>.</li></ul><p>If your team is struggling with these problems while doing Trunk-Based-Development, maybe it’s time to think of falling back to a Pull-Request-Model. Use the technique as a <strong><em>learning-tool.</em></strong></p><h4>Culture</h4><p>Be very aware of team-dynamics and culture when introducing Trunk-Based-Development.</p><p>Take for instance <a href="https://martinfowler.com/bliki/CodeOwnership.html">collective code-ownershi</a>p.</p><p>In some teams, members would often get offended when some-one changed an area of code they considered “their own” without sending over a pull-request first, or asking for something akin to ‘permission’.</p><p>Maybe take the opportunity to fix those issues before diving into Trunk-Based-Development.</p><p>Can we use Trunk-Based-Development to build up culture?<strong> </strong>I think “it depends” on the ground situtation.</p><h4>Technical Excellence</h4><p>If a team is lacking good infrastructure and tooling, Trunk-Based-Development will make it stick out even more like a sore-thumb.</p><p>Take, for instance — build-times.</p><p>If a complete end-to-end deployment cycle takes about 15–30 minutes, multiple commits coming in at the same time will quickly bog down the build-system.</p><p>Another aspect that can stand in the way is the testing strategy used in the project. For instance — if there are no automated tests to cover the most important business flows, Trunk-Based-Development would actually slow you down instead of making you faster.</p><p>I would always say that this needs to be fixed <em>before </em>you do Trunk-Based-Development.</p><h4>Continuous Improvement</h4><p>I believe that a team does not automatically produce high-quality code on the first go just because of pair-programming (or) a having a working pull-request model in place.</p><p>Having a high-quality code-base is the result of continuous review and improvement.</p><p>I take some time of my day day going over commits of my colleagues over the past couple of days. I do it not because I might be a playing the role of a technical-lead or a senior developer, but to understand what’s happening in the code-base.</p><p>If I were to find areas of potential improvement, I usually pair with the original author(s). This is also an opportunity for me to understand the original intention of the code and to see if I missed something.</p><p>Another practice I would recommend for the team are code walk-through sessions to makes sure that all team-members are “on the same journey together” when it comes to coding practices, standards or how tests need to written with respect to the code-base.</p><p>Trunk-Based-Development without such a practice of continuous code-review will give rise to inconsistent code-bases, which gets in the way of long term maintenance.</p><h3>Conclusion</h3><p>On a personal note, I think Trunk-Based-Development is a fantastic way to work. But like every sharp tool, one must also be aware of the ways things can go wrong.</p><p>If you are going to adopt Trunk-Based-Development, set things up in the project right first so that such a move can be a successful.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92bbad4bf7ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mocking Spring RestTemplate]]></title>
            <link>https://medium.com/codex/mocking-spring-resttemplate-f38ef464d1de?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/f38ef464d1de</guid>
            <category><![CDATA[test-driven-development]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[spring-boot]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Fri, 19 Nov 2021 20:29:57 GMT</pubDate>
            <atom:updated>2022-02-19T22:35:11.660Z</atom:updated>
            <content:encoded><![CDATA[<p>Just don’t do it.</p><p>I’ve seen the following line of code (or it’s corresponding version in other languages) way too many times to be comfortable with it.</p><pre>val mockRestTemplate = mockk&lt;RestTemplate&gt;()</pre><p>I think it’s a terrible idea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hnVfx3sG1r1TgIwX" /><figcaption>Photo by <a href="https://unsplash.com/@lunarts?utm_source=medium&amp;utm_medium=referral">Volodymyr Hryshchenko</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3><strong>Don’t mock what you don’t own.</strong></h3><p>Why are tests that mock framework elements considered bad?</p><h4>They don’t help with refactoring</h4><p>Tests that mock out library components usually <strong>cannot be used for refactoring</strong>. The main reason for this is because these kind of tests usually “follow the code”. Due to this, we end up having to change test expectations every time you refactor code, even when the logic is unchanged.</p><p>As such, a major benefit of doing TDD is thrown right out of the window.</p><p>Let me present an example.</p><p>Say you have an APIClient class that makes a GET call to an external endpoint using a RestTemplate instance contained within in. When testing the APIClient class, the RestTemplate is mocked out and expectations are set on it.</p><pre><em>every </em><strong>{ <br>      </strong>template.postForEntity(<br>            &quot;/customers/4520&quot;, <br>            any(), <br>            CustomerDetailsResponse::class.java<br>      )<br><strong>} </strong>throws HttpServerErrorException(&quot;5xx from server&quot;)</pre><p>The mock is set up so that every POST call to the /customers/4520 endpoint will simulate the server responding with a 500 Internal Server Error.</p><p>The APIClient code that handles this 5xx response is then tested, using the mocked RestTemplate instance. All is good for today, the code is checked in, the pipelines are green, time for a pint at the local bar.</p><p>However — what happens if for some reason, we change the implementation, but the logic remains the same?</p><p>Say we use RestTemplate#exchange instead of RestTemplate#postForEntity ?</p><p>Now we see that we have to update the test expectations, even though there was no change in logic. <strong>The tests are no longer a safety net </strong>for the change that is about to be made.</p><h4>Limits a future upgrade</h4><p>Also — we cannot swap out the library for another one that does the exact same thing, without re-writing the tests. Again, this means there is no safety net for this change, which does not make it any better than not having written tests in the first place.</p><h4>Assumptions about external code</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/276/1*syn_yJ7EX1EA6tpm9WBrvA.png" /><figcaption><a href="https://xkcd.com/1339/">https://xkcd.com/1339/</a></figcaption></figure><p>In the example earlier we assume that the RestTemplate throwing a specific exception implies the remote server responded with a HTTP 500 Internal Server Exception.</p><p><strong>This is an assumption about the semantics and the contracts between your application and the library.</strong></p><p>If a future upgrade of the library were to change these semantics, there is no safety net anymore, and a bug slips through undetected.</p><p>If this assumption was made in many places in the code-base, that the impact is much more.</p><h3>What’s the alternative?</h3><h4>Mock-servers provided by the library</h4><p>Most libraries provide a fake implementation of a web-server so that you can test your API client classes.</p><p>However, I end up being a bit vary about them, because they are in the end, ‘tied’ to the library. In the event of swapping out the library for another, these kind of tests may not help.</p><h4><strong>WireMock</strong></h4><p>This is my preferred approach these days, chosen mostly for the maturity of the tool. Since they are completely independent from implementation detail, I believe they can be more resilient in the time to come.</p><p>There are guides you will be be able to find that will detail how to use WireMock in the JVM, and I suggest you have a look if it suits your needs. I’ve added the official <em>Getting Started with JUnit5 reference </em>at the bottom.</p><h3>Conclusion</h3><p><strong>Don’t forget value</strong> when it comes to tests.</p><p>If tests only help us with double entry book-keeping when it comes to writing code, but does not provide a safety net for future change, I believe value is on the lower end of what you can have.</p><p>As such, choose to have a more resilient approach to testing API clients.</p><h4>References</h4><ol><li><a href="https://8thlight.com/blog/eric-smith/2011/10/27/thats-not-yours.html">https://8thlight.com/blog/eric-smith/2011/10/27/thats-not-yours.html</a></li><li>Dont Mock Types you don’t own <a href="https://testing.googleblog.com/2020/07/testing-on-toilet-dont-mock-types-you.html">https://testing.googleblog.com/2020/07/testing-on-toilet-dont-mock-types-you.html</a></li><li>Using Wiremock with JUnit 5 <a href="http://wiremock.org/docs/junit-jupiter/">http://wiremock.org/docs/junit-jupiter/</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f38ef464d1de" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/mocking-spring-resttemplate-f38ef464d1de">Mocking Spring RestTemplate</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do you track onboarding progress?]]></title>
            <link>https://vyvyd.medium.com/do-you-track-onboarding-progress-4d14c9b97e3a?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d14c9b97e3a</guid>
            <category><![CDATA[onboarding]]></category>
            <category><![CDATA[employee-engagement]]></category>
            <category><![CDATA[team]]></category>
            <category><![CDATA[information-technology]]></category>
            <category><![CDATA[onboarding-tools]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Sun, 27 Jun 2021 20:06:10 GMT</pubDate>
            <atom:updated>2024-04-01T04:55:50.520Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MnqlCVLSCHQZG6A9-V4fpA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@kaleidico?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Kaleidico</a> on <a href="https://unsplash.com/s/photos/whiteboard?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>Working at a software consultancy means that I might have to switch clients and projects often. This sets me up for being part of onboarding processes frequently — which in many cases can be very unstructured and ad-hoc.</p><p>I don’t like that. We wanted to do things a bit different in my last project.</p><h3>Our approach</h3><p>Every newcomer to the project gets their individual onboarding board that might look like this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EIzczNK2OtNnEofKCJ_Z3g.jpeg" /></figure><p>This board was created through a GitHub <a href="https://docs.github.com/en/issues/organizing-your-work-with-project-boards/managing-project-boards/about-project-boards">Project Board</a>. If you use other tools like GitLab, they may have some <a href="https://about.gitlab.com/stages-devops-lifecycle/issueboard/">similar</a> feature. Or you might even have <a href="https://trello.com/">Trello</a> at your organization.</p><h4>The cards</h4><ul><li>are ordered</li><li>should include catch-up tasks in-between to ensure to get feedback</li><li>can contain additional information. For instance, links to existing documentation.</li></ul><p>We wrote a simple python script to copy over a <em>template </em>project board for every new employee on the project.</p><h3>Purpose</h3><h4>Track onboarding progress per team member</h4><p>Most of these tools provide a way to visualize progress.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*mWRtgVx9MOnrDxmlOwQWWg.png" /></figure><p>This allows the person being on-boarded with where they are on their onboarding journey.</p><p>For managers and existing team-members, this could serve as a visual cue to indicate whether existing team-members need to intervene and unblock their new colleagues.</p><h4>Iterative Improvement</h4><p>Post the onboarding process, people will come across problems that make them go<em> “This is something I should have known during my onboarding”</em></p><p>If you have a structured <em>template</em> for onboarding tasks, then it can be updated with these new-found topics.</p><h4>“It takes a village…”</h4><p>Conducting onboarding sessions is usually a tech-lead or engineering lead responsibility in many teams.</p><p>But we need to involve the rest of the team. Having an onboarding board will make it easier for other team-members to <em>visualize</em> what new-comers to their project are going to have to know.</p><p>Other team-members can then sign up for some of these onboarding tasks. Not only does this avoid knowledge silos but it also reduces the workload for the tech-lead or engineering lead.</p><p><strong>Also, this is a very functional way for the new-comer to meet different people of the team, and build working relationships.</strong></p><p>Never throw a set of documentation and manuals to someone on the onboarding journey. Instead, always supplement documentation and manuals with 1:1 interactions.</p><h4>Offboarding</h4><p>Tasks that involve providing access to systems must be reversed when the employee leaves the team.</p><p>Having these kind of tasks tracked will make it easier to collate off-boarding actions (or they could be tasks on a separate offboarding board). This avoids the possibility of missing out revoking accesses for an particular system, which can be a security nightmare.</p><h3>Conclusion</h3><p>A Gallup study of US based workplaces in 2019 stated that only <a href="https://www.gallup.com/workplace/238085/state-american-workplace-report-2017.aspx">12%</a> of employees felt that their organization did a good job at onboarding. Not all teams do onboarding well.</p><p>One way to improve onboarding do this is to have structure in place that enables collection of feedback and iterate for a better solution with every new employee. The technique of tracking using cards is just one approach.</p><p>Arguably, we could also get similar results with recording tasks in a Google Document instead of a full fledged card-wall. That however, will depend on your project.</p><p>On a personal note, however, nothing beats the satisfaction of moving a card from the “In Progress” column to the “Done” column. What do you think?</p><h3>References</h3><ol><li><a href="https://www.gallup.com/workplace/238085/state-american-workplace-report-2017.aspx">https://www.gallup.com/workplace/238085/state-american-workplace-report-2017.aspx</a></li><li>Project Boards in Github — <a href="https://docs.github.com/en/issues/organizing-your-work-with-project-boards/managing-project-boards/about-project-boards">https://docs.github.com/en/issues/organizing-your-work-with-project-boards/managing-project-boards/about-project-boards</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d14c9b97e3a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Keeping Focus with Pomodoro and Google Calendar]]></title>
            <link>https://vyvyd.medium.com/keeping-focus-with-pomodoro-and-google-calendar-ee230e3a2b77?source=rss-6d7723c134f9------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee230e3a2b77</guid>
            <category><![CDATA[time-management]]></category>
            <category><![CDATA[focus]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[work]]></category>
            <category><![CDATA[pomodoro]]></category>
            <dc:creator><![CDATA[Vineeth Venudasan]]></dc:creator>
            <pubDate>Sun, 06 Jun 2021 18:58:01 GMT</pubDate>
            <atom:updated>2021-12-02T14:51:58.936Z</atom:updated>
            <content:encoded><![CDATA[<p>I devised a few ways to keep track of my time and to maintain focus during the “new-normal” (as they say) WFH days . Thought maybe it might be useful to someone else too.</p><h4>What problem was I trying to solve?</h4><ul><li>Get into <a href="https://www.collinsdictionary.com/dictionary/english/in-the-zone">the zone</a> often</li><li>To find an answer to “Where did my day go?” at the end of the day</li><li>Streamline and manage interruptions</li></ul><h4>Tools and Techniques</h4><ul><li>The well-known Pomodoro technique</li><li>Google Calendar</li><li>Task Breakdowns</li></ul><h3>What I do</h3><ul><li>From the work at hand, carve out a chunk that could be finished in 15 minutes, nothing more.</li><li>Block the next 15 minutes in your calendar. This is what I call a <strong><em>session</em></strong><em>.</em></li><li>The <em>aim</em> of the session is to complete the planned subset of work</li><li>Spend the next fifteen minutes executing this plan. <strong>Do everything you can to reduce distractions. </strong>For instance in my specific case, <em>I will not respond to any chat messages/emails right away</em>.<em> </em>I let this accumulate, but I will have an eye on how often the notifications come in.</li><li>At the end of 15 minutes, one of two things have happened. Either we were able to achieve what we set out to do in the <em>aim</em>, or maybe not. Either way, that only decides what we do for the next <em>session.</em></li></ul><h4>With every successful session</h4><ul><li>If we were able to complete what we set out to do, great planning! See why this was possible, and do more of this when planning subsequent sessions.</li></ul><h4>With every failed session</h4><ul><li>If not, then what I usually do is to reduce scope and see what can be done in the next session so that I can complete what could not be completed earlier. I also make sure that the session is named such that I can try how many <em>failed</em> (so to speak) sessions I had in a particular day</li></ul><h4>What about those chat messages and emails?</h4><p>Attending to chat messages and emails are a planned session in itself.</p><p>Since I had been keeping watch on their number (as mentioned before), I can plan sessions for emails and chats with some certainty. But needless to say, it’s not perfect.</p><h4>Breaks</h4><p>I plan for a 15 break session after every 45 minutes, or after an hour of continuous work. However, if I need a break sooner, I will take it — it’s just that it needs to be tracked.</p><h3>Result</h3><p>On a good day, a calendar should look something like this</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WUf6yqxC-FQivKwpf-4SMA.jpeg" /></figure><p>But why the colors you might be thinking?</p><p>I use that to see how much of my day was spent actively coding / collaborating, in meetings, and how often I take my breaks. This allows me to know a “typical day” for myself.</p><p>This is very valuable information for me especially if I have to estimate how long something would take for me, and also is a good tool that I can use to <a href="https://www.nytimes.com/2017/05/08/smarter-living/why-you-should-learn-to-say-no-more-often.html">say no</a> more often.</p><h3>Conclusion</h3><p>The method isn’t perfect.</p><p>It’s more or less agile principles of iterative improvement applied on day-to-day working on a personal level. It’s nothing new, it’s very ordinary.</p><p>My biggest takeaway from the method is to answer the “where did my day go?” question I often had.</p><p>This method is something that am actively doing everyday, hoping to perfect it over time. But maybe you are ahead of the curve. Maybe you have tried this and have suggestions.</p><p>I’m more than happy to hear them in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee230e3a2b77" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>