<?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 Sevil on Medium]]></title>
        <description><![CDATA[Stories by Sevil on Medium]]></description>
        <link>https://medium.com/@sevillguler?source=rss-7aec6a1057f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bcSn56KyS4Z6G9xj2CT77Q.jpeg</url>
            <title>Stories by Sevil on Medium</title>
            <link>https://medium.com/@sevillguler?source=rss-7aec6a1057f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 17:03:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sevillguler/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[Maybe We Should Stop Calling It Platform Engineering]]></title>
            <link>https://blog.stackademic.com/maybe-we-should-stop-calling-it-platform-engineering-47c199edfebd?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/47c199edfebd</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 22:34:29 GMT</pubDate>
            <atom:updated>2026-09-24T01:45:47.872Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yYeWNqxyj7GaH1_IE8J1xw.png" /></figure><p><strong>TL;DR:</strong> Companies keep asking why engineers are not moving faster while underinvesting in the engineering system around them.</p><p>The cost of Platform Engineering is easy to see. The cost of not investing in it is scattered across slower delivery, duplicated work, fragile releases, flaky tests, longer incidents, weak observability, and endless engineering friction.</p><p>Unfortunately, we called it <em>Platform Engineering</em>, a name that does a terrible job of communicating the impact it can have on all of that. 😅</p><p>Companies love talking about engineering velocity. Why are teams slow? Why does delivery take so long? Why are engineers not shipping more?</p><p>Then you look underneath and the picture gets less flattering.</p><p>The codebase is spaghetti, the architecture is tightly coupled, and changing one thing can require coordinating with four teams. Tests are missing, weak, or flaky. Release processes are manual and fragile. Mobile releases depend on environments that only a few people really understand. In many companies, observability barely exists.</p><p>And then, somehow, the conclusion becomes:</p><p><strong>Maybe the engineers are not productive enough.</strong></p><p>Sure. 😅</p><h3>Engineers are usually not the bottleneck</h3><p>I have seen teams where engineers are working nonstop on feature development. They are designing, coding, reviewing, fixing bugs, and trying to ship. The problem is that they are doing all of that inside systems where even small changes can have an unpredictable blast radius, where dependencies cross team boundaries, where test coverage does not create enough confidence, and where a release can become a project of its own.</p><p>Engineers become cautious because the system teaches them to be cautious. If touching one component can unexpectedly break something completely unrelated, every change carries risk. But the team rarely gets the space to stop and fix the foundations properly because they still need to keep delivering features.</p><p>So they keep delivering on top of the same fragile architecture, which makes every new change harder, which makes them more cautious, which slows delivery, which creates even more pressure to deliver faster.</p><p>You can probably see where this is going. 😵‍💫</p><p>A dependency owned by another team can block delivery. A release can trigger hours of validation, rollback discussions, or hotfixes. When something goes wrong, poor observability turns diagnosis into guesswork.</p><p>From the outside, this can look like low velocity. From the inside, it often feels like everyone is running through mud.</p><p>Hiring faster runners does not fix the mud either. 🏃‍♀️💨</p><p>The underlying problem is usually much bigger than individual productivity. It is the engineering system itself: architecture, dependencies, tooling, test quality, release processes, observability, standards, and all the friction that slowly accumulates until even simple changes become expensive.</p><p>And this is exactly the kind of problem platform engineering should be helping to solve.</p><p>The trouble is that when people hear <strong>Platform Engineering</strong>, they often do not think about any of this.</p><p>And when platform engineering is understood mainly as infrastructure and tooling, its value becomes much harder to see.</p><h3>When the value is hard to see</h3><p>When people hear platform engineering, they often think of Kubernetes, CI/CD, cloud accounts, developer portals, some YAML, and maybe Backstage if we are lucky. 😄 The conversation often stops at the tooling, with little curiosity about the engineering problems those tools are meant to solve or the outcomes they are supposed to improve.</p><p>And when that is the mental model, platform becomes easy to treat as overhead.</p><p>A platform team is visible: engineers, infrastructure, budget. The cost of not having one is much harder to see because it gets scattered across everything else: slower delivery, duplicated tooling, fragile releases, repeated hotfixes, long incidents, and product teams solving the same problems again and again.</p><p>So platform looks expensive because its cost is visible. Its absence looks cheap because the cost is distributed.</p><p>That is a pretty convenient accounting trick.</p><p>And that is how underinvestment happens. Not necessarily because anyone decides that engineering foundations do not matter, but because there is always something whose value looks more immediate. Another feature has to ship. Another launch cannot move. Another quarter has commitments attached to it. Foundational work becomes the thing everyone agrees is important and nobody gives enough time to actually do.</p><p>Meanwhile, the damage is not standing still.</p><p>The fragile release process keeps consuming engineering time. Weak observability means incidents take longer to detect and much longer to understand. Poor test quality means regressions escape more easily, which creates more hotfixes, more manual verification, and even less confidence in the next release. Tight coupling makes changes riskier, so teams coordinate more, review more cautiously, and avoid touching parts of the system they no longer trust.</p><p>The team is still expected to deliver through all of this.</p><p>So the obvious shortcuts appear. Another script. Another manual check. Another exception. Another workaround that was supposed to be temporary. Another team builds its own tooling because the shared solution does not exist. Another dependency is added because fixing the boundary properly would jeopardize the deadline.</p><p>Each one solves the immediate problem.</p><p>Together, they make the engineering system worse.</p><p>And the cost does not just show up as slower engineers. It shows up as slower product delivery, more defects reaching users, longer incidents, repeated hotfixes, duplicated engineering work, fragile releases, higher infrastructure and maintenance costs, and senior engineers spending their time keeping broken systems alive instead of improving the product.</p><p>Eventually the organization is not merely carrying technical debt. It is paying interest on it every day.</p><p>And because the company still manages to ship something, it can take a surprisingly long time before anyone treats the underlying problem as urgent.</p><p>That interest tends to surface in a few recurring places: teams repeatedly solving the same problems because there are no shared standards or common tooling, weak quality systems that make changes harder to trust, and poor observability and release processes that make failures expensive to detect and recover from.</p><p>Those are not separate problems. They are different symptoms of the same underinvestment in the engineering system.</p><h3>No standards means everyone pays</h3><p>Lack of standards is another form of hidden cost.</p><p>In many organizations, every team chooses its own patterns, release process, observability setup, testing strategy, deployment tooling, service structure, dependency management, and definition of what “production ready” actually means.</p><p>That can look like autonomy.</p><p>Sometimes it is.</p><p>Sometimes it is just distributed reinvention. 👀</p><p>One part of the product builds its own version of the same basic capability. Another part builds it again with slightly different assumptions. A third does the same because there is no shared building block to start from.</p><p>Soon the company has several versions of essentially the same thing, all solving slightly different local needs, all needing to be maintained separately.</p><p>The same thing happens with CI wrappers, service templates, release tooling, observability libraries, local development environments, test infrastructure, dependency tooling, and all the little pieces engineers create because nothing consistent exists.</p><p>And this is where the cost becomes interesting.</p><p>You are not paying for the tool once. You are paying several teams to design it, build it, debug it, secure it, document it, upgrade it, and maintain it for years.</p><p>The initial implementation is usually the cheap part.</p><p>A company can convince itself it is saving money by not investing in a proper platform capability while quietly paying far more across dozens of product teams.</p><p>The cost is simply fragmented enough that nobody sees the invoice. 💸</p><p>Good standards do not mean forcing every team into the same box. They mean having sensible defaults, paved roads, and reusable tooling so engineers do not need to make every low-level decision from scratch.</p><p>Autonomy is valuable when teams are deciding things that actually matter to their product.</p><p>It is much less exciting when several teams are independently solving the same underlying problem in different parts of the product.</p><h3>A green pipeline does not mean quality</h3><p>Product teams obviously own product quality, but they do not create quality in a vacuum. The engineering system around them determines how easy it is to test a change, how quickly engineers get feedback, how much they trust that feedback, and how confidently they can ship.</p><p>In many companies, there is no real testing strategy behind the pipeline. There may be unit tests, a few integration tests, some UI tests, and a layer of manual validation that has grown over time. Different frameworks get introduced by different people, tooling appears when a particular need becomes painful enough, and eventually the company ends up with a collection of tests rather than a coherent quality system.</p><p>Sometimes the problem goes even deeper because the software was never designed to be testable in the first place. Business logic is buried inside UI code, components are tightly coupled, dependencies are difficult to isolate, and testing one small behavior requires booting a large part of the application. In that environment, telling engineers to “write more tests” misses the point. If the architecture actively resists testing, the problem is not simply a lack of discipline.</p><p>Even when the architecture allows testing, the tests themselves may provide surprisingly little confidence. Weak tests create false confidence, flaky tests gradually teach engineers to ignore failures, and slow test suites encourage people to avoid running them unless they absolutely have to. A pipeline can be green while protecting very little.</p><p>This is where platform engineering should matter much more than simply providing CI infrastructure.</p><p>Product teams are focused on building the product. They are expected to deliver features, fix bugs, respond to customers, and meet deadlines. It is unrealistic to expect every team to also continuously evaluate testing frameworks, improve testability, investigate systemic flakiness, build shared tooling, decide which kinds of tests belong at which level, and measure whether the overall feedback loop is actually improving.</p><p>Someone needs to look at those problems across the engineering system.</p><p>The question should not only be whether tests are running, but whether they are useful. Are systems easy enough to test? Do engineers have sensible frameworks and tooling? Is feedback fast enough to influence how people work? Are flaky tests destroying trust? Are we testing the right things at the right level? Are we spending large amounts of compute on tests that rarely catch anything meaningful?</p><p>Companies naturally gravitate towards metrics that are easy to count: number of tests, code coverage, pipeline success rate. Those numbers can be useful, but the more important question is whether the engineering system can give engineers meaningful confidence that a change is safe.</p><p>This matters even more for mobile. A backend problem can sometimes be fixed and deployed within minutes. A mobile fix has to be built, signed, validated, submitted to a third party, reviewed, published, rolled out, and then actually adopted by users. Once a bad version is in users’ hands, recovery is slower and much less controllable.kubectl rollback is unfortunately not an App/Play Store feature. 😄</p><p>A strong platform team should therefore do more than provide somewhere for tests to run. It should help create the architecture, tooling, frameworks, and feedback loops that make quality achievable in the first place, and give teams a reason to trust what “green” actually means.</p><h3>Observability and releases are part of the same problem</h3><p>We often talk about observability as if every engineering organization already has it and the only remaining question is which dashboard looks nicest.</p><p>That is not reality.</p><p>In many companies, when something goes wrong, the most important data simply does not exist. Engineers know that an error happened, but not what led to it, which users are affected, which version introduced it, what the system was doing immediately before it failed, whether it is happening repeatedly, or whether the same problem has started appearing somewhere else.</p><p>Instead, they reconstruct the story afterwards from logs, CI output, deployment history, Slack messages, and memory.</p><p>That is not observability. That is archaeology. 🏺</p><p>Good observability should give engineers the context around a failure. What happened before it? Which release was running? Which environment, device, OS version, feature flag, request, dependency, or user journey was involved? When did the problem start? How often is it happening? Did it appear immediately after a deployment? Did the latest release make it better or worse?</p><p>A useful engineering system should leave that trail automatically. Engineers should not have to realize during an incident that the one piece of data they need was never collected.</p><p>Mobile makes this even harder because production is fragmented across app versions, operating systems, devices, rollout states, feature flags, and backend versions. A failure might affect only one particular combination, while thousands or millions of users continue running older versions you can no longer change.</p><p>Release engineering is part of the same problem. A change should be traceable through build, test, deployment, rollout, and production, so when behavior changes, engineers can connect what users are experiencing back to what the company actually shipped.</p><p>This is where platform engineering should create leverage: not simply by providing CI, deployment tooling, or dashboards, but by building the foundations that make software explain itself when something goes wrong.</p><p>Testing, CI, releases, and observability are not separate concerns. Together, they should help answer two very basic questions:</p><p><strong>What happened? And what changed?</strong></p><p>If the engineering system cannot answer those questions, engineers are left debugging the process as well as the product.</p><h3>Then AI arrives 🤖</h3><p>Now everyone is excited about AI developer productivity.</p><p>Generate more code. Generate more tests. Generate more pull requests. Great.</p><p>But what happens when you dramatically increase code production inside a system that already struggles with architecture, testing, observability, standards, and releases?</p><p>You may not get more velocity.</p><p>You may just manufacture spaghetti faster. 🍝</p><p>More code is not automatically more value. You can generate 30% more code and also generate 30% more things nobody knows how to validate.</p><p>That is not velocity. That is throughput without control.</p><p>And this is another place where I think the platform mindset matters.</p><p>If an organization wants AI to improve engineering productivity, somebody needs to think beyond buying licenses. How do these tools fit into the development lifecycle? How do we validate generated code? How do we handle security? How do we avoid duplication? How do we measure whether quality is getting better or worse? How do hundreds or thousands of engineers use AI in a way that is consistent enough to actually learn from?</p><p>A focused group with a clear goal can make AI adoption cleaner, safer, and much more useful.</p><p>Buying licenses is not a strategy.</p><h3>So why do companies underinvest in platform engineering?</h3><p>Because the cost of building a strong platform capability is easy to see, while the cost of not having one is scattered across the organization and much harder to measure.</p><p>A platform team appears clearly on an org chart. There are engineers, infrastructure costs, tooling costs, and a budget line someone can point at and question.</p><p>The alternative is much less visible.</p><p>There is no budget line for the hours engineers lose to bad tooling. No invoice for duplicated internal systems. No report showing how much slower releases became because the architecture is fragile, how much senior engineering time disappeared into debugging problems that better observability could have explained much faster, or how much product quality deteriorated because the testing and delivery system failed to catch problems early.</p><p>Often, companies cannot even quantify that last part. They do not know which tests are actually protecting them, how many defects should have been caught earlier, or how much engineering effort is being spent manually creating confidence that the system itself should have provided.</p><p>Most of that waste simply gets absorbed into normal work: another manual release step, another flaky test rerun, another team rebuilding something that already exists elsewhere, another incident that takes hours to understand, another feature that takes twice as long because changing one thing touches several other systems.</p><p>The problem is that these costs rarely add up in one place.</p><p>And platform engineering has another disadvantage: its value is often indirect.</p><p>A product feature can be connected to revenue, growth, retention, or a launch. Better testing infrastructure, safer releases, stronger observability, faster feedback loops, and less duplicated tooling are much harder to translate into one obvious financial result.</p><p>For leaders who are not close to the engineering system, that makes the value easy to underestimate. The investment is visible immediately. The return appears gradually, spread across faster delivery, fewer incidents, better quality, lower maintenance costs, and engineering time that is no longer being wasted.</p><p>So the platform team can look expensive while the cost of operating without a strong platform capability looks almost free.</p><p>That is how underinvestment becomes easy to justify.</p><p>Not because the value is not there, but because much of it never appears as one obvious number on a financial report.</p><h3>The name hides the outcome</h3><p>This is why I increasingly think <strong>Platform Engineering</strong> is a problematic name.</p><p>Not because the work is wrong, but because people often hear “platform” and think about the implementation: infrastructure, Kubernetes, CI, cloud accounts, internal tooling.</p><p>They do not immediately think about engineering velocity, product quality, release safety, observability, standards, architecture, or the cost of duplicated work across teams.</p><p>The name hides the outcome behind the implementation.</p><p>And that matters because once platform engineering is reduced to infrastructure and internal tooling, it tends to be evaluated at that level too. People see the engineers, the cloud bill, the CI costs, and the tools being built. What is much harder to see is the engineering time being recovered, the failures being prevented, the duplicated work disappearing, or product delivery becoming faster and safer.</p><p>I think this bothers me because I have seen the same pattern in different companies. Engineers work hard, product teams are under constant pressure to move faster, and yet the engineering system around them makes every change more expensive than it needs to be.</p><p>The dangerous part is that once these problems become routine, people stop seeing them as problems at all. Slow releases become “just how releases work.” Flaky tests become “just CI.” Poor observability becomes “just how incidents are.” Duplicated tooling becomes “team autonomy.” Fragile architecture becomes something everyone works around instead of something anyone expects to fix.</p><p>A lot of the value of platform engineering is not in producing something shiny that everybody can point at. It is in identifying the friction, risk, duplication, and manual work that the organization has learned to accept as normal, and then systematically removing it.</p><p>Platform engineering, at its best, challenges that normalization by asking how much of the friction engineers experience is actually necessary.</p><p>Anyway, I am home alone tonight, so naturally I used the opportunity to write 1,500 words about engineering infrastructure.</p><p>Everyone has hobbies. 😂</p><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us"><strong>here</strong></a><strong>.</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=47c199edfebd" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/maybe-we-should-stop-calling-it-platform-engineering-47c199edfebd">Maybe We Should Stop Calling It Platform Engineering</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your Git History Is an API]]></title>
            <link>https://medium.com/@sevillguler/your-git-history-is-an-api-bad56698930f?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/bad56698930f</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Mon, 27 Apr 2026 05:15:45 GMT</pubDate>
            <atom:updated>2026-04-27T06:43:13.639Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W5OjBq4J1GscLnETycPzKg.png" /></figure><h3>I asked a room full of engineers if their release flow still depends on human interpretation. 77% said yes.</h3><p>I gave a talk at GDG Android Stockholm last week. The title was “Your Git History Is an API.” Before diving in, I threw a poll at the audience: <strong>“How much of your release flow still depends on human interpretation?”</strong></p><p>The results were not surprising to me. But they were honest.</p><ul><li><strong>46%</strong> said “some important parts”</li><li><strong>31%</strong> said “more than we want”</li><li><strong>8%</strong> said “almost everything”</li><li><strong>15%</strong> said “very little”</li><li><strong>0%</strong> said “almost none”</li></ul><p>That means three out of four engineers in that room were doing manual work somewhere in their release process, work that exists not because it’s valuable but because the system doesn’t have enough signal to act on its own.</p><p>Then I asked: <em>after this talk, what would create the most value fastest in your team?</em></p><p>The winner, by a clear margin, was <strong>“better AI-assisted summaries from Git history.”</strong> Followed closely by <strong>“better commit structure.”</strong></p><p>That’s the problem, and the opportunity, in two data points.</p><p>The talk ended before I could show how the pieces connect in practice. So I wrote it all out here instead.</p><p>Please note that, there is a lot of content out there about how to write Conventional Commits. This post is not about that. This is about why it matters as a system, the downstream effects on versioning, AI tooling, release automation, test plans, and team communication and collaboration. And with AI becoming part of every delivery workflow, getting this right matters more than ever.</p><h3>Git history is a missed opportunity</h3><p>Most teams treat Git history as a record: something you look at after the fact when you need to understand what happened. It’s there, it’s useful occasionally, and it’s largely ignored the rest of the time.</p><p>That’s the missed opportunity.</p><p>Your Git history is already touching everything in your delivery system. Tools like Release Please parse it to decide version numbers. Modern pipelines use commit message content as conditional logic. AI summarisers consume your commit log and the changed code itself to draft release notes. PR summarisers run on your history to explain changes to reviewers, including surfacing risks.</p><p>Your commit message (the string you typed in three seconds) is already doing a lot of heavy lifting. The question is just whether it’s doing it well or poorly.</p><p>When that string is fix: update api or wip: formatting changes or just Post review updates to import, the signal is too weak for the systems consuming it:</p><ul><li><strong>Versioning</strong> becomes interpretive. Was that a patch? A minor? Someone has to decide.</li><li><strong>Release preparation</strong> becomes reconstruction. Someone digs through PRs and memory to figure out what actually shipped.</li><li><strong>Generated release notes</strong> become shallow or misleading. Garbage in, garbage out, at scale.</li><li><strong>QA focus</strong> gets blurry. Nobody’s sure what’s customer-facing and what isn’t.</li><li><strong>Release knowledge</strong> lives in people, not in the system.</li></ul><p>But flip that around, make the history structured and intentional, and all of those systems get dramatically better inputs. The same tools, the same pipelines, the same AI, producing much better output. No new infrastructure required.</p><h3>What actually changes when you fix this</h3><p>This is the part most posts skip. They tell you <em>how</em> to write better commits. I want to explain <em>what becomes possible</em> once you do, and I’m not describing a vision here. Most of what follows is running in production where I work.</p><h3>1. Git history becomes structured data, not just text</h3><p>If commits are written well using something like Conventional Commits, they stop being “notes” and start being machine-readable signals.</p><p>Instead of:</p><pre>fix: auth issue<br>fix: update api<br>fix(settings): adjust spacing<br>Add dark mode support<br>Fix/dashboard improvements<br>wip: formatting changes<br>docs: added comments<br>Update readme.md<br>Post review updates</pre><p>You get:</p><pre>feat(checkout): add offline mode for card payments during connectivity loss<br>fix(receipt): correct VAT rounding on split tender transactions<br>feat!: remove support for legacy barcode scanner protocol v1</pre><p>That distinction matters more than it looks. AI models and automation can now understand <strong>intent</strong>, not just diff. feat! tells a machine there&#39;s a breaking change. fix(payment) tells it exactly where. feat tells it this is user-facing. None of that is guesswork.</p><p>But there’s a second layer that most teams don’t think about: <strong>the ticket number</strong>.</p><pre>feat(cart): PAY-234 Add split payment support<br>fix(sync): INV-560 Prevent duplicate stock updates</pre><p>That ticket reference isn’t just for human traceability. It’s a pointer into a whole world of structured data that already exists in your issue tracker: the ticket title, description, acceptance criteria, linked PRs, comments, labels.</p><p>And when that connection is made, the commit becomes a <strong>key that unlocks much richer context</strong>:</p><ul><li>A well-written ticket has acceptance criteria → AI can generate test cases directly from them</li><li>It has a description of the problem → AI can write a far more accurate release note than any commit message alone</li><li>It has labels and priority → AI can assess risk and flag what needs extra QA attention</li><li>It has comments → AI can surface the “why” behind a decision, not just the “what”</li></ul><p>The commit message tells you <em>what happened</em>. The ticket tells you <em>why it matters and what was expected</em>. The groundwork for connecting them is already laid. We just haven’t pulled that thread yet.</p><h3>2. Git history becomes part of your delivery system</h3><p>This is the shift most teams miss entirely.</p><p>Once your history carries reliable intent, it can directly drive:</p><ul><li><strong>Versioning</strong>: semantic versioning automation determines patch/minor/major with no debate</li><li><strong>Release notes</strong>, AI generates them from the Git history and the changed code itself, producing summaries accurate enough to ship with minimal editing</li><li><strong>Test plans</strong>: AI uses the diff and commit context to produce a focused test plan: what changed, what’s at risk, what needs attention</li><li><strong>Risk analysis and impact assessment</strong>: before anyone has read a single commit manually, AI has already flagged which changes are high-risk and what the blast radius looks like</li><li><strong>Deployment decisions</strong>, a breaking change commit can trigger a slower rollout; an internal ci: commit can skip production gating entirely</li></ul><p>The mental model shift is:</p><blockquote><em>~~”We prepare the release manually”~~ </em><strong><em>“The release is derived from Git history automatically”</em></strong></blockquote><p>That’s not a productivity gain. That’s a different relationship between your team and your delivery system. Version bumps are automatic. Release PRs are created without anyone pressing a button. The changelog, the test plan, the risk summary: generated and ready before a human touches the release.</p><h3>3. AI removes the interpretation bottleneck</h3><p>Before structured history, the release process had a human in the middle doing work that felt important but was mostly mechanical:</p><ul><li>Read the commits</li><li>Understand what changed</li><li>Rewrite it into release notes</li><li>Decide what matters for which audience</li></ul><p>With structured history and access to the changed code, AI can take that over, and do it for multiple audiences simultaneously. The same source produces a QA-focused test plan with risk analysis, a customer-facing changelog of new features, and an internal impact summary of what might break. We get all of these from a single release trigger, without anyone sitting down to write them.</p><p>The key difference: <strong>human interpretation is no longer the bottleneck.</strong> Humans are still in the loop: reviewing, approving, judging the things that actually need judgment. They’re just not doing the mechanical reconstruction anymore.</p><p>The goal is simple: stop spending human time on things machines can do reliably.</p><h3>The real advantages (not theory)</h3><p>Let me be specific about what you actually gain in practice.</p><p><strong>Predictability.</strong> Version bumps are automatic, releases are consistent, and there are no surprises. Same input → same output, every time. That sounds boring. It should sound boring. That’s the goal.</p><p><strong>Speed without chaos.</strong> Usually, moving faster creates more chaos. With structured commits and AI in the loop, speed increases <em>because</em> clarity exists. You ship more confidently, not more recklessly.</p><p><strong>Trustworthy communication.</strong> Customer release notes, internal summaries, and support documentation are generated from the same source of truth. No more “wait, what actually changed?” conversations before a release.</p><p><strong>Test plans and risk analysis, generated automatically.</strong> AI infers which modules changed, which areas carry more risk, and produces a focused test plan rather than “test everything.” We also get a risk analysis and impact assessment as part of the release output, before anyone has manually read a commit. When we eventually connect this to ticket data too, acceptance criteria become test specifications directly. But even without that, what we have now already saves significant time and catches things that would otherwise slip through.</p><p><strong>Scales with your organization.</strong> Manual processes break at scale. A release manager who holds all the knowledge in their head is a scaling problem waiting to happen. Git-history-driven automation works for 5 engineers and for 500, because it removes human dependency from the repetitive steps.</p><h3>Conventional Commits: not a style guide, a schema</h3><p>I asked the audience at GDG Android Stockholm whether they use Conventional Commits. About half said yes. But only 5 out of 31 had them enforced (3 out of 5 can be my colleagues :D ) . That gap is the problem. Familiarity without enforcement means leaving stability, clarity, efficiency, and scalability on the table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8Gi719Y_UmccNg2UXUi5SQ.png" /></figure><p>The mechanism behind all of this is <a href="https://www.conventionalcommits.org/">Conventional Commits</a>. And I want to be clear about why they matter: because it’s easy to dismiss them as another formatting standard for pedantic engineers.</p><p>They’re interesting because they make intent explicit. A commit message is no longer a note to your future self. It becomes a structured signal:</p><pre>feat(cart): PAY-234 Add split payment support<br>fix(sync): INV-560 Prevent duplicate stock updates<br>feat!: CORE-4040 Remove legacy inventory endpoint<br>ci(android): run UI tests on release branches</pre><p>From those four lines, automation can:</p><ul><li>Know this release contains a new feature, a bug fix, and a <strong>breaking change</strong></li><li>Determine the correct semver bump without human input</li><li>Group the changelog correctly</li><li>Skip the internal CI commit from customer-facing notes</li><li>Link every meaningful change back to a ticket, and from the ticket to everything else</li></ul><p>Compare that to fix: update api, Add split payment support, wip: formatting changes. Same work. Completely different signal quality.</p><h3>“Can’t we just get this from the project management system?”</h3><p>Yes, and no.</p><p>Your PM system has tickets, descriptions, acceptance criteria, status updates. In theory, AI could read all of that and produce release notes, test plans, and risk assessments without ever touching Git.</p><p>The problem is that the PM system depends entirely on human discipline to stay accurate. Tickets get forgotten. Work happens that never gets a ticket. Tickets get moved to the wrong status, left in progress after the code shipped, or closed prematurely. Scope changes mid-sprint and the ticket doesn’t follow. By the time a release is cut, the PM system reflects <em>intent at planning time</em>, not what actually happened.</p><p>The code doesn’t have that problem. The diff is ground truth. It’s exactly what changed, nothing more, nothing less. When AI runs on the actual code changes, it’s working from the closest possible source to reality, not a human’s summary of what they planned to do.</p><p>Git history sits right next to that ground truth. A commit tied to a code change is a statement made at the moment the work was done, not before and not after. That’s what makes it more reliable as an automation input than any ticket that may or may not reflect what actually shipped.</p><p>The other thing Git enforces that PM systems don’t: <strong>every change has to go through it.</strong> You can skip writing a ticket. You cannot skip committing code. If you enforce structure at the commit level, you capture everything, including the work that never made it into a ticket, the hotfix committed at 11pm, the small refactor that turned into a breaking change. The PM system will never know about those. Git always will.</p><p>Tickets are still valuable, especially when AI can reach into them for richer context. But as the primary source of truth for what actually shipped, Git wins. It’s not a matter of discipline. It’s a matter of where the work actually lives.</p><h3>Where most teams fail</h3><p>This is important: you’ll recognise this pattern immediately.</p><p>Teams think: <em>“AI will fix our process.”</em></p><p>But bad commit history produces bad AI output. Inconsistent practices produce unreliable automation. If the input is vague, AI mostly generates <strong>confident guesses</strong>: shallow summaries with misleading emphasis that require as much cleanup as writing from scratch.</p><p>AI amplifies quality. It doesn’t create it.</p><p>The teams that get the most out of AI in their delivery workflows are the ones who invested in input quality first. Structure isn’t a prerequisite that slows you down before the AI magic happens. It’s the thing that makes the AI actually useful. We know this because we have it running, and because we remember what release prep looked like before.</p><p>Someone at the talk asked a fair question: <em>“What if we just use AI to write our commit messages? Isn’t that good enough?”</em></p><p>It’s a reasonable thought, and AI can certainly help. But there’s a hidden cost that’s easy to miss, and a deeper problem that doesn’t go away.</p><p>The hidden cost first. Getting AI to consistently produce well-structured, correctly classified, ticket-referenced commit messages requires a good prompt, context about your conventions, and ongoing maintenance as your standards evolve. That’s not free. Every developer needs access to it, it needs to be embedded into the workflow, and someone needs to own it. And every commit runs an API call.</p><p>Compare that to a linter at the PR gate: simple, centralized, deterministic, and essentially free to run. A linter doesn’t get tired, doesn’t drift, doesn’t need a prompt update when you add a new commit type. It just checks the rule and either passes or fails. CPU time is cheap. AI tokens are not. For enforcing a known rule with a clear pass/fail outcome, spending tokens is the wrong tradeoff that’s exactly what deterministic tooling exists for. Use AI where judgment is needed, not where a regex will do.</p><p>The deeper problem: AI writing a commit message from a diff is still guessing at intent. It sees what changed in the code, but it doesn’t know <em>why</em> you made that choice, whether it’s a breaking change, which scope it belongs to, or whether there’s a ticket behind it. The output tends to be grammatically correct but semantically shallow, which means downstream systems are still working with weak signals, just more polished-looking ones.</p><p>The structure needs to come from the engineer, because the engineer is the one who knows the intent. AI can help you format it, remind you of the convention, suggest the type. But the classification has to be honest, and only the person who made the change can make it honest. Outsourcing that judgment to AI doesn’t solve the signal problem, it just adds a confident-sounding layer on top of it.</p><h3>What I built (and open-sourced)</h3><p>To enforce these practices across repos without duplicating configuration everywhere, I built a small GitHub Actions toolkit and open-sourced it under <a href="https://github.com/DevExSweden">DevExSweden</a>:</p><h3>1. Validate commits at the PR gate</h3><p><a href="https://github.com/DevExSweden/conventional-commit-with-ticket"><strong>conventional-commit-with-ticket</strong></a></p><p>Validates PR titles against the Conventional Commits spec, optionally enforces a ticket key for specific commit types, and automatically labels PRs with type and scope on success. Enforce the schema at the point of entry, not after the fact.</p><p>The key design decision was centralization, by keeping the allowed types and ticket pattern in one action, every repo that uses it inherits the same standards. Update once, update everywhere.</p><p>You can see a real example workflow here: <a href="https://github.com/GulerSevil/HelloAndroid/blob/main/.github/workflows/pr_workflow.yml">pr_workflow.yml</a></p><pre>name: Conventional Commit Check<br><br>on:<br>  pull_request:<br>    types: [opened, reopened, edited]<br><br>jobs:<br>  conventional-commit:<br>    runs-on: ubuntu-latest<br>    steps:<br>      - name: Validate conventional commits<br>        uses: DevExSweden/conventional-commit-with-ticket@v1.0.0<br>        with:<br>          app-token: ${{ secrets.GITHUB_TOKEN }}<br>          ticket-key-pattern: &quot;(PROJ|TEAM)-[0-9]{2,5}&quot;<br>          require-ticket-for-types: &quot;feat,fix,perf,security,refactor&quot;<br><br>      - name: Continue workflow<br>        run: echo &quot;If the conventional commit check passes, the workflow will continue&quot;</pre><h3>2. Full release automation</h3><p><a href="https://github.com/DevExSweden/release-please-autoship"><strong>release-please-autoship</strong></a></p><p>The glue layer on top of <a href="https://github.com/googleapis/release-please">Release Please</a>. It reads your structured commit history, creates a versioned release PR with a generated changelog, and when merged, tags the release and auto-merges all without anyone pressing a button. The workflow runs on a schedule and can also be triggered manually.</p><pre>name: Release Please<br>on:<br>  schedule:<br>    - cron: &quot;0 9 * * 1&quot; # Every Monday at 09:00 UTC<br>  workflow_dispatch:<br>jobs:<br>  release:<br>    runs-on: ubuntu-latest<br>    permissions:<br>      contents: write<br>      pull-requests: write<br>    steps:<br>      - name: Run Release Please and auto-merge<br>        uses: DevExSweden/release-please-autoship@v1.0.0<br>        with:<br>          target-branch: main<br>          config-file: .github/release-please/config.json<br>          manifest-file: .github/release-please/manifest.json<br>          github-app-id: ${{ secrets.APP_ID }}<br>          github-app-private-key: ${{ secrets.APP_PRIVATE_KEY }}</pre><p>The config and manifest files in .github/release-please/ tell Release Please which packages to version and how. When your commits carry clear intent, this workflow just... works. When they don&#39;t, it struggles. That&#39;s the point.</p><p>Full working example: <a href="https://github.com/GulerSevil/HelloAndroid/blob/main/.github/workflows/release_please.yml">release_please.yml</a></p><h3>What Conventional Commits don’t solve</h3><p>I’d be doing you a disservice if I didn’t say this clearly.</p><p>Conventional Commits improve the signal. <strong>They don’t replace engineering discipline.</strong></p><p>They won’t fix huge PRs with mixed intent. They won’t help if fix is used for everything, including breaking changes. They won&#39;t rescue a chaotic branch strategy or make unsafe cherry-picks safe. If the classification is dishonest or inconsistent, the automation built on it will be too.</p><p>Structure is a tool. It only works if it’s used honestly and consistently across the team. Getting there requires buy-in, not just a linter.</p><h3>Where to start</h3><p>If you’re sitting in that 77% who still have meaningful human interpretation in your release flow, the entry point is simpler than you might think:</p><ol><li><strong>Start with PR titles, not individual commits.</strong> If you squash-merge, the PR title becomes the commit. That’s the one string that matters most. Validate it.</li><li><strong>Pick a small set of types and stick to them.</strong> feat, fix, chore, ci, docs. Don&#39;t overthink it.</li><li><strong>Gate it in CI.</strong> Use a linter or the <a href="https://github.com/DevExSweden/conventional-commit-with-ticket">conventional-commit-with-ticket</a> action to enforce at the PR level.</li><li><strong>Add Release Please.</strong> Once the signal is clean, let automation handle the release PR and the changelog.</li><li><strong>Plant the ticket reference now.</strong> Enforce ticket numbers in commits for meaningful types. You may not have AI reading your tickets yet, we don’t, but the pointer will be there when you do. That’s a structural decision that’s much harder to retrofit later.</li><li><strong>Measure the boring.</strong> Track how many release days have a surprise. Watch it go down.</li></ol><p>The goal isn’t perfect commit messages. The goal is boring release days, where the system knows what changed, acts on it confidently, and humans spend their time on things that actually need judgment.</p><p>Git history is no longer just <em>what happened</em>. It’s the single source of truth that drives everything after code is written. And when each commit carries a ticket reference, that history becomes a graph, connecting code changes to intent, acceptance criteria, risk, and context that your whole delivery system can query.</p><p>Treat it like the API it already is.</p><p>You don’t have to do all of this at once. Start small, automate one thing, see what happens.</p><p>This post is the first part of a CI/CD talk I gave at GDG Stockholm — the part I didn’t have time to finish. Whether there will be a second talk I’m not sure yet, but I’ll definitely write about it. There’s more to cover: how the delivery system behaves once the signal is clean, what changes further down the pipeline, and where things get interesting.</p><p>If you try any of this and run into something, feel free to reach out. I’d love to hear what worked and what didn’t.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bad56698930f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Quiet Violence of Being an Expat]]></title>
            <link>https://medium.com/@sevillguler/the-quiet-violence-of-being-an-expat-3a6851ef332c?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a6851ef332c</guid>
            <category><![CDATA[expat-life]]></category>
            <category><![CDATA[motherhood]]></category>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[immigration]]></category>
            <category><![CDATA[identity]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Fri, 28 Nov 2025 20:33:02 GMT</pubDate>
            <atom:updated>2025-11-28T20:42:29.008Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mZ5gdPKrf9SOBLDGYJJw9g.jpeg" /><figcaption>A moment of calm in a city that has shaped me for twelve years.</figcaption></figure><p><strong>What is home?</strong><br>That question hit me somewhere above the clouds on my flight to Norway this evening. I’m terrified of flying, something I somehow developed after I finally started feeling genuinely happy in life. So every time the plane shakes, my brain hosts a TED Talk featuring all the existential questions I never asked when I was younger. Every vibration goes straight into my chest like a little emotional earthquake.</p><p>To me, home is Sweden.<br>Or… it used to feel that way. Lately it has started to feel more like a one-sided love story — me loving Sweden, Sweden responding with <em>“seen”</em> but no reply.</p><p>I arrived 12 years ago for my master’s degree. I left for a year and a half for another university, then came back to work. I spent more than a decade building a life here. Sweden was the only place where I felt safe, calm, and seen as a human being. That’s why I called it home. It wasn’t a metaphor; it was a feeling.</p><p>And yet I’ve been waiting more than six years for my citizenship application to even be opened. Six years. Despite recent court decisions that should apply to my case, my application is untouched. I’ve never received a reason. Meanwhile, people who applied after me — months or even years later — get their decisions in 3–6 months, sometimes even in three weeks. Watching that happen while I’m still stuck in the queue has been soul-crushing.</p><p>I should mention something even more exhausting. After waiting five and a half years with no progress at all, I withdrew my first application and applied again so I could take the case to court. The court ruled in my favor. You’d think that would finally unlock something — but my new application still hasn’t even been opened. Nothing. It’s a strange and painful kind of silence.</p><p>At one point, I even hired two different lawyers, trying to understand what I could do or what I might be missing. I kept hoping that the right professional help would finally bring clarity. Instead, it just showed me how powerless you can feel when the process stays silent.</p><p>I developed severe anxiety after my daughter was born. She is Swedish — her father is Swedish. I never gave her my birth-country’s passport because of many reasons, safety being the biggest one. And now, having different passports in one family feels like a storm cloud that never goes away. It might sound dramatic if you haven’t lived it, but it’s the kind of worry that wakes you up at 3 a.m. What if something happens? Their passports open doors that mine won’t. What if I become the weak link that holds my own family back?</p><p>The uncertainty affects everything. People sometimes ask why I still struggle with the language after so many years. The truth is that it’s hard to commit fully to a future that never feels guaranteed. When you don’t know if the place you love will let you stay, even learning the language becomes emotionally heavy. You try to plant roots, but the soil keeps shifting underneath you.</p><p>A thought hit me yesterday: <em>What if I lose my job? What would happen to us then?</em><br>It’s not a thought I usually allow myself to have. But uncertainty does strange things to your mind. When you already feel stuck in limbo, even small stories you hear from others can make your imagination spiral. Suddenly you start questioning things you never questioned before.</p><p>Some days I think about leaving and starting over somewhere else — countries where highly educated engineers are welcomed with immediate permanent residence. But the truth is: I built my entire adult life here. My friends, my memories, my routines, my daughter’s childhood… everything is rooted in Sweden. And I love this country. That’s what makes this whole thing hurt in a very specific way.</p><p>Being an expat is fun when you’re young. It’s exciting, adventurous, freeing. But with age, it gets heavier. Because who are you? Where do you belong? I left my birth country because I never felt safe or appreciated there, and because the ideological environment was so far from the life I wanted to build. I only worked one year there before deciding to leave. I had no future there. Yet here I am, 36 years old, with a job and a beautiful family, and still living with a sense of chaos inside me.</p><p>Home… home is where you feel you belong.<br>But what is belonging? What happens when the place you poured your energy into — your work, your dreams, your future — doesn’t truly open its arms to you? What happens when you do everything “right” and still find yourself in limbo?</p><p>Then you become something I wouldn’t wish on anyone: an expat who feels homeless.</p><p>I’ve never cheated anyone. I’ve never done anything wrong. I’ve played life on “honest mode,” and still I don’t get a single day of peace of mind.</p><p>Because that’s the part no one tells you when you decide to start over in another country. You don’t just move — you shed one self and grow another, and sometimes the new place never fully opens its arms to you. Being an expat can be beautiful and expanding, but it can also be lonely, unfair, and exhausting.</p><p>Yet even inside that mess, I remind myself of something steady: belonging isn’t granted by a passport office. It’s built through the life you create, the people who hold you, the small daily rhythms that make you feel human.</p><p>Maybe Sweden hasn’t met me halfway yet. Maybe I’m still waiting in more ways than one. But the life I’ve built here is still real. The love I have here is real. And even if the system hasn’t caught up, a part of me already belongs.</p><p><em>This story reflects only my personal experience and feelings. Every expat’s journey is different, and this is simply my own experience of navigating long-term uncertainty. Still, I would choose Sweden again without hesitation — this country is part of me now.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a6851ef332c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Observability in CI/CD — using ElasticSearch + GitHub to get real insights into your pipelines ]]></title>
            <link>https://blog.stackademic.com/observability-in-ci-cd-using-elasticsearch-github-to-get-real-insights-into-your-pipelines-1c9b3d7e717a?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c9b3d7e717a</guid>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Wed, 08 Oct 2025 05:02:12 GMT</pubDate>
            <atom:updated>2025-10-13T12:06:14.029Z</atom:updated>
            <content:encoded><![CDATA[<h3>Observability in CI/CD — using ElasticSearch + GitHub to get real insights into your pipelines 📊</h3><p>Monitoring CI/CD is actually pretty easy — it just looks complicated from the outside. So I decided to show how simple it can be to make your pipelines observable, with a bit of TypeScript, Node.js, and my little golden retriever by my side. 🐶💻☕️</p><p>I was off last week — and, of course, instead of actually resting, I decided to <strong>learn Node.js properly</strong> and go deeper with <strong>TypeScript</strong>.<br>I’ve used both before, but not as main languages in my domain, and I wanted to refresh my memory — partly so I can <strong>code more consciously with AI</strong>.</p><p>These days, AI tools can write code <em>for</em> you, but understanding what it’s doing under the hood still matters — so this was my way of staying sharp while also having some fun. 😅</p><p>So why not spend my “time off” doing something totally unnecessary but surprisingly useful, right?</p><p>Here’s what came out of it:<br>👉 <a href="https://github.com/GulerSevil/ci-data-ingestor"><strong>ci-data-ingestor</strong></a> — a small service that collects CI/CD data and sends it to <strong>ElasticSearch</strong>, so you can visualize your pipeline behavior and trends in Grafana or Kibana.</p><p>It’s still a work-in-progress (I’ll talk about what’s missing later), but I wanted to share it early because I think there’s a lot of value in making CI/CD <em>observable</em> — not just “green or red,” but <em>why</em> things behave the way they do.</p><p>Spoiler: <strong>Milo my 4-years-old golden retriever was very supportive of this decision.</strong> Mostly by sleeping next to me while I studied and coded. 🐶💤</p><h3>☕️ My “off week” setup</h3><p>📸 <em>First photo</em>: Me in a coffee shop, laptop open, comparing Kotlin to TypeScript so I can learn faster, while Milo sits right next to me — clearly wondering why I keep saying <em>“Aha!”</em> instead of throwing his ball. 🐶💻☕️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BkbHLwEAzjxoL0CZcFwxTQ.jpeg" /><figcaption>Coffee for me, moral support from Milo</figcaption></figure><p>📸 <em>Second photo</em>: later that week, I’m on the sofa, Milo snoring beside me while I’m tweaking webhook handlers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8kDNghdb_pPbNlFoNcx8ag.jpeg" /><figcaption>My accountability partner for this project.</figcaption></figure><h3>🔍 Why CI/CD observability matters</h3><p>We all have those moments where a pipeline fails, gets retried, and we just shrug it off. But over time, all those “small things” add up — slower releases, flaky tests, unclear ownership.</p><p><strong>CI/CD observability</strong> is about getting visibility into that world — not just <em>“did it pass?”</em> but <em>“how often do we fail?”</em>, <em>“which step is slowing us down?”</em>, and <em>“what can we fix proactively?”</em></p><p>This project is a simple example of how you can set that up in minutes. No complex integrations, no SRE team required — just <strong>GitHub, Node.js, and ElasticSearch</strong>.</p><p>If you’ve ever wanted to <em>see</em> what’s happening inside your CI/CD in a real dashboard, this is probably the easiest way to start.</p><h3>🧩 What this project does</h3><p>The <strong>ci-data-ingestor</strong> acts as a small <strong>Node.js + Fastify backend</strong> that listens for GitHub events (like workflow_run or check_suite) and forwards them to ElasticSearch.</p><p>Once the data lands there, you can create dashboards showing things like:</p><ul><li>Duration of each pipeline run</li><li>Frequency of failed steps</li><li>Average workflow success rate</li><li>Most common failure reasons</li></ul><p>Basically, it helps you go from <em>“our pipeline failed again”</em> → to <em>“we fail 30% of the time on flaky test X across repos”</em>.</p><h3>🪄 How to get started</h3><p><strong>1. Clone the repo:</strong></p><pre>git clone https://github.com/GulerSevil/ci-data-ingestor.git <br>cd ci-data-ingestor</pre><p><strong>2. Set your environment variables:</strong></p><pre>cp .env.example .env # Add your ElasticSearch variables and GitHub Webhook Secret</pre><p><strong>3. Run it locally:</strong></p><pre>npm install <br>npm run dev</pre><p><strong>4. Expose your local port (for testing):</strong><br>To test it locally and receive webhooks from GitHub, you can use <strong>ngrok</strong> (or any alternative like cloudflared tunnel) to make your localhost accessible publicly.<br>Example:</p><pre>ngrok http 3000</pre><p>This step is <strong>only for local testing</strong> — if you prefer, you can absolutely <strong>deploy this service to the cloud</strong> and point your GitHub webhook directly there instead.</p><p><strong>5. Add a webhook in GitHub:</strong><br>Go to your repository → <strong>Settings → Webhooks → Add webhook</strong></p><ul><li><strong>Payload URL:</strong> &lt;your-public-url&gt;/webhooks/ci/github</li><li><strong>Content type:</strong> application/json</li><li><strong>Events:</strong> workflow_runor check_suite</li></ul><p>And that’s it — the ingestor will start pushing data to ElasticSearch, and you can visualize it however you want.</p><h3>🧠 Why this setup?</h3><p>I started with <strong>ElasticSearch</strong> because it’s easy to spin up and great for experimenting — but this isn’t really about ElasticSearch.<br>The core idea is having a <strong>lightweight, flexible backend</strong> that can take CI/CD data from <em>any</em> provider and send it to <em>any</em>storage or visualization layer you prefer. You can query things like:</p><p>That could be:</p><ul><li>🧱 <strong>BigQuery</strong> or <strong>Snowflake</strong> for analytics</li><li>☁️ <strong>AWS OpenSearch</strong>, <strong>CloudWatch</strong>, or <strong>S3</strong></li><li>📊 <strong>Grafana</strong>, <strong>Looker</strong>, or <strong>Tableau</strong> for dashboards</li><li>Or even just a <strong>PostgreSQL</strong> table if you’re keeping it minimal</li></ul><p>ElasticSearch just made it easier to get started — but the real goal here is to show how <em>simple CI/CD observability</em> can be when you design it right.</p><h3>🏗️ Architecture overview</h3><pre>GitHub → Webhook → ci-data-ingestor (Fastify) → ElasticSearch → Grafana / Kibana dashboards</pre><p>Super lightweight. Super extendable.</p><h3>🚀 Extending it beyond ElasticSearch</h3><p>One thing I love about this setup is how <strong>provider-agnostic</strong> it is.<br>It doesn’t matter whether you’re using GitHub Actions, Jenkins, CircleCI, or GitLab — the idea is the same:<br><strong>capture your pipeline events, transform them, and send them wherever you want.</strong></p><p>It’s event-driven, flexible, and adaptable — the kind of thing you can easily evolve into your own observability hub.</p><h3>🧩<strong> Why not OpenTelemetry (yet)?</strong></h3><p>I know some of you might be thinking — “Why not just use OpenTelemetry for this?”</p><p>And you’re absolutely right — it would be a great fit for a more complete, vendor-neutral observability setup.</p><p>But for this first version, I wanted to keep it dead simple and transparent.</p><p>No collectors, exporters, or complex setup — just a small Fastify backend that anyone can run, tweak, and understand in minutes.</p><p>If there’s enough interest, I might extend this to support OTel spans and metrics later on — so it can plug into any observability stack with zero friction.</p><p>But for now, the focus is purely on showing that CI/CD observability doesn’t have to be complicated to be useful.</p><h3>⚠️ Disclaimer — it’s not “production ready” (yet)</h3><p>This is a <strong>proof of concept</strong>, not a polished product.<br>It currently:</p><ul><li>Doesn’t handle idempotency (so duplicate event inserts can happen)</li><li>Has minimal error handling</li><li>Hasn’t been load-tested</li></ul><p>I don’t plan to extend it <em>unless there’s enough interest</em>.<br>If you find it useful or want to collaborate, I’d love to hear from you — otherwise, it stays as a fun weekend project with <strong>Milo-approved vibes</strong> 🐾</p><h3>✨ Coming up next</h3><p>This post is <strong>Part 1</strong> of a three-part mini-series.<br>Next one will be about an <strong>alternative solution that doesn’t require a backend</strong> — perfect if you want to push CI/CD data directly from GitHub Actions.</p><p>And the <strong>third (and final)</strong> post will dive into <strong>creating DORA metrics</strong> using that data — connecting all the dots between your CI/CD events and your delivery performance.</p><p>To be honest, this will probably be the <strong>last series I write about CI/CD</strong> — so whether Part 3 happens or not depends on how much interest this topic gets. 😅</p><h3>💬 Final thoughts</h3><p>I’ll probably regret not spending my vacation days outside during the last sunny days of Sweden — but I needed to reset my perspective and be close to my boy. ☀️🐶</p><p>Sometimes learning something new, even in a quiet corner with coffee and a snoring dog, does more for your mindset than any trip could.<br>And honestly, that feels like a pretty good trade. 💛</p><p>If you’re curious, the repo’s here:<br>👉 <a href="https://github.com/GulerSevil/ci-data-ingestor"><strong>github.com/GulerSevil/ci-data-ingestor</strong></a></p><p>And if you try it out, let me know — I’d love to hear how you use it, what dashboards you create, or what metrics you find most insightful.</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c9b3d7e717a" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/observability-in-ci-cd-using-elasticsearch-github-to-get-real-insights-into-your-pipelines-1c9b3d7e717a">Observability in CI/CD — using ElasticSearch + GitHub to get real insights into your pipelines 📊</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ Automate Your Slack Goalie Rotation (So You Can Stop Doing Boring Stuff)]]></title>
            <link>https://python.plainenglish.io/automate-your-slack-goalie-rotation-so-you-can-stop-doing-boring-stuff-a5d3df5fc470?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5d3df5fc470</guid>
            <category><![CDATA[site-reliability-engineer]]></category>
            <category><![CDATA[work-smarter]]></category>
            <category><![CDATA[on-call]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Mon, 19 May 2025 04:02:32 GMT</pubDate>
            <atom:updated>2025-10-15T12:51:37.903Z</atom:updated>
            <content:encoded><![CDATA[<h3>🥅 Automate Your Slack Goalie Rotation (Own Your App and Say Goodbye to Boring Tasks!)</h3><p>Let’s be honest — reminding your team who’s on goalie duty every week is not just annoying… it’s a little soul-draining. 🧂<br>Manual, repetitive tasks are the first things we should automate. So, I did.</p><p>This tiny GitHub Action rotates your on-call goalie (and deputy, if you have one), updates a file, posts to Slack, and<strong> </strong>updates the Slack user group so people actually get pinged when it matters.<br>No spreadsheets. No calendar invites. No more “wait, who’s on this week?”</p><p>You get to create and own your own Slack app with the exact permissions you need — no relying on random third-party apps with unclear practices. Spoiler alert: there isn’t really a great free rotation app on Slack’s marketplace that lets you do this seamlessly.</p><h3>🔐 Security Matters</h3><p>When you bring third-party apps into your Slack workspace, you’re trusting them with access to your team’s data and conversations. Not all apps are created equal, and sometimes you don’t have full visibility into what they do behind the scenes.</p><p>By building and running your own Slack app for rotation, you keep control in your hands. You decide exactly what permissions it needs, how it handles your data, and where it runs. This means fewer surprises and a smaller attack surface — a win for your team’s security and peace of mind.</p><h3>Run Anywhere</h3><p>You can run the Python package behind this GitHub Action from <strong>any</strong> CI/CD system — GitHub Actions, GitLab CI, Jenkins, CircleCI… you name it. All you need is Python and your Slack token. This makes it super flexible, whether you want to automate rotations on GitHub or elsewhere.</p><h3>🧯 Why not just use Slack’s Workflow Builder?</h3><p>Because it’s not enough. 😅<br>Slack workflows are great for simple things like forms and reminders — but they can’t:</p><ul><li>Read from your custom rotation list</li><li>Track state in a file</li><li>Update Slack user groups programmatically</li><li>Integrate tightly with your CI/CD</li></ul><p>This GitHub Action can do all that, and run on a schedule. Total control, less boredom.</p><h3>🔜 Coming Soon: PagerDuty Support</h3><p>We’re also working on extending this to automatically update your on-call in PagerDuty too — so you only manage one source of truth and everything else syncs up. 🎉</p><h3>🚀 What You’ll Need</h3><ul><li>A GitHub repo with your goalie rotation list</li><li>A dedicated Slack app (don’t use your own identity!)</li><li>A few basic bot token scopes:</li></ul><pre>channels:read  <br>channels:write.topic  <br>chat:write  <br>usergroups:read  <br>usergroups:write</pre><p>Then, drop your bot token into GitHub secrets as SLACK_BOT_TOKEN. Done.</p><h3>📖 Full Setup Instructions</h3><p>Check out the <a href="https://github.com/GulerSevil/slack_rotation_action#readme">README.md </a>— it has all the juicy details and examples.</p><h3>🧪 Run it from GitHub Actions (or any CI/CD)</h3><p>Here’s a quick example workflow to get you started:</p><pre>- uses: GulerSevil/slack_rotation_action@main<br>  with:<br>    slack-token: ${{ secrets.SLACK_BOT_TOKEN }}<br>    file-path: &#39;scripts/goalie_rotation.txt&#39;<br>    mode: &#39;next_as_deputy&#39;<br>    slack-channels: &#39;C01ABCD2345&#39;<br>    user-group-handle: &#39;teamx_goalie&#39;</pre><p>This works in any CI/CD setup — GitHub Actions, GitLab, Bitbucket… it’s just Python under the hood.</p><p>You can also commit the updated rotation list back to your repo. (Sample workflow in the <a href="https://github.com/GulerSevil/slack_rotation_action#readme">README</a>).</p><h3>💡 A Few Tips</h3><ul><li>Use a dedicated Slack bot, not your own user — or people will think <strong>you</strong> are updating the user group every week 😅</li><li>If you’re committing from GitHub Actions, GITHUB_TOKEN works fine — but if you want more flexibility, use a <a href="https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens">PAT</a>.</li></ul><h3>📦 The Repo</h3><p>👉 <a href="https://github.com/GulerSevil/slack_rotation_action">GulerSevil/slack_rotation_action</a></p><h3>🛒 Install from GitHub Marketplace</h3><p>You can also find this action on the GitHub Marketplace for easy integration:<br><a href="https://github.com/marketplace/actions/goalie-selection-and-slack-notification">Goalie Selection and Slack Notification</a></p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5d3df5fc470" width="1" height="1" alt=""><hr><p><a href="https://python.plainenglish.io/automate-your-slack-goalie-rotation-so-you-can-stop-doing-boring-stuff-a5d3df5fc470">🥅 Automate Your Slack Goalie Rotation (So You Can Stop Doing Boring Stuff)</a> was originally published in <a href="https://python.plainenglish.io/">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Generated Code is a Ticking Time Bomb Without Strong Engineering Fundamentals.]]></title>
            <link>https://medium.com/@sevillguler/ai-generated-code-is-a-ticking-time-bomb-without-strong-engineering-fundamentals-57208893a2c5?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/57208893a2c5</guid>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[leadership-career-growth]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Fri, 28 Feb 2025 23:00:30 GMT</pubDate>
            <atom:updated>2025-03-01T18:49:15.750Z</atom:updated>
            <content:encoded><![CDATA[<p>AI, AI everywhere! You can’t walk two steps without hearing about it these days. I recently attended a tech conference, and let me tell you — I’ve seen some wild talks, but this one took the cake.</p><p>A speaker confidently claimed you could <strong>“transform your entire company in just 48 hours — without a single engineer!”</strong> 😱 The grand solution? Upload your Excel data to ChatGPT and let it work its magic. That was it. That was the demo. 😶‍🌫️</p><p>Naturally, my brain went into full <strong>“What could possibly go wrong?”</strong> mode. Privacy and security risks? <strong>Huge.</strong> The speaker conveniently skipped over the minor detail of <strong>handing over your company’s data to a third party — for free.</strong></p><p>Now, don’t get me wrong — I’m a huge AI fan. I can’t wait to see its potential unfold. But the <strong>misuse and misinformation</strong> around AI right now? It’s everywhere. And even if we <em>ignore</em> the security and privacy concerns (which we shouldn’t), there’s another ticking time bomb waiting for companies:</p><p>🚨 <strong>AI-Generated Code Without Understanding is a Risk</strong> 🚨</p><p>If engineers don’t understand the code AI spits out, <strong>who’s going to maintain it?</strong> It might seem like a time-saver now, but in reality, it’s just setting things up for chaos later. AI is an incredible tool — but treating it like a magic wand? That’s a shortcut to disaster.</p><p>Many believe AI can handle the <strong>majority</strong> of the work, leaving engineers to simply fine-tune the rest. <strong>But reality paints a different picture.</strong> AI-generated code is only as good as the engineers reviewing it, and without a strong foundation in software design, things can spiral out of control fast.</p><p>Let me give you a real-life example. I once came across <strong>AI-assisted code written by engineers without solid engineering principles.</strong> The result?</p><ul><li><strong>Unreadable, unmaintainable, untestable</strong> spaghetti code 🍝</li><li><strong>Any small change had the potential to send production into chaos</strong> 🍌</li><li><strong>Releases took forever</strong> because no one wanted to touch the code</li></ul><p>It was a mess. <strong>So bad, in fact, that it took me three whole days just to figure out what the code was supposed to do.</strong> I reached out to the owning team for help, but… well, <strong>they weren’t too sure either.</strong> The comments were misleading, and the logic made absolutely no sense.</p><p>By the time I finally cracked the mystery, one thing was clear: <strong>this code wasn’t salvageable.</strong> The only way forward was to <strong>rewrite it from scratch.</strong> So that’s exactly what I did — <strong>made it modular, added tests, and ensured quality of my unit tests with mutation testing — all in less than a single day.</strong></p><p>This is the real danger of blindly relying on AI-generated code. Without engineering fundamentals in place, <strong>you don’t just end up with bad code — you end up with a system no one understands, no one trusts, and no one wants to touch.</strong></p><p><strong>🚨 AI is Not a Shortcut to Good Engineering 🚨</strong></p><p>AI can generate code, but without <strong>strong engineering foundations</strong>, that code can quickly turn into a ticking time bomb. With AI, any engineer can build anything — but without the right fundamentals, they risk creating systems that are fragile, inefficient, and unmaintainable. To truly harness AI effectively, companies must <strong>invest in training their engineers</strong> — not just on tools and frameworks, but on the <strong>fundamentals of good engineering</strong>:</p><p>✅ <strong>Core engineering principles</strong> — writing maintainable, scalable, and efficient code<br>✅ <strong>SOLID principles</strong> — ensuring good software design and avoiding code rot<br>✅ <strong>Architectural patterns &amp; trade-offs</strong> — knowing when to use <strong>monoliths, microservices, event-driven systems</strong>, etc.<br>✅ <strong>Software architecture models</strong> — <strong>Clean Architecture, Hexagonal, Onion Architecture</strong>, and how to choose the right approach<br>✅ <strong>Testing strategies</strong> — unit, integration, mutation, performance, security testing, and their real-world impact<br>✅ <strong>Code quality &amp; maintainability</strong> — writing readable, structured, and future-proof code<br>✅ <strong>Performance optimization</strong> — ensuring efficient systems at scale<br>✅ <strong>Security best practices</strong> — building software that’s resilient to threats and vulnerabilities</p><p>AI can be an incredible assistant, but it’s <strong>not a substitute for good engineering.</strong> Companies that prioritize <strong>continuous learning and deep technical understanding</strong> will have teams that can <strong>use AI as a tool — not as a crutch.</strong></p><p><strong>💎 Well, well — should we also revisit the definition of engineering? 💎</strong></p><p><em>“You can transform your company with no engineers.”</em></p><p>That’s a bold claim, but it raises a bigger question: <strong>What does it really mean to be an engineer? What value do engineers bring?</strong></p><p>I’ve been in the industry for a long time, and if there’s one thing I’ve noticed, it’s that the meaning of <em>engineering</em> has always been… let’s say, <strong>interestingly vague.</strong></p><p>Many still see software engineers as just coders — people who crank out lines of code like machines. But engineering is so much more than that. It’s about <strong>solving problems in a sustainable and safe way</strong> — for example, ensuring that AI can be used <strong>with compliance, protecting privacy and security while maintaining development velocity.</strong></p><p><strong>This is why the idea that engineers will become unnecessary is completely misguided. AI won’t replace engineers — it will raise the bar.</strong> Instead of needing <strong>more</strong> engineers, we’ll need <strong>better</strong> engineers — ones who can <strong>adapt, think critically, and truly understand the systems they build.</strong></p><p><strong>Yet, many companies fail to recognize what truly makes a great engineer.</strong> Too often, they focus only on technical skills while overlooking other essential qualities, such as:</p><p>🚨 <strong>Collaboration &amp; communication</strong> — Poor communication leads to a broken culture that slows everything down<br>⚠️ <strong>Tech debt awareness</strong> — Bad code piles up when no one thinks long-term<br>💡 <strong>Ownership &amp; innovation</strong> — Engineers shouldn’t just follow instructions; they should drive solutions</p><p>And while AI is a powerful tool in the right hands, hiring processes still rely on checkboxes— <em>Do you know X? Have you used Y?</em> —instead of focusing on how well someone learns, adapts, and solves problems. But engineering is more than just knowing a tool or a framework. So rather than focusing solely on technical skills, companies should invest in well-rounded engineers who can:</p><p>✅ Continuously learn and adapt in an evolving tech landscape<br>✅ Focus on quality and long-term maintainability, not just speed<br>✅ Take ownership and solve problems, rather than just executing tasks<br>✅ Collaborate effectively across teams and disciplines<br>✅ Bridge the gap between technology and business needs</p><p>Because at the end of the day, <strong>engineering isn’t about knowing every tool </strong>— it’s about knowing <strong>how to think and applying strong engineering fundamentals</strong>. And in a world that’s constantly evolving, the companies that value <strong>problem-solvers over checklist-hitters</strong> will be the ones that truly thrive. 🚀</p><p><strong>👋🏼 I have talked enough 👋🏼</strong></p><p>It’s Friday, and once again, it’s way too late.As a toddler mom, I already know that tomorrow I’ll regret <strong>every single second</strong> I stayed up past 22:00. 😅 But honestly, I wouldn’t have been able to sleep without getting these thoughts out.</p><p>There’s so much more I want to write about — <strong>life, parenthood, love, living abroad, mental health</strong> etc. — not just tech. Writing feels like the easiest way to be myself. But for now, sticking to tech feels like the safest path. 🙂</p><p><strong>Aaaannnnywwaaaayyy, before I wrap this up…</strong> 😆</p><p>Let me <em>grace you</em> with this <strong>extremely profound and wise</strong> closing thought 😅: Tech is always evolving, but one thing stays the same<strong> — engineering isn’t just about knowing every tool, it’s about knowing how to think.</strong> 🚀</p><p>If this article helped you even a little, it’ll totally make my day — swollen, sleep-deprived eyes and all! 😆👀✨ Wishing you <strong>clarity to see the big picture, curiosity to keep exploring, and a steady path (or at least a fun adventure) in this ever-changing world.</strong> 🌍✨</p><p><em>Just so you know this article is polished by AI — because even late-night thoughts deserve a final touch.</em> 🤖✨🙌🏼</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57208893a2c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Engineer to Manager: Navigating the Transition]]></title>
            <link>https://medium.com/@sevillguler/from-engineer-to-manager-navigating-the-transition-f8c458f31da?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8c458f31da</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[career-advice]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Tue, 23 Apr 2024 20:00:22 GMT</pubDate>
            <atom:updated>2024-10-21T12:23:13.146Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>TL;DR: Having a great manager is like hitting the jackpot for your team. Strive to have that winning ticket! 🌟</em></strong></p><p>Hey there! Today, let’s embark on the exciting journey of transitioning from an engineering role to becoming an engineering manager. As someone who’s navigated this transition firsthand, I’m thrilled to share some tips and insights to help you shine in your new role. But before we dive in, allow me to introduce myself and share a bit about my professional journey 🌟</p><p><strong>Let me introduce myself first …</strong></p><p>I am a Staff Engineer at one of the leading automotive companies. Before this role, I had the privilege of serving as an engineering manager for nearly three years at Spotify. Yep, you heard it right — I went from calling the shots back to getting my hands dirty in engineering.</p><p>Now, managing was a hoot! There’s something special about helping others conquer their daily dilemmas that tickled my fancy. But guess what? I’ve got this itch for some fresh engineering challenges. I want my brain to go on a wild rollercoaster ride of problem-solving.</p><p>But hold your horses, who knows? I am missing the satisfaction of being a helping hand so might decide to leap back into management someday. Life’s a box of chocolates, full of surprises! 🎢🤷‍♂️</p><p><strong>Reflecting on the Transition</strong></p><ul><li><strong>Reflect on your reasons for wanting to pursue a managerial role:</strong> While diving into a managerial role may seem like a natural progression in your career, managing isn’t just about titles and authority. It’s about genuinely wanting to support both your team members and the organization as a whole. If the idea of navigating conflicts, fostering growth, and championing your team doesn’t resonate with you, it might be worth reconsidering your path. Managing isn’t for everyone, and that’s okay. Find a role that aligns with your passions and strengths.</li><li><strong>Beginnings are hard.… but hey! just breathe…—</strong>transitioning from being a solo contributor as an engineer to taking on a managerial role can be quite the adjustment. Your daily routine will have a significant transformation. Your presence and availability will be in high demand, and you’ll find yourself without the immediate satisfaction of achieving small wins through the implementation of a single feature. Instead, your focus will be on broader strategies and long-term goals. It’s a shift, but with time and effort, you’ll adapt.</li><li><strong>It’s no longer solely about you — it’s time for a mindset shift: </strong>Your role now extends beyond yourself. Your primary focus is ensuring the happiness of your team and the prosperity of the business. Remember, when your team succeeds, so do you; it’s that simple.</li><li><strong>Acknowledge Team Equality:</strong> Your title may change, but you’re still part of the team. Empower your team by involving them in decisions that may affect their daily work. Recognize that your role comes with different responsibilities, not necessarily privileges.</li><li><strong>Listen Actively and Act Accordingly:</strong> Listening is a great asset, but it’s equally important to act on what you hear. While being attentive to your team’s needs and concerns is crucial, taking action demonstrates your commitment to their well-being and the success of the team. Make active listening your main asset, but let action be your superpower 💪</li><li><strong>Stay Relevant: </strong>Even though your role may now involve more big-picture stuff, staying tuned into the latest tech trends keeps you sharp and ready to support your team. It’s like staying up-to-date with the latest gossip but way cooler! Keep an eye on what’s buzzing in the tech world, whether it’s new tools, methodologies, or breakthroughs in your field and don’t forget to share the juicy bits with your team!</li><li><strong>Delegate, Delegate, Delegate: </strong>It’s time to advance delegation. No one expects you to do it alone, but they expect your team&#39;s delivery. Let your team shine and support them from the back seats. Use delegation as an opportunity for your team to grow. For example, if an engineer is interested in management, you can start by delegating team ceremonies or having them assist with recruiting interns. For an engineer aiming to improve their public speaking skills, delegate tasks like presenting at cluster demos. Tailor opportunities to match their goals, helping them develop in areas they’re passionate about.</li><li><strong>Foster Team Autonomy:</strong> Aim to make your team autonomous enough so that you will not be needed eventually. Empower your team members to take ownership of their work and make decisions independently. Provide guidance and support as needed, but encourage them to develop their problem-solving skills and take initiative.</li><li><strong>The Pitfall of Dismissing Intentions: </strong>If you ever feel the need to reassure someone by saying, “I don’t think he/she/they have bad intentions,” when they are concerned about a colleague’s behavior, it often signals that something is wrong and action is needed. Intentions are not the focus when dealing with bad behavior. This seemingly innocent statement, “I don’t think he/she/they have bad intentions,” can contribute to overlooking harmful actions. Be mindful of your words and remember that unconscious bias is real. Strive to do better.</li></ul><h4>Navigating the Managerial Landscape</h4><ul><li><strong>Same, same, but different</strong>: Management isn’t about crunching numbers or coding algorithms; it’s about connecting with people and unleashing their inner superheroes! As a manager, your primary responsibility is to lead, support, and empower your team members to achieve their goals and fulfill their potential. Focus on building strong relationships, fostering open communication, and providing meaningful support and guidance to your team members. Be empathetic, approachable, and responsive to their needs and concerns, creating a positive and supportive work environment where everyone feels valued and respected. By prioritizing people over processes or tools, you can inspire trust, loyalty, and commitment within your team, driving greater engagement, satisfaction, and success.</li><li><strong>1:1s for Connection, not Status Updates:</strong> One-on-one meetings are invaluable opportunities for building strong connections with your team members. Rather than merely using these meetings for status updates or task assignments, prioritize using them as avenues for understanding your team members on a deeper level. Actively listen to their thoughts, concerns, and aspirations. Tailor your approach to each individual’s preferences and needs, fostering a sense of trust, transparency, and support. Imagine one-on-one meetings as cozy coffee chats with your work buddies. It’s your chance to get to know each team member — their dreams, their quirks, and their favorite pizza toppings! So, ditch the spreadsheets and dive into meaningful conversations. Who knows, you might discover a shared love for cat memes or hiking trails!</li><li><strong>Be Honest and Constructive</strong>: Remember, honesty is key in your interactions with the people you work with — your team, stakeholders, clients, and anyone else involved. Take the time to understand how to provide constructive feedback. Don’t drop a bombshell on your team during performance reviews and then expect their trust in guiding their career paths. Be gentle but courageous in helping others improve where needed. <strong>Stay truthful</strong>; if you feel an engineer’s career goals might not match their skills, be upfront about it <strong>instead</strong> of giving false hope. And let’s not use feedback as a teaching moment based on just one example!</li><li><strong>Admit Mistakes and Learn</strong>: We’re all human. Sometimes we mess up, and that’s okay! Admitting mistakes isn’t a sign of weakness; it’s a superpower! What sets great managers apart is their ability to acknowledge and learn from their mistakes. When you make a mistake, take ownership of it, apologize if necessary, and commit to making amends and learning from the experience. Cultivate a culture of accountability and continuous improvement within your team, where mistakes are viewed as opportunities for growth and learning rather than sources of blame or shame.</li><li><strong>Support Team Members’ Growth</strong>: One of the most fulfilling aspects of being a manager is supporting the growth and development of your team members. Take an active interest in their professional goals, aspirations, and areas for improvement. Provide opportunities for learning, skill development, and career advancement tailored to each individual’s interests and talents. Offer guidance, mentorship, and constructive feedback to help your team members unlock their full potential. Create a culture of continuous learning and improvement, where curiosity, experimentation, and innovation are encouraged. Always keep in mind: that when your team succeeds, you succeed too.</li><li><strong>Embrace Diversity in Approaches</strong>: Acknowledge that management isn’t one-size-fits-all, and stay flexible to accommodate diverse team dynamics and preferences. Take the lead in educating yourself and your team about unconscious biases, fostering a more inclusive and understanding work environment!</li><li><strong>Understand Agile Principles</strong>: Agile might sound like just another buzzword now that you’re in a managerial role but don’t brush it off as mere hype. Take the time to truly understand its essence. Even if you’re strapped for time, start by grasping its foundational principles: putting communication and collaboration above processes and tools. Remember, at the heart of this principle lie the people — your team, stakeholders, clients, and anyone else involved. Center your approach around their needs to foster better communication and collaboration. <strong><em>Let processes and tools adapt to serve these needs, not the other way around</em></strong><em>. </em>There’s no one-size-fits-all solution in Agile; it all boils down to understanding and addressing the collective needs and dynamics of everyone involved.</li><li><strong>Embrace Constructive Conflict:</strong> Uhh, conflict — not my favorite thing, but sometimes it’s necessary, ya know? 🤷‍♀️ I’m all about creating an environment where everyone feels comfy speaking their mind, even if it means things get a bit spicy. I truly believe that healthy conflict can be like a fertilizer for growth and creativity within a team. It’s all about promoting respectful, open-minded discussions and focusing on finding solutions. By encouraging constructive conflict resolution, you can turn those heated debates into opportunities for learning and improvement. Remember, it’s not about avoiding conflicts entirely, but managing them like pros!</li><li><strong>Shape Organizational Culture:</strong> As a manager, you play an important role in shaping the culture of your team and organization. Your actions, decisions, and interactions set the tone for the work environment and influence the attitudes and behaviors of your team members. Take responsibility for fostering a culture of respect, inclusivity, and accountability. <strong>Lead by example</strong>, demonstrating integrity, transparency, and empathy in your dealings with others. Address issues or conflicts promptly and impartially, promoting open communication and constructive resolution.</li><li><strong>Set Expectations:</strong> Clear communication and alignment of expectations are essential for fostering a productive and harmonious work environment. Take the time to establish open communication channels with each team member to understand their strengths, weaknesses, preferences, and career aspirations. This facilitates mutual understanding and lays the foundation for effective collaboration and personal growth within the team. Similarly, when interacting with stakeholders, clients, and others involved, it’s crucial to set clear expectations regarding project objectives, timelines, and deliverables. Engage in meaningful discussions to understand their requirements, concerns, and goals. By aligning expectations with all parties involved, you can create a collaborative environment where everyone works towards a common goal and achieves collective success.</li><li><strong>Use Books as Guides, not Gospel</strong>: Think of management books as your friendly neighborhood advisors, not strict rulebooks carved in stone. While books offer frameworks and best practices, blindly adhering to them without considering the specific context and dynamics of your team can be counterproductive. Ultimately, the decisions you make, the rules you apply, and the tools you use should be informed by the specific needs, challenges, and goals of the group you’re managing. Flexibility and adaptability are key in effectively utilizing management literature as a guide rather than treating it as infallible doctrine.</li><li><strong>Bridge Business and Tech:</strong> Have you ever played the role of translator between two friends who speak different languages? That’s you, bridging the gap between tech wizards and business gurus! Help them understand each other’s jargon and priorities, so they can team up to conquer any challenge together. Encourage a mindset of collaboration and problem-solving, where individuals from diverse backgrounds and disciplines work together towards common objectives. Please remember that every missed collaboration opportunity represents a significant setback in your journey toward growth, innovation, and success.</li><li><strong>Prioritize Delivery and Clarity</strong>: In today’s fast-paced and dynamic work environment, effective project management is essential for achieving success. As a manager, it’s your responsibility to ensure that projects are delivered on time, within budget, and according to specifications. Prioritize clarity and transparency in communication, setting clear expectations, goals, and milestones for your team. Provide regular updates on project progress, highlighting any potential risks or obstacles that may arise. Proactively identify and address issues or challenges that may impact project delivery, leveraging your resources and expertise to find solutions. Don’t save your apologies for the final stop! Make clear communication and timely delivery your ride-or-die companions to build trust and accountability among your team and stakeholders.</li><li><strong>Focus on Outcome over Output</strong>: As a manager, it’s important to focus on the broader outcomes and impacts of your team’s work, rather than simply measuring outputs or activities. Encourage your team to set clear goals and objectives that align with the organization’s strategic priorities and customer needs. Emphasize the importance of collaboration, innovation, and continuous improvement in driving meaningful outcomes and value creation. Celebrate successes and learn from failures, fostering a culture of accountability, resilience, and adaptability. By focusing on outcomes over output, you can inspire your team to achieve their full potential and make a positive impact on the organization and its stakeholders.</li><li><strong>Hire and Promote the Right People: </strong>Understanding your team’s and business’s needs is essential. Sometimes, you’ll require someone tech-savvy, while other times, you might need to enhance your team’s social and work-related proactivity. Hiring or promoting the wrong person can spell disaster for your team’s success. Think of it like keeping water clean; once it gets dirty, it takes time to purify again.</li></ul><p><strong>Conclusion</strong></p><p>Each person’s journey is unique, with its own twists and turns. I found that I learned the most during the toughest challenges. I consider myself fortunate to have encountered more than my fair share of hurdles during my early months as an engineering manager. It’s through overcoming these obstacles that I truly grew and developed in my role.</p><p>I trust you&#39;ll discover your unique approach and guide your team to success effortlessly. Having a great manager is akin to hitting the jackpot, so strive to be that winning ticket for your team 🌟</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8c458f31da" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Short Summary of Data Breach Resources: Pastebin, Have I Been Pwned, Breach Directory, and more]]></title>
            <link>https://medium.com/@sevillguler/a-short-summary-of-data-breach-resources-pastebin-have-i-been-pwned-breach-directory-and-more-d2efba3a5049?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d2efba3a5049</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[penetration-testing]]></category>
            <category><![CDATA[data-breach-protection]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Tue, 30 Jan 2024 05:12:21 GMT</pubDate>
            <atom:updated>2024-01-30T05:12:21.162Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently started a Penetration Testing course at a known university in Sweden and I’m eager to share the useful information I learn as quickly as possible with 100% for <strong>educational purposes </strong>only. To be honest, I’m a bit nervous about balancing the course with being a mom to a furry boy and a hyperactive toddler, all while working full-time. But I feel this urge to do more with my time. 😅</p><p><strong><em>As usual, I am by no means an expert ….</em></strong></p><p>When I began discussing this topic with others (I tend to get carried away when I’m excited 😶), the first question raised was about distinguishing between data breaches and leaks. So, before we proceed, let’s clarify the difference between data breaches and leaks:</p><blockquote>Leaks and data breaches share similarities as both involve the unauthorized exposure of sensitive information. However, they differ in nature and intent. Data breaches typically result from malicious activities targeting sensitive data, while leaks may occur accidentally or due to negligence. In a data breach, information is accessed without authorization, whereas in a leak, information is disclosed, often unintentionally. While both can lead to significant consequences, leaks may not always involve malicious intent, whereas data breaches are typically deliberate attempts to access sensitive data for wicked purposes.</blockquote><p>Now, let’s delve into our main topic: Data Breach Resources. When was the last time you checked if your email address was compromised in a data breach? Here are some resources to help you with that:</p><ol><li><strong>Pastebin (</strong><a href="https://pastebin.com/"><strong>https://pastebin.com/</strong></a><strong>)</strong>:</li></ol><p>Picture Pastebin as this quirky corner of the internet where folks share all sorts of text snippets — from coding secrets to recipes for unicorn pancakes. However, it’s also utilized by individuals to post lists of compromised email addresses and passwords after data breaches. It’s like a treasure hunt with a touch of digital danger!</p><p>Currently, Pastebin asks for logging-in for search functionality. Despite some <a href="https://medium.com/hengky-sanjaya-blog/google-dorks-utilizing-search-engines-a68aad9a7829">methods to bypass</a> this requirement without breaching any laws, you can choose to skip this step and explore alternative options described below.</p><p><strong>2. Have I Been Pwned (HIBP) </strong>(<a href="https://haveibeenpwned.com/">https://haveibeenpwned.com/</a>):</p><p>Have I Been Pwned is a reputable service designed to help users determine if their email addresses or passwords have been compromised in known data breaches. It’s the place to go when you suspect your email or password might have surfaced in breaches. You just punch in your details, and it’ll tell you if they’ve been caught up in any digital escapades. It’s like having a cyber-fairy godmother watching your back!</p><p><strong>3. Breach Directory</strong> (<a href="https://breachdirectory.org/">https://breachdirectory.org/</a>):</p><p>Breach Directory offers a searchable database of data breaches, allowing you to check if your email addresses have been compromised. It offers more detailed insights into specific breaches compared to Have I Been Pwned. It provides additional information regarding the nature and extent of breaches, including details on the methods used, types of compromised data, number of affected records, duration of the breach, and targeted geographic regions or organizations. The breach directory is your hero, if you would like to gain a deeper understanding of potential risks and exposures and take appropriate measures to safeguard your online security and privacy.</p><p><strong>4. Identity Leak Checker (</strong><a href="https://sec.hpi.de/ilc/"><strong>https://sec.hpi.de/ilc/</strong></a><strong>)</strong></p><p>This tool from the Hasso Plattner Institute in Germany helps you discover if your personal information, including email addresses and usernames, has been compromised online. It offers comprehensive searches for various types of leaks, not just data breaches, providing tailored recommendations to enhance your online security. The response of this tool is a bit slow comparing to the other tool listed above.</p><p><strong>Thankfully, there is also a built-in browser feature …</strong></p><p>While you have a chance to monitor your account’s security and privacy on demand on the websites listed above, Google offers built-in features designed to help its users stay informed about potential security threats related to their online accounts and take appropriate actions to protect their data. This feature is integrated into the Google Chrome web browser. When you enter your login credentials on a website, Google Chrome automatically checks if the username and password combination has been compromised in any known data breaches. If a match is found, Chrome prompts you to change your password for improved security.</p><blockquote>Please be aware that this feature doesn’t provide specific details about the breach or leak itself .</blockquote><p><strong>Until next time…</strong></p><p>While I dive into the exciting world of ethical hacking and hopefully prepare to share my newfound insights with you, let’s keep things secure! Don’t forget to keep an eye on your accounts using tools like Pastebin, Have I Been Pwned, and Breach Directory. Stay ahead of the game by staying vigilant and proactive about your online security. Stay tuned for more updates, and until then, stay safe! 🛡️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d2efba3a5049" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ever tried. Ever failed. No matter. Try again. Fail again. Fail better …]]></title>
            <link>https://blog.venturemagazine.net/ever-tried-ever-failed-no-matter-try-again-fail-again-fail-better-c5e8ee51b758?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/c5e8ee51b758</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[decision-making]]></category>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[embracing-failure]]></category>
            <category><![CDATA[engineering-management]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Tue, 29 Aug 2023 04:02:26 GMT</pubDate>
            <atom:updated>2026-01-21T14:21:24.972Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WkKeNjT3ml5fbsRN7BP87w.png" /><figcaption>Generated by OpenAI</figcaption></figure><h3>Ever tried. Ever failed. No matter. Try again. Fail again. Fail better …</h3><p>Imagine being in a meeting room with many talented people. You see a great idea getting shot down by worries and doubts. Sometimes, even before things begin, one person’s fear can ruin it all. If you’ve never seen this, you’re lucky to not watch opportunities slip away when leaving the room. Cheers to you! 🍻</p><p>Decision-making can turn into a nightmare if luck isn’t on your side. Never-ending meetings, especially when there’s an insistence on precision, can make things worse. In a world that’s constantly changing, predicting tomorrow’s challenges is tricky enough, and trying to stay on top of this dynamic world becomes nearly impossible if we spend excessive time discussing potential issues for solutions that can be easily reversed. And if today’s speed in business or technology feels overwhelming, just wait a few more years to truly grasp the challenge.</p><p>One piece I really appreciate about decision-making is <a href="https://www.sec.gov/Archives/edgar/data/1018724/000119312516530910/d168744dex991.htm">Jeff Bezos’ 1997 letter to shareholders</a>:</p><blockquote>Some decisions are consequential and irreversible or nearly irreversible — one-way doors — and these decisions must be made methodically, carefully, slowly, with great deliberation and consultation. If you walk through and don’t like what you see on the other side, you can’t get back to where you were before. We can call these Type 1 decisions. But most decisions aren’t like that — they are changeable, reversible — they’re two-way doors. If you’ve made a suboptimal Type 2 decision, you don’t have to live with the consequences for that long. You can reopen the door and go back through. Type 2 decisions can and should be made quickly by high judgment individuals or small groups.</blockquote><blockquote>As organizations get larger, there seems to be a tendency to use the heavy-weight Type 1 decision-making <em>process</em> on most decisions, including many Type 2 decisions. The end result of this is slowness, unthoughtful risk aversion, failure to experiment sufficiently, and consequently diminished invention.1 We’ll have to figure out how to fight that tendency.</blockquote><p>Ahhhhhhh isn’t it beautifully put? ⭐️ I admire this statement exactly as it is, and even after 26 years, we still find ourselves stuck in the same patterns again and again. Don’t you think today’s Amazon is the result of this great vision? Even though we have examples of great success, why do we still find ourselves repeatedly falling into the same trap? Is it the company culture’s influence or is it us contributing to the culture? I believe in the power of the ripple effect, even though changing minds is difficult. While company leadership shapes the culture, you can still create change through your actions. Be part of the change you want to see and try to grasp the meaning of proactiveness by practicing it.</p><p><strong>Breathe ….</strong></p><p>When fear fills the room, pause and consider how you can shift the direction of the conversation. It could be beneficial to determine the nature of the decision beforehand or begin altogether by clarifying the decision type. In a noisy room, it might take an act of courage to pause everyone and take a step back to rethink. Be the brave one and step out of the sidelines!</p><p><strong>Focus on solutions, not the problem …</strong></p><p>One of the coolest lessons I picked up during my engineer-y college days was all about zapping problems with solution power. My professor had this epic mantra for us: “Engineers rock the solution scene, not the problem parade!” Let’s give it a cheer, shall we? 😁 This cool idea didn’t only rock school; it got cozy in my real life too. I’m not a total pro at it in real life, though. Sometimes “🙄” I still make problems the star of the show. But here’s my trick: take a break, breathe, and come back swinging!</p><p>Just so we’re clear, I’m not saying ignore problems. Nope! It’s more like saying hi to problems by acknowledging them, then diving into finding solutions and moving forward. Some solutions might bring their own problems, but that’s just how things roll. Keep tweaking, and balancing the risks and values, and don’t get stuck in a swamp of “what if everything goes wrong” thoughts. 🚀</p><p><strong>Remember, fear is the poison of every brilliant idea 😱</strong></p><p>Fear is the poison of every brilliant idea. Acknowledge it, define the risks, analyze it, and give it a try. Most of the time, the risk of doing something is almost none compared to its value but it is a common “human error” to get lost in dwelling on the fear of failure. It might be you or any other party dealing with this poison, make sure iterative development is understood and how beautiful can it be to fail if you learn something from it and do better next time. Don’t waste time dwelling on “what ifs” for too long. As long as you’re not throwing millions around, endangering the company’s reputation, or inviting security disasters, you’re good. Again define the risks, analyze them, and find out the cost and value equation. Most of the time your equation will be far from a reason to worry.</p><p><strong>Choose your relationship with failure wisely</strong></p><p>Let’s be straightforward: if you’ve never failed, you might not have really taken a shot. It’s as simple as that. Failing does not necessarily mean something negative. Most of the time, it brings learning opportunities. You master tweaking and predicting tomorrow’s challenges. Remember, a majority of decisions fall into Type 2, just as Bezos outlined in his letter years ago — they are reversible so make sure you can feel the satisfaction of proudly saying “We gave a shot!” — Whether it’s success or failure, you ultimately come out as the winner.</p><p><strong>Until next time …</strong></p><p>Failure and success dominate every part of our life. From excelling in school to nurturing relationships, thriving at work, and navigating parenthood, these are just a few instances among a long list. However, the principle doesn’t change — take a break, breathe, and come back swinging!</p><p>Please feel free to leave a comment and give your opinion about my articles. It is the community that makes us stronger and inspires more and more. I would like to close this discussion with my favorite line from a song that led to most of my decisions in life especially when I was younger, which is translated from Nietzsche’s letter to his lover Lou Salome, and goes, <strong><em>“</em>If you live in fear, you just watch life<em>.” — “</em>Korkarak yaşıyorsan yalnızca hayatı seyredersin (Turkish)<em>”. </em></strong>If you are reading this, I hope this can inspire you not only for your work but for whatever you have passion for. Cheers!</p><h3>A message from our Founder</h3><p><strong>Hey, </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>Sunil</strong></a><strong> here.</strong> I wanted to take a moment to thank you for reading until the end and for being a part of this community.</p><p>Did you know that our team run these publications as a volunteer effort to over 3.5m monthly readers? <strong>We don’t receive any funding, we do this to support the community. ❤️</strong></p><p>If you want to show some love, please take a moment to <strong>follow me on </strong><a href="https://linkedin.com/in/sunilsandhu"><strong>LinkedIn</strong></a><strong>, </strong><a href="https://tiktok.com/@messyfounder"><strong>TikTok</strong></a>, <a href="https://instagram.com/sunilsandhu"><strong>Instagram</strong></a>. You can also subscribe to our <a href="https://newsletter.plainenglish.io/"><strong>weekly newsletter</strong></a>.</p><p>And before you go, don’t forget to <strong>clap</strong> and <strong>follow</strong> the writer️!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c5e8ee51b758" width="1" height="1" alt=""><hr><p><a href="https://blog.venturemagazine.net/ever-tried-ever-failed-no-matter-try-again-fail-again-fail-better-c5e8ee51b758">Ever tried. Ever failed. No matter. Try again. Fail again. Fail better …</a> was originally published in <a href="https://blog.venturemagazine.net/">Venture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond the Buzz: Efficient Testing on CI]]></title>
            <link>https://medium.com/@sevillguler/beyond-the-buzz-efficient-testing-on-ci-3c2b82c654fd?source=rss-7aec6a1057f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c2b82c654fd</guid>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[test]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Sevil]]></dc:creator>
            <pubDate>Wed, 19 Jul 2023 20:56:04 GMT</pubDate>
            <atom:updated>2023-07-20T06:51:11.418Z</atom:updated>
            <content:encoded><![CDATA[<p>Greetings, everyone! It’s time for the next piece in my series on “<a href="https://medium.com/@sevillguler/effective-ci-cd-for-android-apps-a17bb371c40b"><strong>Unleashing the Power of CI&amp;CD for Android Apps</strong></a>.” Today, I’ll share some practical knowledge about techniques to do efficient testing on CI that can greatly benefit any company looking to reduce its development cost with efficiency.</p><p>If you are having a long feedback loop, high invoices for your CI in the cloud due to the tests taking long time, and are not sure about how to ensure the quality of your test cases, you are in the right place 🎉</p><p>Before we proceed, I want to clarify that this article doesn’t cover the detailed aspects of writing tests. Instead, it focuses on running tests more efficiently and measuring their quality. So, if you’re looking for insights on optimizing your testing process and evaluating its effectiveness, you’re in the right place. Ready? So, let’s dive in!</p><p><strong>…Wait… A kindly reminder</strong></p><p>My references and tooling advice might focus on Android-specific details. However, it is important to note that, in theory, the underlying principles apply to any software development platform or testing environment as long as there are no resource constraints, lack of infrastructure support (legacy systems for example), etc. While the implementation may differ between the platforms, the outlined concepts and guidelines can be adapted and extended.</p><h3><strong>Quality over quantity</strong></h3><p>It is a common antipattern for multiple companies to be trapped with using test coverage as their utmost quality metric. 100% code coverage is a foolish target alone and it is nothing but a well-known common fallacy.</p><p><strong><em>No one succeeds without effort…</em></strong></p><p>While many coverage criteria can be used to assess the completeness of testing efforts, statement coverage, known as line or node coverage, is often considered a minimum requirement for testing, as it helps identify simple syntax errors, basic control flow issues, and missing code paths. However, 100% line coverage doesn’t say much as well as 10% line coverage. Therefore, you should consider combining coverage criteria, such as branch coverage, to achieve slightly more comprehensive testing. I like branch coverage as it requires all decision points, logical operators, and loops to be covered. Each coverage criteria has its value as well as its cost, and to me, branch coverage and line coverage slightly give a better understanding of the completeness of testing efforts with efficiency in cost.</p><p><strong><em>Every effort counts, but …</em></strong></p><p>Don’t be trapped by the fallacy of test coverage. Use it for the right purpose, such as to identify areas of the codebase that are well-covered and require additional testing. What should matter the most is the quality of your tests over quantity. So say hi to <strong><em>mutation testing! 👋</em></strong></p><h4>Mutation Testing</h4><p>Mutation testing simply introduces intentional changes (mutations) into the code and checks if the existing test suite can detect those mutations. Consider your tests like super-vaccines that cure code viruses! Vaccines protect us from harmful bugs, while your tests protect your codebase. But here’s the cool part: mutation tests create mutant code versions, like new strains of viruses. If your tests are strong, they’ll defeat those mutants, too, ensuring your code stays healthy and bug-free.</p><p><strong>The more mutations we zap, the happier our code will be! </strong>The goal is to evaluate the quality and robustness of the test suite by measuring its ability to identify and “kill” these mutated versions of the code.</p><p><strong><em>Nothing comes for free …</em></strong></p><p>You guessed right! Mutation testing is expensive for many reasons, such as test execution time, test suite maintenance, etc. The smartest way would be to identify the most critical tests you have (i.e., tests related to login, signup, payment, etc.) and evaluate their quality and robustness by running mutation tests in a regular cron job.</p><p><strong>Remember the Pareto principle of fault distribution …</strong></p><p>Multiple studies utilize the Pareto principle to confirm fault distribution of software [<a href="https://ieeexplore.ieee.org/document/6235962">1</a>]<a href="https://www.researchgate.net/publication/3188104_Ohlsson_N_Quantitative_analysis_of_faults_and_failures_in_a_complex_software_system_IEEE_Trans_Softw_Eng_268_797-814">[2]</a>. So according to these studies, 20% of the software modules are responsible for 80% of the faults in a project, of course, this principle might neither be applicable nor meaningful if this 20% of modules compose the majority of the project/system size.</p><p>The budget for development always depends on the company. Regardless of your budget, you can start from 20% and iterate over time. So FIND your 20%, define their criticality and priority, and enhance their quality one by one. If you don’t have test metrics to find out your 20%, be best friends with your QA fellows, crashlytics, test analysis tools, etc 💛</p><p>Don’t take the quality as an option but make it the foundation of everything you do. If I am not mistaken, my professor at college was yelling this at least a few years: a wrong software solution is worst than a non-working software solution 😁 😅 Hats off to this wise man✊</p><h3>Speed over perfection</h3><p>In the world of a fast-changing world, speed and agility are essential to be able to stay ahead of the competitive tech world. Besides, slower execution causes a longer feedback loop and increased resource consumption, longer feedback loop and increased resource consumption causes increased cost including the time and resources wasted in the present and the missed opportunities that may arise in the future. Oohh such a delightful chain of events … 😬</p><p>Please don’t take the title wrong, contrary to popular belief you don’t have to compromise on perfection for the sake of speed. It might take time but with consistent effort and efficient tooling, you can aim to have both:</p><h4><strong>Selective Testing</strong></h4><p>Time is money for many reasons, and the execution of all tests generally takes time. So ask yourself, do you really need to execute all of your tests in every commit? Well, not really. If you want to optimize the execution of tests and improve the overall efficiency of the testing process, selective testing would be a vital answer. By selectively running tests and focusing on specific areas or components of the codebase, you can reduce the time and resources required for test execution while still ensuring code quality. Woolah 🎊 🎈</p><p>The following might help you to understand it better:</p><ol><li>When a change is made to a specific module in a PR (pre-merge):</li></ol><ul><li>Identify the module that has changed (e.g., Module A).</li><li>Configure the pre-merge flow to execute only the tests related to that specific module. For example, if the change is in <strong>com.x.moduleA.ExampleClass.kt</strong>, run the tests for <strong>moduleA:unittest</strong> and <strong>:moduleA:uitest</strong> during the pre-merge flow.</li></ul><p>2. If other modules depend on the changed module:</p><ul><li>Identify the modules that depend on the changed module (e.g., Module B depends on Module A, Module C depends on Module B).</li><li>Configure the pre-merge flow to execute the tests for these dependent modules. For example, if the change is in <strong>com.moduleC.ExampleClass.kt</strong>, run the tests for <strong>:moduleA:unittest</strong>, <strong>:moduleA:uitest</strong>, <strong>:moduleB:unittest</strong>, <strong>:moduleB:uitest</strong>, <strong>:moduleC:unittest</strong>, and <strong>:moduleC:uitest</strong> during the pre-merge flow.</li></ul><p><strong><em>More modular is better..</em></strong></p><p>The more modular your software is the better. Think about the described scenario above, if you break down the system into smaller, manageable components, you will have fewer tests to execute whenever there is a change and this can reduce the time required for testing, making the development and testing process more agile.</p><p><strong><em>Gain confidence…</em></strong></p><p>I suggest running all tests with a cron job until you feel safe with your selective testing setup in a regular cadency — start with once a day, then once a week — stop running all tests gradually.</p><h4>Test tagging</h4><p>I know there is at least one feature every project defines as a critical one and there is no tolerance for failure of those. Fair enough. If certain test cases are critical and must be executed with every code change, regardless of selective testing, you can use test tagging. By applying test tagging, you ensure these critical test cases are consistently run to validate the changes made. You can check how test tagging is done for Junit <a href="https://www.baeldung.com/junit-filtering-tests">here</a>. You will most probably use the same tag multiple times then the better way is to create a custom tag annotation to be able to set the standard for all.</p><h4>Test Sharding — put on your dancing shoes and step into the world of parallel executions</h4><p>As we discussed, if you break down the system into smaller, manageable components in a constructive way, you will have fewer tests with selective testing. However, it doesn’t necessarily mean your test suite will be efficiently small or your management will be okay to do selective testing. If any of these applies to you, you can divide a large test suite into smaller subsets or groups called shards with the technique called test sharding. Each shard contains a subset of test cases that can be executed independently and concurrently. The primary goal in implementing test sharding is to distribute the test execution workload across multiple machines or processes, enabling faster and more efficient testing. You can find out how you can do sharding for Android projects <a href="https://source.android.com/docs/core/tests/tradefed/architecture/advanced/sharding">here</a>.</p><p>Test sharding is a fun solution to achieve an efficient testing process but you need to allocate more machines and processes which might not be always feasible and sufficient enough. A combination of other techniques such as selective testing and test tagging can give you a more cost-value balance of the execution workload.</p><p>I see the deadlock but let&#39;s focus on a solution: start with selective testing and test tagging if allocating more machines and processes is not feasible for you initially. Ensure the cost of quality and the importance of iterative development are understood by every party.</p><p><strong>Ever tried. Ever failed. No matter. Try again. Fail again. Fail better …</strong></p><p>Fear is the poison of every brilliant idea. Acknowledge it, define the risks, analyze it, and give it a try. Most of the time, the risk of doing something is almost none compared to its value but it is a common “human error” to get lost in dwelling on the fear of failure. It might be you or any other party dealing with this poison, make sure iterative development is understood and how beautiful can it be to fail if you learn something from it and do better next time. Don’t waste time dwelling on “what ifs” for too long. As long as you don’t spend millions on what you are doing or risk the company losing its reputation somehow or risk having security incidents you will be safe. Again define the risks, analyze them, and find out the cost and value equation. Most of the time your equation will be far from a reason to worry.</p><p>Ah before I forget following is my motto in general and it is almost a candidate to be my next tattoo 😅</p><p><strong><em>We will try, fail, learn, and fail better.</em></strong></p><h3>Wrap up</h3><p>It might be overwhelming to follow all so let&#39;s wrap it up:</p><ol><li>Don’t get tricked by test coverage fallacy — use it for the right purpose, such as to identify areas of the codebase that are well-covered and require additional testing.</li><li>Don’t rely on only line coverage — combine it with other coverage criteria, such as branch coverage.</li><li>Focus on quality, not quantity — be friends with mutation testing and find a way to balance the usage of it with its cost.</li><li>Remember the Pareto principle of fault distribution — FIND your 20%, define their criticality and priority, and enhance their quality one by one.</li><li>You don’t have to compromise on perfection for the sake of speed — use selective testing to optimize the execution of tests and improve the overall efficiency of the testing process in a meaningful way, enhance it with test tagging by executing “critical” tests in every code change.</li><li>Put on your dancing shoes and step into the world of parallel execution</li><li><strong><em>Try, fail, learn, and fail better — don’t be afraid of trying different things. Doing nothing is worst than failing while you are trying to do better.</em></strong></li></ol><h3>What is next?</h3><p>According to the plan, the next article of the series will be Automated Code Quality and Security Checks for Android Apps — well it will take time 😅 Please keep in mind, this series is not focusing on giving you the sample code but the information.</p><p>Thank you for your reading.</p><p>Cheers until next time 🥂</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c2b82c654fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>