<?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[Andersen IT Community - Medium]]></title>
        <description><![CDATA[In-person or online network of people who share a common interest or involvement for collaboration, learning, knowledge sharing, networking, and discussing trends in information technology. Find more about us — https://people.andersenlab.com/ - Medium]]></description>
        <link>https://medium.com/andersen-it-community?source=rss----e06e8e31660a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Andersen IT Community - Medium</title>
            <link>https://medium.com/andersen-it-community?source=rss----e06e8e31660a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 22:57:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/andersen-it-community" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Stop Calling Everything a Technical Audit]]></title>
            <link>https://medium.com/andersen-it-community/stop-calling-everything-a-technical-audit-474d8b85aa14?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/474d8b85aa14</guid>
            <category><![CDATA[consulting]]></category>
            <category><![CDATA[due-diligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[technology-strategy]]></category>
            <dc:creator><![CDATA[Drew Elen Maxwell]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 08:38:42 GMT</pubDate>
            <atom:updated>2026-10-20T08:38:41.323Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MWoa647OkHLGqkz2bFwrBw.png" /></figure><p>A while ago, I was preparing a briefing for a team that was about to work on a Tech Due Diligence engagement. The team already had plenty of experience with architecture reviews and technical audits, which was precisely the problem: everyone knew the familiar mechanics, so it was very easy to assume that Due Diligence was simply the same work with a different report at the end.</p><p>One of the slides reduced the distinction to two questions. A Technical Audit asks: <strong>What is wrong or should be improved?</strong> Tech Due Diligence asks: <strong>What can materially affect the acquisition or business decision?</strong> It looked almost too simple. The same system would still be examined by many of the same specialists, using many of the same activities and much of the same evidence.</p><p>And yet it was not the same product.</p><h3>Same evidence. Different product</h3><p>Assessment work is easy to confuse because it often looks remarkably similar from the outside. We review architecture and implementation, inspect dependencies, talk to engineers, examine delivery history, infrastructure, security controls, tests and operational evidence. Sometimes we add targeted validation where the existing evidence is weak. Eventually, all of that has to turn into findings and conclusions.</p><p>The overlap in mechanics can be enormous while the meaning of the work is different. A Technical Audit may treat systemic coupling as important because it makes ordinary change expensive, risky or slow. Due Diligence may encounter exactly the same condition, but now it has to answer whether this materially changes what a buyer should expect, invest, integrate, price or plan for. Governance may look at the same problem again from yet another direction: are technical decisions and controls sufficient to keep future evolution manageable?</p><p>So the same technical reality can be examined through the same domains, by the same people, using overlapping evidence, and still produce different assessment products. For a long time, I thought the practical difference was mostly in reporting: different audiences, priorities and language. I no longer think that is sufficient.</p><p>The difference starts earlier, in how the assessment itself is designed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNsZst64tw9a1wUtRm0WGw.png" /></figure><h3>The part of the assessment that does not fit into the WBS</h3><p>When we scope an assessment with a client, we normally speak in activities. We may agree to validate an architecture baseline against implementation, review critical integrations, inspect representative code, examine deployment evidence, validate CI/CD controls or review incident history. This is useful language because activities are executable: they can be estimated, assigned, scheduled, priced and placed into a Work Breakdown Structure.</p><p>They are also one of the few things both sides can discuss without sharing the same internal assessment methodology. A client can understand what we are going to look at and which specialists will be involved, while the delivery team can translate the same description into effort and responsibilities. In that sense, activities are the commercial and operational language of the engagement.</p><p>The problem is that an activity does not explain why performing it helps us answer the actual question. “Validate integration and API dependencies” tells us what a specialist will do, but not whether we are looking for hidden dependencies, systemic coupling, a separation constraint, a concentration point, an architectural ceiling or something else entirely.</p><p>This is where I find the concept of a <strong>Concern</strong> useful. A Concern is not another task in the WBS; it is a condition that the assessment needs to establish or rule out because that condition matters to the goal of the engagement. One activity may contribute evidence to several Concerns, while establishing one Concern may require evidence from several activities and even several technical domains.</p><p>The engagement therefore has two structures superimposed on one another. The visible structure contains domains, activities, owners, estimates and dates. The second is the reasoning structure: the selected Concerns that explain what those activities are actually supposed to establish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*zuTX-ITJBsm-gbbpOUAiqQ.png" /></figure><p>This distinction matters because the WBS alone tells us surprisingly little about depth. I can spend half a day or two weeks on an activity called “validate integration dependencies” and claim, in both cases, that the activity was performed. What tells me how far to go is not the activity name but what I am trying to establish, what evidence is sufficient and how much confidence the engagement requires.</p><blockquote><strong>Activities make an assessment executable. Concerns make it defensible.</strong></blockquote><p>This also gives a more precise way to think about Technical Audit and Due Diligence. Their domains may be the same, their activities may be largely the same, and even many of the underlying technical conditions may be the same. What changes is how the relevant Concerns are selected from the purpose of the engagement.</p><p>In a Technical Audit, that connection is often relatively direct. We may start from explicit technical requirements, Quality Attributes, known pain points or expected standards and refine the Concern set as we learn more. If the client wants to understand why the product is difficult to evolve, finding serious systemic coupling is already directly relevant; if availability or scalability is expected to meet a certain level, we investigate the mechanisms behind those expectations and assess the resulting gaps.</p><p>Due Diligence creates a longer chain between technical reality and the final decision. A technical condition has to become an acquisition-relevant Concern; that Concern has to imply a credible consequence; the consequence may affect future obligations, integration effort, investment assumptions or transaction risk; and only after that may it influence the actual acquisition decision. The specialist doing the technical validation may be several steps removed from the people making that final call.</p><p>That distance gives us less freedom to follow whatever looks technically interesting. A technically ugly solution, a legacy component or technical debt are not automatically Due Diligence problems. They become relevant when they create a credible consequence for the business decision the assessment exists to support.</p><p>The meaning of a good negative result changes as well. In a Technical Audit, coverage itself has value: if we assessed an area with sufficient depth and found nothing more serious than the reported issues, that provides useful assurance about the assessed scope. Due Diligence does not need an inventory of everything technically undesirable; it needs sufficient confidence around the conditions capable of materially changing the acquisition conclusion.</p><p>That difference is subtle enough to be missed and important enough to change the work.</p><h3>Technical assessments have a strange quality problem</h3><p>There is another problem hiding behind all of this. Software delivery usually ends in something observable: a feature works or it does not, a migration happened or it did not, a system was deployed or it was not. Engineering quality can still be difficult to judge, but there is at least a concrete product against which the effort can be discussed.</p><p>Assessment work is stranger. Several weeks of expensive senior effort may end in a report, and the client can reasonably ask why that report was worth the money and time spent on it. The number of pages is not a convincing answer. Neither is the number of findings, interviews, reviewed repositories, diagrams, workshops or person-days.</p><p>The problem is made worse by the fact that technical assessment almost never naturally runs out of useful work. There is always another component to inspect, another configuration to verify, another interview to conduct, another change-history sample to examine or another uncertainty that could be reduced. A competent team can continue producing apparently useful activity long after the business value of doing so has started to flatten.</p><p>This makes “we did more work” a very weak definition of “we did better work.” I did not have a particularly satisfying answer to that quality problem at first. It became clearer only after looking at what was actually being delivered under the word “audit.”</p><h3>Sometimes the audit is not even the whole service</h3><p>One client request was commercially described as a Technical Audit, but once we decomposed the work, the engagement did not resemble a single clean audit phase at all. Some preparation was required before meaningful assessment could begin: critical journeys and actions had to be clarified, requirements needed interpretation, and a minimal architectural picture had to exist so that the team had something stable enough to assess.</p><p>Screening then ran alongside targeted testing. Security validation, performance tests or usability work could generate evidence, but the test itself was not the audit. A performance test may tell us that p95 latency is 4.8 seconds; the assessment has to tell us whether that number matters against the relevant requirement, risk or decision context.</p><blockquote><strong>Tests produce evidence. Assessment interprets it.</strong></blockquote><p>The screening itself had to support a much larger decision: whether continued remediation of the current solution remained credible, or whether a rebuild path deserved serious consideration. This was not Due Diligence, but methodologically the logic started to look surprisingly familiar.</p><p>The reason was the magnitude of the decision. Due Diligence does not need a complete inventory of everything technically wrong with a product; it needs to identify the conditions capable of materially affecting an acquisition. Our screening had a different decision to support, but the same pressure existed: we did not need to understand every weakness of the existing system. We needed to know whether there were conditions serious enough to change the answer to a much larger question — should we continue investing in this product at all, or begin considering replacement?</p><p>Once an assessment supports a decision of that magnitude, exhaustive technical completeness becomes less useful than deliberate selection of the Concerns capable of changing the decision. Different assessment products can therefore begin to resemble one another methodologically without becoming the same service.</p><p>At that point, calling everything inside the engagement “audit” became actively unhelpful. Some work was assessment, some was validation, some was decision support, and some existed because the client needed enough information to understand what could sensibly happen next.</p><p>There were also parallel engineering projects changing the environment while it was being assessed. Troubleshooting existed nearby as another kind of technical work that could use the same logs, interviews, code and tests while pursuing a different objective: explain and fix a known undesirable behavior rather than assess the system broadly. After the assessment, discovery and planning continued the engagement by converting selected conclusions into possible next steps.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5bSl-XopE6rZ3meNn0HZ3Q.png" /></figure><p>The diagram is not intended as a reference methodology for audits. Its value is almost the opposite: it is one real example of what can hide behind a familiar commercial label once the actual client problem is decomposed into the different kinds of work required to solve it.</p><h3>And then the audit ends — but the client’s problem does not</h3><p>An assessment can legitimately conclude that a dependency is dangerous, that an architecture does not credibly support the required scale, that the release process creates unacceptable operational risk, or that a particular boundary should be isolated or replaced. Those conclusions can be correct, evidence-based and useful while still being insufficient for implementation.</p><blockquote><strong>A recommendation is not a plan.</strong></blockquote><p>“Reduce coupling” does not tell an organization which boundary should move first, what must coexist during transition, which teams will be needed, what can fit before a deadline or how existing commitments survive the change. Discovery, remediation planning, target design and sequencing consume assessment findings, but they operate with different inputs, produce different artifacts and have different criteria for being done.</p><p>Keeping those activities separate also protects the assessment itself. A finding should be challengeable with better evidence or corrected when it rests on a factual misunderstanding, but it should not be negotiated until it becomes comfortable. If remediation starts during the engagement, the assessed object should not silently move underneath the report every time an uncomfortable condition is discovered.</p><p>The assessment therefore needs a reasonably stable evidence boundary. The change program may start immediately afterward, and in practice the two may even overlap operationally, but they are still not the same work.</p><h3>The toolbox is larger than the audit</h3><p>Once these boundaries become visible, a wider pattern emerges. Audit, Due Diligence, testing, troubleshooting, governance, screening and downstream discovery can reuse much of the same technical machinery. The same architect may participate in several of them, the same repository may be inspected, and the same diagram, test result or log entry may be useful in more than one context.</p><p>What changes is what the work is trying to produce. Troubleshooting looks for the cause of a known problem, testing establishes observable behavior, an Audit assesses technical conditions against relevant expectations, and Due Diligence asks which conditions matter to a business or acquisition decision. Governance tries to improve future technical decision-making, while discovery and planning convert selected findings into an executable change path.</p><p>The dangerous mistake is therefore not simply using the word “audit” too loosely. The larger mistake is allowing the commercial label to dictate the production model. If a client buys something called a “Technical Audit,” I do not particularly care what the purchase order says as long as we understand what problem the engagement is supposed to solve and have assembled the right types of work to solve it.</p><p>The client-facing label does not have to match the internal production model. In that sense, this is simply product thinking applied to a consulting service: start from the problem the client actually has, identify the capabilities needed to solve it, and resist the temptation to force every engagement through one convenient methodology.</p><h3>This is where Lean suddenly becomes very practical</h3><p>Now the earlier quality problem becomes easier to approach. If an assessment can continue producing technically useful work almost indefinitely, the important question is not whether more work exists but what work deserves to remain inside the scope.</p><p>I find Lean thinking more useful here than the usual argument about “quality versus budget.” That argument often assumes that somewhere there is a correct full scope, that additional budget allows us to execute more of it, and that less budget means removing pieces and therefore accepting lower quality. The planning conversation then becomes:</p><blockquote><strong>What do we have to cut to fit the deadline and budget?</strong></blockquote><p>This is planning by subtraction. We begin with a package larger than the available capacity and progressively damage it until it fits. The alternative is to begin from the value the engagement must create, identify the minimum coherent body of work required to answer the relevant Concerns with credible confidence, and then ask what additional work deserves the remaining capacity. Now the question becomes:</p><blockquote><strong>What is the most valuable thing we can add next?</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7DexJMtoYAS4KxP3yn1Jyw.png" /></figure><p>This does not imply that Lean automatically makes the engagement cheaper. Two teams may spend exactly the same money and the same eight weeks while using those eight weeks very differently. One may spend most of the engagement squeezing a predefined package into the available constraints, while another first secures the work required for the most important conclusions and then invests the remaining capacity where it is most likely to change the result.</p><p>There is no simple “highest value first” algorithm hiding here. Activities have dependencies, apparently low-value tasks may unlock much more valuable conclusions, evidence often becomes meaningful only when combined across several sources, and specialist work may need to happen before another workstream can proceed. Lean is useful not because it solves this optimization problem for us, but because it changes the direction from which we approach it: we work backward from the value and assurance we need rather than forward from an inventory of available work.</p><p>That places more pressure on expert judgment, not less.</p><blockquote><strong>Lean does not make the assessment simpler. It makes the execution smaller by making the decision about what to execute harder.</strong></blockquote><h3>Business value minus cost</h3><p>For this kind of work, I find an economic model more useful than an efficiency ratio. The objective is not to maximize “value per architect-hour,” because a locally inefficient task may still be essential if it unlocks several important conclusions. What matters at the engagement level is closer to maximizing:</p><blockquote><strong>Business Value − Cost</strong>.</blockquote><p>There is usually a minimum coherent set of work below which the deliverable has very little credible value. Once that threshold is crossed, value may rise quickly as important uncertainties are resolved and decision-relevant conclusions become possible. Later, additional investigation often produces diminishing returns: another repository, interview or validation sample may still improve technical completeness while adding almost nothing to the business decision the assessment exists to support.</p><p>This gives us a practical way to think about both depth and stopping. An activity deserves more effort while additional validation can still materially change a relevant Concern, the confidence in the conclusion, its consequence or the credible response. Eventually that stops being true, even though more technically useful work remains available.</p><p>The resulting stopping rule is stronger than “we ran out of budget” and more realistic than “we inspected everything.” Quality is not maximum technical completeness; it is producing decision-relevant information with enough confidence for the purpose of the engagement. Thoroughness in the wrong direction is still waste.</p><p>The dangerous waste in technical assessment is not obviously useless activity. It is <strong>necessary-looking activity optimized for the wrong objective</strong>.</p><p>Time makes the economics less linear still. Before a board meeting, transaction milestone, regulatory deadline or launch decision, another week may be affordable; after that date, the cost of the same week may rise sharply. A technically better report delivered after the decision it exists to support can therefore be a worse business product.</p><blockquote><strong>Effort explains cost. Value justifies it.</strong></blockquote><h3>There is a sales problem hiding in here too</h3><p>The same model changes the commercial conversation. If a Technical Audit is sold as one indivisible package, the main lever available to Sales is usually price. If the engagement is understood as a composition of different capabilities, there are more meaningful ways to adjust it.</p><p>A client may not need independent performance validation, in which case that evidence stream can be removed and the resulting limitation in assurance stated explicitly. Another client may need findings and recommendations but not an implementation roadmap, so the service can stop at assessment. A third may need the findings translated into target designs, responsibilities, sequencing, budget ranges and deadlines, in which case downstream discovery and planning should be treated as additional work rather than as free paragraphs at the end of the report.</p><p>The model works in the other direction as well. If early screening shows that the viability of the current platform is itself uncertain, a rebuild-path assessment may become necessary even though it was not part of the original package. This is both down-sell and up-sell, but for a better reason than commercial optimization alone: the service changes because the client problem changes.</p><p>Instead of asking how much discount we can give on the audit, we can ask which service the client actually needs. For an outsourcing company, there is something slightly amusing about applying product thinking to a consulting service, but the logic is the same.</p><h3>So what exactly are we doing?</h3><p>I started with a small briefing slide: Technical Audit asks what is wrong or should be improved, while Tech Due Diligence asks what can materially affect the acquisition or business decision. At first, this looked like taxonomy. After enough engagements, it started looking much more like a production problem.</p><p>We can inspect the same technical reality through the same domains, execute many of the same activities and even encounter the same underlying technical conditions. What changes is why those conditions matter, which Concerns deserve investigation, how deep we need to go, what evidence is sufficient, what the result is supposed to enable and, ultimately, when the work is done.</p><p>Once that distinction is visible, the argument extends beyond Audit and Due Diligence. Sometimes we are assessing, sometimes validating, sometimes troubleshooting, sometimes designing the next move, and sometimes building governance so that future moves become more controlled. Several of these may legitimately appear inside one engagement and may even be sold under one convenient name.</p><p>That is fine, as long as we do not confuse the name with the work.</p><p>So stop calling everything a Technical Audit — not because the label itself matters very much, but because once we stop hiding different kinds of work behind the same label, we can finally ask the questions that do matter:</p><blockquote><strong>What value are we supposed to create? <br>What conditions do we need to understand to create it? <br>What work will establish them? <br>And when have we done enough?</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=474d8b85aa14" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/stop-calling-everything-a-technical-audit-474d8b85aa14">Stop Calling Everything a Technical Audit</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Median-Pessimistic Scenario: Choosing Reality Before Estimating It]]></title>
            <link>https://medium.com/andersen-it-community/the-median-pessimistic-scenario-choosing-reality-before-estimating-it-053a39cb101f?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/053a39cb101f</guid>
            <category><![CDATA[decision-making]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-estimation]]></category>
            <dc:creator><![CDATA[Drew Elen Maxwell]]></dc:creator>
            <pubDate>Tue, 20 Oct 2026 08:35:29 GMT</pubDate>
            <atom:updated>2026-10-20T08:35:28.563Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZqKyquNcvc7o1LB4Et3OQw.png" /></figure><p><em>How I discovered that removing delivery noise from engineering estimates was not enough — and why scenario selection turned out to be the missing piece.</em></p><h3>The Day I Almost Solved Software Estimation</h3><p>Some time ago, a designer approached me with a familiar problem. They needed to estimate the effort required to design a set of screens, but could not provide a reliable number because nobody knew how much communication and clarification would be necessary. Requirements were still moving, questions were unanswered, and the estimate was getting buried under all the uncertainty surrounding the actual work.</p><p>I suggested a simple solution. Imagine that all requirements are already known, every important question has been answered, and all necessary decisions have already been made. Under those conditions, how much time would it take to do the design work itself?</p><p>The answer came almost immediately. Once the design effort had been separated from communication and clarification, we could estimate the design work directly and discuss the communication overhead as a different problem.</p><p>At that moment, I was rather pleased with myself. It briefly seemed possible that humanity had spent decades suffering through estimation difficulties only because nobody had suggested estimating different things separately. I was ready to enjoy the magnificent glow of my own architectural brilliance.</p><p>Unfortunately, reality remained unimpressed.</p><p>The method genuinely worked, and I later formalized that way of thinking in my article, <a href="https://medium.com/andersen-it-community/effort-time-estimation-the-core-model-behind-predictable-delivery-9bca7ed4e7a0"><em>Effort &amp; Time Estimation: The Core Model Behind Predictable Delivery</em></a>. It introduces <strong>Ideal Man-Hours (IMH)</strong>: the idea that pure implementation labor should be estimated separately from communication, planning, technical design, and other delivery-related activities. That model helped a great deal. It made estimates easier to explain, easier to compare, and far less vulnerable to all-purpose confusion.</p><p>But then I found myself planning a larger project — something on the order of 35 people and a year of work, months before implementation would even begin. Requirements were incomplete, major technical decisions had not yet been made, and much of the future system existed only as assumptions.</p><p>I could still separate implementation labor from communication overhead. I could still model technical design and planning separately. I could still avoid mixing delivery friction into the estimate for actual implementation work.</p><p>But even after removing all of that noise, a different question remained.</p><blockquote><strong>What implementation was I actually estimating?</strong></blockquote><p>The designer had one advantage: they had me to help reformulate the question. I, unfortunately, had no second me available for consultation. A regrettable organizational oversight. So I had to resort to the Baron Munchausen method and pull myself out of the swamp by my own hair.</p><p>That was the point at which I realized that solving the <em>conditions</em> of estimation was not the same thing as solving the <em>object</em> of estimation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NT5LiEU5eUWm4zftlLVWAA.png" /></figure><h3>Ideal Working Conditions Are Not an Optimistic Implementation</h3><p>This was the distinction I had been missing.</p><p>Ideal Man-Hours describe labor under ideal <strong>working conditions</strong>. We assume that the engineer already knows what needs to be built, understands the solution, and can perform the work without interruptions, waiting, or organizational overhead. The estimate concerns implementation labor itself. Other activities belong elsewhere in the model.</p><p>At first glance, this can look suspiciously optimistic. Everything has already been discussed, all decisions have already been made, and nobody is blocked by anything. The engineer just sits down, writes the code, and occasionally drinks coffee. It feels so comfortable that many people instinctively assume the result must therefore be optimistic too.</p><p>But that is a category mistake.</p><p>The fact that we exclude delivery friction from the estimate does not mean we have chosen a favorable implementation. It only means that we have isolated the labor of implementation from the surrounding process.</p><p>Imagine a future integration with a legacy banking system. In one possible reality, the available interface is clean, consistent, and well documented. In another, it has limitations, requiring extra transformations, custom authentication handling, and awkward error recovery. In a third, deeper architectural restrictions force us to abandon the preferred integration approach and adopt something less elegant.</p><p>All of these implementations can be estimated in IMH. In every case, the engineer is assumed to know what to build and to build it under ideal execution conditions. But the labor required can differ dramatically because the implementation itself differs.</p><p>So IMH solves one problem very well: it tells us how to measure effort. It does <strong>not</strong> tell us which future implementation we should imagine when we measure it.</p><p>And during early planning, that second question becomes the harder one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SXQ2RfXuBRSEGpt_uthFjQ.png" /></figure><h3>Why I Prefer One Number</h3><p>I have long preferred asking experts for one effort estimate instead of three.</p><p>This is not because I think three-point estimation is mathematically absurd. Methods such as PERT have legitimate mathematical roots. Under the right assumptions, they make sense. The problem is more practical and more human: in many real presales and early planning situations, experts cannot credibly provide the kind of inputs those methods implicitly require.</p><p>What exactly does <em>Optimistic</em> mean? The best physically possible outcome? A favorable but plausible one? A low percentile of some imagined distribution? And what does <em>Most Likely</em> mean when the expert does not actually possess a meaningful probability distribution of future implementation outcomes? <em>Realistic</em> is even worse, because it sounds useful while meaning almost anything.</p><p>My experience has been that asking for several numbers often creates the appearance of precision without necessarily improving the quality of understanding. It also consumes more effort than it seems to. An expert must repeatedly shift mental context, construct several variants of the future, and maintain some internal consistency between labels whose boundaries are not stable in the first place.</p><p>I would rather have one number that the expert can genuinely explain than three numbers that cannot survive interrogation.</p><p>But one-number estimation has an obvious weakness. If you only ask for one number, what future does that number describe? The answer cannot simply be “whatever the expert happened to imagine.”</p><p>That missing piece is what I eventually started calling the <strong>Median-Pessimistic Scenario</strong>.</p><h3>The Median-Pessimistic Scenario</h3><p>I did not invent the term while trying to improve estimation.</p><p>I first started using it while working through unclear requirements and uncertain technical assumptions. I needed a practical way to reason about a future that was not yet known, without relying on optimistic assumptions and without getting lost in catastrophic fantasies. What I needed was a disciplined way to choose a plausible working reality.</p><p>The procedure is simple.</p><p>First, consider plausible scenarios. Then discard those that depend significantly on unsupported optimistic assumptions. After that, order the remaining scenarios by their degree of pessimism and select the median.</p><p>That selected scenario becomes the one in which further reasoning takes place.</p><p>A scenario here is not a number. It is a description of a possible reality: assumptions, constraints, choices, consequences, relationships, and trade-offs. It may later be used to estimate labor, but it is not itself a labor estimate.</p><p>This is crucial, because pessimism is not the same thing as cost.</p><p>A more unfavorable scenario can lead to a cheaper implementation. Suppose the external API turns out to be so poor that the team abandons the idea of building a rich real-time integration and falls back to a much simpler file-based exchange, where the requirements permit it. That reality may be substantially worse from the perspective of architecture, data freshness, or operational quality. Yet the development effort may be lower than in a more elegant but technically difficult real-time solution.</p><p>This is why MPS should not be read as “take the pessimistic side of the effort distribution and choose its median.” We are not ordering labor values first. We are choosing a scenario first and estimating consequences later.</p><p>When credible scenario probabilities exist, they can inform the choice. When they do not, the result remains a structured expert heuristic. Either way, the central move is the same: we first choose a sufficiently grounded future to reason inside.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*t-xLnyHadd-o4p5I_bblyQ.png" /></figure><h3>Why This Region of Scenario Space?</h3><p>The median-pessimistic region is not attractive to me simply because it is conservative.</p><p>The deeper reason is that I suspect experts often think more effectively there.</p><p>Engineers are trained, socially and professionally, to reason about problems. We look for constraints, weak points, incompatible assumptions, integration risks, missing information, and failure modes. This is not pathological pessimism; it is much of what engineering competence consists of. As a result, moderately unfavorable scenarios are often easier to construct, challenge, and defend than strongly favorable ones.</p><p>Optimistic scenarios frequently depend on a very different kind of material. A third-party interface turns out to be more convenient than expected. A reusable component fits perfectly. Hidden complexity does not materialize. Several uncertainties all resolve in the easier direction. Such things certainly happen, but before they are confirmed, they are often supported more by hope than by knowledge.</p><p>This leads to a working hypothesis.</p><p>There may be a region of scenario space in which expert reasoning is relatively stable: not because every task is simple, and not because every scenario there is equally likely, but because this region tends to contain the kinds of complications engineers are actually good at thinking about.</p><p>In relatively straightforward tasks, this can produce something like a plateau: neighboring scenarios differ in details without fundamentally changing the implementation narrative. If such a stable region exists, minor variations in assumptions or scenario granularity may have less influence on the selected baseline.</p><p>That plateau is not mandatory. Sometimes it will not exist. And when it does not, that is useful information. If small changes in assumptions around the median-pessimistic region produce substantially different implementation narratives, the task may contain important unresolved alternatives, possibly across several interdependent aspects. That is not a failure of the method. It is a signal that the problem deserves additional investigation or decomposition.</p><p>Of course, engineering experience can also produce exaggerated pessimism. A particularly painful incident from a previous project does not automatically make the same outcome plausible in the next one. Scenarios still need to be grounded in the available context; pessimism alone is not evidence.</p><p>So the value of the median-pessimistic region is not that it is always smooth. The value is that it is often a useful place to start, and when it is not, that fact becomes visible.</p><p>This is a hypothesis drawn from professional practice, not an empirically established law about expert judgment. But it offers a reason for choosing this region that goes beyond simply adding a safety margin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jb5QgR08FbiEKGZSHZ9NkQ.png" /></figure><h3>Optimism Belongs in Opportunity Management</h3><p>Once I started thinking this way, another conclusion followed naturally.</p><p>If optimistic scenarios are often not robust enough to support the baseline, that does not mean they are useless. It means they belong somewhere else.</p><p>They belong in <strong>opportunity management</strong>.</p><p>Suppose a simpler implementation becomes possible if a reusable adapter turns out to fit, or if an interface can be improved, or if a certain technical shortcut can be validated. Those are not assumptions that should quietly sit inside the baseline estimate as if they were already true. They are opportunities that may be pursued.</p><p>This is, in my view, a sign of managerial maturity.</p><p>An immature planning culture bakes optimism directly into commitments and then acts surprised when reality refuses to cooperate. A more mature culture builds a plan that works without requiring good luck and then actively works to create favorable conditions. If a simpler path exists, investigate it. If a dependency can be improved, improve it. If a more efficient design is possible, validate it and revise the baseline accordingly.</p><p>In other words, we do not need to forbid optimism. We need to stop treating it as free.</p><p>A plan should not require optimism in order to be viable. Optimism should appear as the result of deliberate work.</p><h3>From Scenario to Estimate</h3><p>Once the scenario has been chosen, the connection to estimation becomes straightforward.</p><p>An engineer considers the selected Median-Pessimistic Scenario and estimates the implementation labor required within it. That labor is then expressed in Ideal Man-Hours.</p><p>At this point the roles are clear.</p><p><strong>MPS answers:</strong> Which implementation reality are we using as our baseline?</p><p><strong>IMH answers:</strong> How much pure engineering work does that implementation require?</p><p>This separation is useful because it keeps the estimate explainable. If somebody wants to challenge the number, the discussion can return to the scenario and its assumptions instead of sliding into arguments about whether “realistic” meant P50, P60, or “whatever we can get away with.”</p><p>It also makes the framework reusable. The same scenario can be used not only to estimate engineering effort but also to assess infrastructure consequences, operational costs, or other effects. The scenario becomes the context for analysis; the expert — human or AI — turns that context into the relevant estimate or assessment.</p><p>For small tasks, this scenario may exist only in the expert’s head. For larger work packages, uncertain requirements, collaborative analysis, or AI-assisted estimation, making it explicit becomes increasingly useful.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LOG7SLl28pH7_ttGg9Wy4A.png" /></figure><h3>Uncertainty Is Still There</h3><p>A median-pessimistic baseline does not remove uncertainty. It only gives that uncertainty a better anchor.</p><p>Some favorable developments may still occur. Some negative deviations may still materialize. That remaining uncertainty should not be confused with the baseline itself.</p><p>In my broader estimation model, I prefer to represent uncertainty separately, using practical categories rather than pretending to derive exact probabilities from weak input. Some of that uncertainty sits on the downside, some of it on the upside, and the upside is where opportunity management becomes relevant. The favorable side is not just a collection of nice things that might happen. It also contains conditions we can deliberately work to create.</p><p>This helps answer a concern that naturally appears at project level. If many work items are estimated from median-pessimistic baselines, does conservatism accumulate?</p><p>It may influence the aggregate, but that is not automatically a flaw. The baseline is intentionally constructed without relying on unsupported favorable assumptions. If the resulting plan is conservative, we do not need to artificially reduce the estimate to account for good fortune that has not yet been earned. We can instead investigate and pursue opportunities for simpler implementation.</p><p>There is also a distinction between aggregating coherent engineering estimates and mechanically combining unrelated pessimistic outcomes. Shared implementation work should not be counted repeatedly, and local scenarios must be compatible with the broader system architecture and project assumptions. A collection of local MPS estimates is not automatically the same thing as the MPS of the entire project.</p><p>The distinction matters even more when risk exposure enters the picture. If a scope has a baseline of 500 IMH and another 200 IMH of possible adverse deviation, that does not automatically mean the project budget must become 700 IMH. Risk exposure is not the same thing as contingency. Some risks should be mitigated, some accepted, some investigated, some avoided, and some converted into explicit delivery decisions.</p><p>Again, the point is not that MPS solves all of that. The point is that it gives the rest of the framework a cleaner foundation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pmEJmNEdnDJxuKxuyv5liQ.png" /></figure><h3>A Better Starting Point for Planning</h3><p>The value of estimation is not in producing numbers for their own sake. It is in helping us make decisions: what belongs in scope, where to investigate first, what can be committed, and what must remain conditional.</p><p>For that, we need a baseline that actually means something.</p><p>MPS provides such a baseline by choosing a reality before estimating within it. IMH then measures the implementation labor of that chosen reality without mixing it with communication overhead, technical design, or delivery friction. Uncertainty remains separate. Risks remain separate. Opportunities remain separate. Each part of the framework gets to do its own job.</p><p>Under a fixed deadline, a conservative baseline may initially leave less room for scope. But when opportunities are realized and implementation effort is reduced, the released capacity can be allocated to additional items from a prioritized backlog. This makes favorable outcomes useful without depending on them when making the original commitment.</p><p>That, in the end, is why the concept turned out to be useful far beyond the problem in which I first found it. I did not create it as an estimation formula. I created it as a way to reason about unknown future implementations without either daydreaming or catastrophizing. Estimation just happened to be one place where that discipline turned out to be especially valuable.</p><p>The designer had me to help reformulate the question. I had to find a way to ask myself a better one.</p><p>Fortunately, that turned out to be easier than finding a second me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=053a39cb101f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/the-median-pessimistic-scenario-choosing-reality-before-estimating-it-053a39cb101f">The Median-Pessimistic Scenario: Choosing Reality Before Estimating It</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why pnpm Exists: Rethinking node_modules]]></title>
            <link>https://medium.com/andersen-it-community/why-pnpm-exists-rethinking-node-modules-9c5d56e0bdb1?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/9c5d56e0bdb1</guid>
            <category><![CDATA[node-modules]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[npm]]></category>
            <category><![CDATA[pnpm]]></category>
            <dc:creator><![CDATA[Margarita Zakharova]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 09:37:40 GMT</pubDate>
            <atom:updated>2026-10-15T09:37:39.548Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xmDhpvN-qDbyyCxD7AHPEg.png" /><figcaption>Why pnpm Exists: Rethinking node_modules</figcaption></figure><p>If you work with JavaScript or TypeScript, <em>npm install</em> was probably one of the first commands you learned. It is simple, familiar, and, most importantly, it works.</p><p><em>So why would anyone create another package manager?</em></p><p>Let’s find out.</p><h3>What npm actually does</h3><p>NPM, short for Node Package Manager, is the default package manager for Node.js, which solves many of the problems that developers faced a decade ago. It provides lockfiles, workspaces, security auditing, and multiple installation strategies.</p><p>At a high level, npm takes the dependency information from your package.json and lockfile and uses it to build the <strong>node_modules</strong> directory on your disk:</p><ul><li>npm determines which packages are required;</li><li>which versions of those packages should be installed;</li><li>where each package should live inside node_modules.</li></ul><p>The tricky part is that dependencies can overlap. If two packages require the same version of a dependency, npm can usually install a single copy and let both packages share it. But if they require different versions, npm may need to install multiple copies of that dependency.</p><p>To minimize this duplication:</p><ul><li>npm uses hoisting: when a dependency can be safely shared, npm moves it higher in the node_modules tree. This allows multiple packages to resolve the dependency from the same location.</li><li>npm dedupe command: it can reorganize the installed dependency tree. It allows packages to share dependencies whenever possible.</li></ul><p>In other words, npm is not simply copying every dependency into node_modules. It is solving a dependency-resolution problem: it must find a directory structure that satisfies the entire dependency graph while sharing as many packages as possible and avoiding unnecessary duplication.</p><p>And that’s where the real complexity begins.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L6m6sOJzV8vho_60LyK-Pg.jpeg" /><figcaption>Inside npm</figcaption></figure><h3>The hidden cost of node_modules</h3><p>The traditional node_modules layout is convenient, but it has two important drawbacks.</p><h3>1. Dependencies can be duplicated</h3><p>Real dependency graphs often contain different versions of the same package. With hundreds of dependencies, this can produce many files and filesystem operations, especially when installing in CI, switching branches, or working across multiple applications.</p><h3>2. Hoisting can hide missing dependencies</h3><p>Suppose your application declares package-a, and package-a depends on lodash. Your application does not declare lodash itself. Because of hoisting, the root node_modules might still contain it, allowing the application to import it.</p><p>This is a <strong>phantom dependency</strong>: the application uses a package that it never declared.</p><p>The problem appears when package-a changes and no longer depends on lodash. The application can suddenly fail with Cannot find module ‘lodash’. Nothing in the application changed; it was relying on another package’s internal dependency.</p><p>Thus, while node_modules is convenient, hoisting can make dependency boundaries less explicit.</p><p>So node_modules is convenient, but that convenience comes with a cost: <strong>duplicated files, filesystem work, and dependencies that can appear to exist when they don’t actually belong to your project.</strong></p><h3>So what exactly is pnpm?</h3><p>pnpm, short for Performant npm, is another package manager for the Node.js ecosystem. Its key idea is a <strong>content-addressable store</strong>.</p><p>Imagine three projects all using the same version of React. Instead of maintaining three independent physical copies, pnpm stores the package contents in a shared store and reuses them across projects.</p><p>When a project needs those files, pnpm can create <strong>hard links</strong> to the store instead of copying the data. A hard link lets multiple paths refer to the same underlying data, so many projects can reuse the same package files.</p><p>This saves disk space.</p><h3>Hard links and symlinks</h3><p>Hard links solve the storage problem, but pnpm also needs Node.js to resolve dependencies correctly. This is where <strong>symbolic links</strong>, or symlinks, are used.</p><p>The core idea is:</p><p><strong>Hard links → reuse package data;</strong></p><p><strong>symlinks → construct the dependency graph.</strong></p><p>Node.js does not require dependencies to physically exist in a traditional flat node_modules directory. pnpm uses Node’s module-resolution behavior to create a different layout while remaining compatible.</p><p>This also helps solve phantom dependencies:</p><ul><li>a package can access the dependencies it declares;</li><li>the application does not automatically gain access to every transitive dependency;</li><li>package.json becomes a more accurate description of what the application actually needs.</li></ul><h3>Installation and reuse</h3><p>Conceptually, pnpm installation has three stages:</p><ol><li>Resolve dependencies.</li><li>Calculate the required directory structure.</li><li>Link dependencies from the store into node_modules.</li></ol><p>If you delete node_modules and run pnpm install again, packages already present in the store can be reused rather than downloaded and copied from scratch.</p><h3>Monorepos and shared projects</h3><p>If several applications share packages such as React, TypeScript, ESLint, or Vite, a traditional setup can store the same package files repeatedly. With pnpm, each project still has its own dependency structure, while the underlying files can be shared through the common store.</p><p>This is especially useful with <strong>monorepos</strong>: pnpm workspaces allow applications and shared packages to coexist in one dependency graph and link local packages directly.</p><h3>Reproducibility</h3><p>Another important benefit is predictable dependency resolution.</p><p>Suppose package.json contains: “some-library”: “³.0.0”</p><p>The ^ range allows multiple compatible releases. Without a lockfile, the resolved dependency tree can change as new versions are published.</p><p>Lockfiles solve much of this problem by recording the actual resolution. npm uses package-lock.json; pnpm uses pnpm-lock.yaml. The lockfile records the resolved dependency graph, helping development and CI environments reproduce the same installation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C5Ku3NpfhnoEQ3T2fdFvzw.avif" /><figcaption>Inside pnpm</figcaption></figure><h3>Is pnpm always faster?</h3><p>Not necessarily. Installation performance depends on cache state, network speed, dependency count, disk performance, CI environment, filesystem, and registry performance.</p><p>pnpm can have a significant advantage when packages are already available in its store because linking existing files can be cheaper than repeatedly copying them. But a completely new dependency graph still has to be downloaded. There is no magic performance boost.</p><h3>What are the downsides?</h3><p>pnpm has trade-offs.</p><p><strong>First, some tooling expects flat node_modules.</strong> Older tools may assume dependencies are hoisted into the root directory. pnpm’s isolated layout can expose these assumptions, although configuration options can help with legacy tooling.</p><p><strong>Second, migration can reveal broken dependency declarations.</strong> An old project may work with npm because it accidentally relies on a transitive dependency. Switching to pnpm can expose this missing declaration. That can be annoying, but it also fixes a real dependency-management problem.</p><p><strong>Third, filesystem behavior matters.</strong> pnpm relies on hard links and symlinks, so unusual filesystems, containers, or deployment platforms may impose restrictions. Production and CI environments should be tested before adopting pnpm everywhere.</p><h3>What about security?</h3><p>pnpm does not magically make JavaScript dependencies secure. A different filesystem layout cannot make a malicious package trustworthy.</p><p>Dependency isolation can improve dependency hygiene by making the graph more explicit, and pnpm supports auditing and overrides for vulnerable transitive dependencies. Still, <strong>dependency isolation ≠ dependency security</strong>. Production systems should continue to use lockfiles, vulnerability scanning, CI checks, dependency review, and careful monitoring.</p><h3>Should everyone use pnpm?</h3><p>The short answer is “No”.</p><p>For a small Node.js project with only a few dependencies, npm is perfectly reasonable. There is little value in adding complexity simply because another tool is fashionable.</p><p>pnpm becomes more attractive when you have many projects on one machine, large dependency trees, large monorepos, multiple applications sharing dependencies, significant CI installation costs, concerns about undeclared dependencies, or substantial node_modules disk usage.</p><p>For a large TypeScript monorepo, pnpm can be a compelling choice. For a tiny script, npm may be all you need.</p><h3>The bigger idea behind pnpm</h3><p>The interesting part of pnpm is not the command pnpm install. It is the question behind it:</p><p><em>Why should every project own another physical copy of the same dependency?</em></p><p>The traditional node_modules model prioritized simplicity and compatibility, but its costs become more visible as applications grow. pnpm stores package contents centrally, reuses them through hard links, and connects them into each project’s dependency graph with symlinks. Projects still behave as if they have their own dependencies, while the underlying data is shared and dependency boundaries remain explicit.</p><h3>Final thoughts</h3><p>npm is not bad. Modern npm has evolved considerably and provides many of the tools developers need. But its traditional hoisted node_modules model can lead to duplicated files, filesystem overhead, and dependencies that appear available even when they are not declared.</p><p>pnpm takes a different approach: it stores package contents centrally, reuses them through hard links, constructs dependency relationships with symlinks, and keeps dependency boundaries more explicit.</p><p>The result is not simply “npm, but faster.” It is a different model for installing and managing dependencies: sometimes the best optimization is to stop doing the expensive thing in the first place.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c5d56e0bdb1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/why-pnpm-exists-rethinking-node-modules-9c5d56e0bdb1">Why pnpm Exists: Rethinking node_modules</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Not to Lose a Tender Before You Even Submit Your Bid: 5 Practical Steps]]></title>
            <link>https://medium.com/andersen-it-community/how-not-to-lose-a-tender-before-you-even-submit-your-bid-5-practical-steps-295e6505ae60?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/295e6505ae60</guid>
            <dc:creator><![CDATA[Vera Nikanchyk]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 09:34:25 GMT</pubDate>
            <atom:updated>2026-10-15T09:34:24.152Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pVJinEuUkH7Kj4of9ddNpg.png" /><figcaption>How Not to Lose a Tender Before You Even Submit Your Bid: 5 Practical Steps</figcaption></figure><p>One of the most frustrating tender scenarios happens before the proposal is even prepared. The team spends a week on the bid. Pre-sales specialists, architects, and lawyers all get involved. Then someone discovers that a mandatory certificate is missing, the contract terms are unacceptable, or the client actually needs a completely different type of solution.</p><p>In IT tenders, a weak proposal isn’t the only reason you can lose. You can have relevant experience, the right team, and a competitive price and still be eliminated because of formal non-compliance, a misunderstood scope of work, or underestimated contractual risks.</p><p>That’s why preparing a bid shouldn’t start with a presentation or a technical proposal. First, you need clarity on three things: whether it makes sense to participate at all, what exactly the client is buying, and whether the requirements can realistically be delivered on terms the company can accept.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*IiVDdQ2SZamot6rf31q-4g.png" /></figure><h3>1. First, decide whether the tender is worth pursuing</h3><p>In my experience, preparing an average IT bid can take 40 to 150 hours of combined work across pre-sales, technical, tender, legal, finance, compliance, and information security teams. That’s a meaningful investment of team time. Sometimes, walking away from the wrong opportunity early saves more resources than pushing all the way to submission at any cost.</p><p>Before making a go/no-go decision, I usually look at a few basics.</p><p><strong>How well do the tender requirements match the company’s actual expertise?</strong></p><p>If the client requires a certain number of similar projects in a specific industry, backed by mandatory client reference letters, a local office, an uncommon certification, or specialists with a niche tech stack — and the company cannot provide those things — even an excellent technical proposal will not help.</p><p><strong>Are the requirements too narrow or overly specific?</strong></p><p>Sometimes it’s already clear at this stage that the procurement is designed for a fairly narrow pool of suppliers. For example, the documents may specify a particular product without allowing an equivalent, set an extremely short submission or implementation deadline, or demand unusually specific experience. I once came across a tender that required combined experience in developing a mobile application for recording inventory data on elements of the natural environment and building an IT system based on real-time voice and natural language processing (NLP). Unsurprisingly, very few companies can demonstrate that exact combination of experience.</p><p><strong>What outcome is the client actually expecting?</strong></p><p>Is this custom development, an off-the-shelf solution, enhancement of an existing platform, integration, support, or a dedicated team? These are fundamentally different delivery models. If the client needs a mature product implemented within two months, while the company can only offer a full development cycle that will objectively take longer, participating in that tender is unlikely to make sense.</p><p>The draft contract also needs a separate review if it’s included in the tender package. This is where terms that are easy to postpone “until later” often sit: liability, acceptance procedures, staff replacement rules, payment terms, penalties, warranty obligations, and grounds for termination. After award, these are no longer formalities — they become real supplier risks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*LR2OCWaNhL33nxQdiTI77A.png" /></figure><p>Sometimes the best outcome of a tender analysis is realizing early that you should not bid. Walking away can save more resources than winning a project that was never a good fit in terms of requirements, timeline, or risk profile.</p><h3>2. Break down what the client actually needs</h3><p>Technical specifications in IT tenders vary widely. One client describes the architecture, technologies, and team roles in detail; another provides only the expected outcome. The problem starts when a supplier tries to fit the request into a familiar solution instead of first understanding what the client actually needs.</p><p>To avoid turning everything into one long list of requirements, I usually break the documents down into several logical blocks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*3dkY3hr-9acazH9Otjvicw.png" /></figure><h4>Mandatory and qualification requirements</h4><p>These are requirements where non-compliance can lead to bid rejection. They include certificates, verified company experience, requirements for specialists, implementation timelines, submission format, mandatory documents, licenses, and specific supplier statuses. If ISO 27001 is explicitly stated as a condition of participation, neither a strong architecture nor an attractive price will compensate for not having the certificate.</p><p>It’s much better to identify these points in the first few hours of analysis than after several days of work on the solution.</p><h4>Bid evaluation criteria</h4><p>This is no longer about eligibility; it is about what earns points and how the client compares bidders. You can prepare a strong proposal and still spend a lot of effort on advantages that barely affect the final score. If extra points are awarded for faster response to errors, it makes sense to check the shortest response time the company can genuinely commit to. Conversely, there is little value in proposing a specialist with 20 years of experience if the maximum score is already achieved at three years. More experience may look impressive, but on its own it will not earn additional points.</p><p>Before starting the proposal, it helps to understand not only what the company can offer, but also what the client will actually evaluate.</p><h4>Requirements for the scope and project outcome</h4><p>Here, you need to break the scope down into concrete deliverables: what exactly must the company develop, implement, supply, or support?</p><p>The scope might include, for example, a new web portal, a mobile application, enhancements to an existing system, ERP or CRM integration, data migration, license supply, cloud infrastructure setup, user training, technical support, and much more. In some tenders, the main deliverable is primarily IT expertise. For example, a client may need technical specifications for the development of an information system, followed by technical support during the tender process and the subsequent implementation of the project.</p><p>It is important to identify not only the list of features and activities, but also the outcome the client will ultimately consider a successful delivery of the project.</p><h4>Requirements for the delivery process</h4><p>Even a correctly understood scope doesn’t guarantee an accurate estimate. A project can become significantly more expensive because of process requirements: regular reporting, separate acceptance of project stages, on-site client training, mandatory documentation, or a prescribed communication format. If every stage has to be approved separately and accompanied by a report and demonstration, that effort also needs to be counted.</p><p>The estimate may look perfectly reasonable on paper. But once delivery starts, margins shrink, pressure on the team builds, and delays become more likely. It’s easy to focus on development itself while underestimating the time required for documentation, travel, working sessions, and formal acceptance.</p><h4>Contractual obligations</h4><p>There is another layer as well: contract terms that will directly affect the project economics after award. These include delivery deadlines, penalties, SLAs, warranty obligations, IP rights, rules for replacing specialists, security and confidentiality requirements, and payment and acceptance procedures.</p><p>In one tender, our legal team found a clause imposing a penalty of 5% of the total contract value for every day the start of services was delayed. At the same time, the client retained the right to claim damages exceeding the penalties already charged. Terms like these can’t be left until after the award — they need to be factored into the participation decision and the pricing from the outset.</p><p>There is another reason not to fill in the gaps for the client. After award, an ambiguous clause stops being just an unclear line in the tender documents and can become a real contractual obligation. If a requirement allows multiple interpretations, it is safer to clarify it before submitting the bid.</p><p>I once worked on a tender for support of an existing portal. At first glance, it looked simple: the portal was already live, and the contractor just had to support it. But the documents said almost nothing about the portal itself — its functionality and architecture, number of users, scope of integrations, workload, or support ticket statistics. Estimating the actual effort in that situation was practically impossible. “Support” could mean a few small requests per month, or it could mean a team working continuously on a business-critical system with complex integrations. Any price without that information would have been based on assumptions: either padded heavily, with the risk of losing on price, or overly optimistic, with the risk of ending up in a commercially unviable contract.</p><p>The fewer assumptions an estimate contains, the lower the risk of both underestimating the true scope of the project and overestimating the strength of your own bid.</p><h3>3. Choose the delivery approach around the client’s needs — not the other way around</h3><p>Once the requirements are clear, the next question is: which delivery approach actually fits this project?</p><p>There is no universal answer. The same need can be met through development from scratch, implementation of an off-the-shelf platform, integration of several solutions, a dedicated team, or comprehensive managed services. The choice should be driven not by what the supplier is most used to selling, but by the constraints of the specific tender.</p><p>If deadlines are very tight, an off-the-shelf platform or reusable components may make more sense than building from scratch. But speed comes at a price. Subscriptions, user licenses, add-on modules, and future scaling can make an initially attractive solution much more expensive over time.</p><p>For projects involving legacy systems, migration and integration experience is especially important. Supporting a business-critical system is different: SLAs, incident management, team availability, and experience with comparable infrastructure move to the forefront.</p><p>At that point, it makes sense to define the delivery model and commercial terms.</p><p>· What exactly is the client buying — a specific outcome, team capacity, or a service?</p><p>· Is the commercial model fixed-price, time and materials, a dedicated team, or a hybrid?</p><p>· Can prebuilt components be used?</p><p>· Are there requirements for infrastructure hosting, data storage and processing location, information security, or regulatory compliance?</p><p>· What matters most for the project: speed, cost, stability, ease of operation, or risk reduction?</p><p>· Which risks need to be identified and addressed already at the proposal stage?</p><p>A good delivery model isn’t the one the supplier uses most often; it’s the one that best fits the constraints, priorities, and procurement logic of that particular client. A technically more sophisticated solution isn’t necessarily a stronger tender proposal. If the client must launch the system within three months, a proposal to build the perfect custom platform in nine months loses before the architectures are even compared.</p><h3>4. Build a commercially sound proposal</h3><p>Even with a clear scope, the wrong estimation model can still undermine the commercial proposal.</p><p>In practice, I most often see three approaches.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*S9nVV2eEnPZHX7ryrUARRA.png" /></figure><h4>a. Estimating by project deliverables</h4><p>In the first case, the client is buying a specific deliverable: a module, system, integration, migration, documentation, training, support, or a separate project phase.</p><p>Here, it is not enough to count developer hours. The price also needs to cover analysis, architecture, project management, QA, DevOps, security, communication, the warranty period, potential changes, and other related costs.</p><h4>b. Estimating based on specialist rates</h4><p>In the second case, the client is buying hours, days, or months of work from specific specialists. Roles, seniority, availability, expected allocation, rates, replacement rules, and minimum engagement levels become particularly important.</p><h4>c. Hybrid approach</h4><p>In a hybrid model, part of the work has a fixed price and part is billed at specialist rates. For example, analysis, architecture, and key development stages can be estimated upfront, while support, change requests, and additional enhancements are billed based on actual time spent. This works well when one part of the project is clear enough to estimate reliably and another cannot be forecast with confidence before the work begins.</p><p>Two problems are especially common here. Sometimes the cost of a deliverable is calculated as a simple sum of working hours, while management, communication, and risk contingency are forgotten. The opposite also happens: every risk is built into the hourly rate, even though the client is primarily comparing bidders on that rate.</p><p>It is also worth looking separately at the solution’s Total Cost of Ownership (TCO). For an IT project, this is far more than development and licenses. The full picture may include infrastructure, cloud services, support, updates, information security, documentation, user training, ongoing maintenance, scaling, data migration, and handover of the system or processes to another supplier after the contract ends.</p><p>A price that’s too low may look attractive at submission stage but create serious problems later. I’ve seen bids rejected as abnormally low because the bidder couldn’t convincingly explain how the price had been calculated.</p><p>Overpricing carries its own risks. If price carries significant weight in the evaluation, even an excellent technical proposal may not compensate for a substantial gap between your bid and competitors’ bids.</p><p>That is why the team should agree in advance on exactly what is included in the price, which assumptions the estimate is based on, which costs have already been accounted for, and what remains outside the estimate. Not all of this necessarily needs to appear in the commercial proposal if the tender does not require that level of disclosure. But the team itself should share the same understanding of the estimate boundaries. That makes the calculation easier to justify, the scope easier to control, and follow-up questions from the client easier to answer consistently.</p><p>Ultimately, the price has to be not only competitive but also deliverable. Even a winning tender can turn into a poor outcome for the supplier if the project was priced from the start without sufficient margin or with significant costs left out.</p><h3>5. Read the submission instructions carefully</h3><p>The formal side of a tender is easy to underestimate because most attention naturally goes to the solution, experience, architecture, timeline, and price. But sometimes formal requirements determine whether the bid reaches the substantive evaluation at all.</p><p>You can propose a strong solution, demonstrate relevant references, and offer a competitive price — and still be disqualified because of a surprisingly simple mistake. A mandatory document wasn’t attached, a file was signed with the wrong type of electronic signature, the wrong template was used, a field was left blank, the bid was emailed instead of submitted through the procurement platform, or the submission was completed just a few minutes after the deadline. For the procurement team, these aren’t minor details; they are breaches of the procedure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/975/1*qzHOlYuucynfxl73cibJRw.png" /></figure><p>That’s why I would put the submission instructions on the same level as the technical specification and the draft contract when deciding what needs to be reviewed most carefully.</p><p>There’s also the opposite problem: the urge to attach everything that seems useful “just in case.” Extra presentations, architecture documents, numerous case studies, and technical explanations don’t replace mandatory materials. What’s more, every additional file creates another place where an inaccurate or contradictory statement can appear.</p><p>If the client doesn’t ask for a separate architecture description, it isn’t always worth adding one on your own initiative. Sometimes a single unfortunate sentence is enough to look, during the formal review, like a deviation from the technical specification — even though the supplier never intended it that way.</p><p>A high-quality bid is not the one with the most files. It contains everything the client requested, and the documents are consistent with one another without creating unnecessary questions.</p><p>The formal compliance check is the last barrier before evaluation. A strong proposal has to do more than persuade the client; it also has to pass this stage without errors.</p><h3>Conclusion</h3><p>A strong team, relevant experience, and a competitive price genuinely matter in IT tenders. But they are not enough if the requirements, scope, risks, and project economics are assessed only superficially before the proposal is prepared.</p><p>This is exactly where the most expensive problems tend to surface: an unclear scope of services, a harsh contract, experience that cannot be evidenced with documents, timelines that are too short, or support, licensing, travel, and integration costs that were missing from the initial estimate.</p><p>After an award, there is much less room to maneuver. The price is fixed, the documents have been submitted, and a significant part of the obligations has effectively already been accepted.</p><p>That’s why a strong tender bid doesn’t start with writing the proposal. It starts with deciding whether the proposal should be written at all.</p><p>The earlier you identify critical factors, clarify ambiguous terms, and calculate the full scope of obligations, the lower the risk of spending resources on a bid that was weak from the start — or, worse, winning an unprofitable project.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=295e6505ae60" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/how-not-to-lose-a-tender-before-you-even-submit-your-bid-5-practical-steps-295e6505ae60">How Not to Lose a Tender Before You Even Submit Your Bid: 5 Practical Steps</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Business Analysis in Undocumented Products: From Unknown to Understood]]></title>
            <link>https://medium.com/andersen-it-community/business-analysis-in-undocumented-products-from-unknown-to-understood-53c1f1034e81?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/53c1f1034e81</guid>
            <dc:creator><![CDATA[Olga Kletskina]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 13:18:48 GMT</pubDate>
            <atom:updated>2026-09-25T13:18:46.888Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4uzipF0nsHiot8Td6O8cfw.png" /><figcaption>Business Analysis in Undocumented Products: From Unknown to Understood</figcaption></figure><h4><strong>Introduction</strong></h4><p>Let’s imagine the following scenario: you join a new project as a Business analyst or Product owner. This app has already been released to market, has established users, and has proven its value. As a new team member, you’re expected to integrate into the process, support the product, and help to expand it.</p><p>And then you discover that the development team didn’t think much about documenting their decisions and the system’s mechanics. Therefore, it will be impossible to figure out what’s going on quickly.</p><p>So this is what I want to talk about today. I’ll present this scenario from a business analyst’s perspective, primarily for ease of reference. Essentially, if your work is related to setting and prioritizing tasks, describing requirements, and technical specifications, consider yourself included. Also, I won’t be referencing any specific project within this article, the scenario is based on a combination of features of different products I had a chance to work with.</p><h4><strong>New Product vs Existing Product</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aS6hEzZhXq0DF-Fo4tvyjg.jpeg" /><figcaption><em>Pexels.com</em></figcaption></figure><p>Let’s start with a simple analogy. Imagine you need to build a house. You’re doing everything from scratch, but you have a plan, a design, all the engineering solutions, and tools. You know what you want and how everything should work. Of course, not everything will go smoothly, but the main thing is that everything is more or less clear, and you’ll be the one deciding when the house is ready for habitation. This is roughly how we can imagine developing a new product.</p><p>On the other hand, you suddenly find yourself the head of the homeowners’ association in an old building with a bunch of tenants, ghosts, secret passages, and an uncertain past. And you have to not only ensure that the house doesn’t fall apart, but also add new outbuildings to it. Of course, I’m exaggerating, but sometimes working on a live product feels exactly like that. If we translate this analogy into the description, we have the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C5ZIVXH0EwVnD7L1dPDmNQ.png" /><figcaption>Difference between New and Existing Products</figcaption></figure><p>To summarize, when a business analyst works on a project being built from scratch, it’s often easier because they have all the key information and can make changes easily, although there’s a high risk of making poor decisions that could have repercussions down the road. Analysts who join a live product immediately gain access to a much larger volume of data and expertise, but they also have to quickly dive into a new context and established practices, not always understanding why things are the way they are. And this is where we come to the importance of documentation.</p><h4><strong>Why Lack of Documentation Is a Problem</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QP3wLkoyC2dqQJfh2gIVyQ.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>It’s true that it’s better to have a working application and a poor specification than vice versa. But the key word here is “working.” I have a few comments on <strong>why a lack of proper documentation can block or slow down the operation of an application or a system</strong>:</p><ul><li><strong>It’s difficult to transfer knowledge to new colleagues and maintain expertise during staff turnover.</strong></li></ul><p>People leave, and product knowledge goes with them. People come and need to receive information so they can perform their duties. If all product expertise is stored only in the heads of team members and in scattered notes, maintaining knowledge is essentially impossible.</p><ul><li><strong>It’s difficult to introduce new users to the product.</strong></li></ul><p>New users need to be explained why the product is good, what it does, and how. Without detailed product documentation writing user guides, providing information to support, and developing marketing materials becomes quite difficult.</p><ul><li><strong>It’s difficult to fix a system or not to break it.</strong></li></ul><p>When you don’t fully understand how a product works and what non-obvious features it has, it’s difficult to quickly identify the source of a problem or avoid accidentally disrupting another process that might be related to your current point of interest.</p><ul><li><strong>It’s difficult to trace the logic behind product decision-making</strong>.</li></ul><p>If we don’t know why a feature was implemented a certain way, we might misrepresent it, try to redesign it without understanding the nuances of business processes, or simply raise the same issues over and over in discussions simply because there’s no documentation of why the app works the way it does.</p><p>So, of course, documentation is important and necessary. It helps maintain your app and make informed decisions about future product development.</p><h4><strong>Where to Get Information?</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_ULZSqOhRlTbE--Tw11r5g.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>So, we’ve realized that the project we’ve joined isn’t very well-documented. We need to gather requirements, describe tasks, and do other analytical work. Where to get information?</p><p>Let’s go through the <strong>most basic sources.</strong></p><p><strong>First, of course, is the product itself.</strong> Since it already exists, you can use it and empirically identify its behavior and document its nuances. It is also helpful to develop your domain expertise and examine competing applications in parallel with using your application. And, of course, record your observations: draw diagrams, or create an application map or customer journey map to quickly find your way around and see the connections between entities and the data stored there.</p><p><strong>The user guide</strong> provides information about how the app is supposed to be used, what features it has, workarounds, and so on. Here, it’s important to pay attention to how closely the guide materials correspond to the actual state of the app. If the project’s documentation is poor, it’s easy to imagine that the user guide might not be updated regularly.</p><p>By reviewing <strong>promotional materials</strong>, we can gain some understanding of the product’s value to the user, its use cases, and prioritize features based on their importance to the end consumer. On the other hand, we can better understand who our users are, what their needs and wishes are. Furthermore, the website usually contains information about usage forms, subscription options, and so on — the ways to monetize the app. From a documentation perspective, this is where you can gather information about user personas, create a rough matrix of roles and access rights, and document the product’s key value proposition for customers.</p><p>Another key source of information is, of course,<strong> the task backlog</strong>. Here we have three dimensions:</p><ol><li>Current tasks — that is, issues and improvements the team is currently working on or will work on in the near future. This is our first priority, as it may require the analyst’s attention urgently.</li><li>Completed tasks — that is closed epics, stories, changes, and so on. If the team doesn’t maintain a knowledge base, then information about how the system should work, its structure, and development history can often only be obtained from there.</li><li>Future tasks — that is, those that won’t be needed immediately or for the next sprint, but rather in a month, a quarter, or a year. Here, we can determine what requests are coming from stakeholders, their priority, and generally where the product is planned to move next.</li></ol><p>It’s also important to constantly communicate with <strong>product experts and team members</strong> who are familiar with specific aspects of the product. You can check in with colleagues on your understanding of the project, clarify the feasibility of implementing the functionality you’re describing, and even simply request document reviews. The key is to document the results of your communications so you don’t ask the same questions over and over again.</p><p>You can also learn a lot by communicating with<strong> support and sales teams</strong>. Support can share user pain points, questions, and issues, helping you prioritize system improvements and gather feedback from your product’s end users. As for the sales team, as specialists who constantly interact with potential clients, they are well-versed in the product’s most profitable and, conversely, least profitable features. They can also contribute ideas for further development, as they constantly process feedback from interested audiences.</p><p>And, of course,<strong> the users</strong>. Working on a live product, you have the opportunity to interact in one way or another with real people and organizations that use your system. Once you’re able to organize or directly access feedback channels, which will help you test hypotheses, adjust priorities, and obtain data regarding the additions you’ve made to the product.</p><p>I’ve outlined the sources that are present in one form or another in any product. Of course, you could add other categories here, but I think these are definitely worth adding to your list. The main thing is to embrace any knowledge sources you can access.</p><p><strong>What to Do With New Information?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y1vEFPjq0myjHqMIczJGxQ.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>As a new analyst in the team, we’re starting to quickly gather knowledge about our new product. And we absolutely need to do three things with it:</p><p><strong>record, maintain, and share.</strong></p><p><strong>Recording</strong> seems clear: if we don’t capture and formalize our findings, the project situation won’t change at all. Yes, our work will become easier over time because we’ll simply know many details from constant use, but if we want to keep this knowledge consistent and complete, then of course we need to record it.</p><p>Next, remember that outdated documentation isn’t much more useful than missing documentation, and can sometimes even make it worse by being misleading. Therefore, it’s important to manage your knowledge base in a way that makes it <strong>easy to update and maintain</strong>. Try to organize knowledge into logical blocks and link documents to one another so that you and anyone else who needs it can easily find the information they need, supplement it, and adjust it if necessary.</p><p>Finally, even if you maintain the most comprehensive documentation in the world, it’s useless if your team doesn’t use it and continues to work in the old-fashioned way. Therefore, try to regularly link your documents to tasks, show colleagues where everything is, and solicit their feedback on your articles. Over time<strong> the entire team will start to actively use it</strong>, making it easier to synchronize, make changes, and communicate information to new team members and other stakeholders.</p><p>Documentation is only useful when used for product development; otherwise, it can simply become a source of bureaucracy, a waste of time, and even a source of conflict within the team. So let’s always maintain a practice-oriented approach for our knowledge base.</p><p><strong>A Mantra for an Analyst</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4sBAS2TnVnoi4WCiK_G8iA.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>Now I want to talk about one important thing that I think haunts every analyst:<strong> the fear of missing something important.</strong> Analysts are often the first people turn to for questions and clarifications. And of course, we always want to quickly provide the right answer, describe the problem perfectly, and take into account every detail. And if that doesn’t work, our worst enemies — the perfectionist and impostor syndrome — come and start to put pressure on us. I won’t discuss the psychology of work here, but I want us to embrace one simple thought:</p><p><strong>there’s always something you don’t know!</strong></p><p><strong>So step number one is to not be afraid to admit mistakes. </strong>Errors and inaccuracies are an everyday part of the process. Therefore, admitting a mistake and correcting it is normal and in no way diminishes your authority as a specialist. On the contrary, it shows that you’re open to learning, dialogue, and working for the benefit of the product.</p><p>And <strong>step number two is to establish a process for introducing changes</strong>. If you learn something new, you need to correct the documentation, create an additional task, or make changes to the design. This always requires time and resources, so make sure you and your team have it.</p><p>There’s always a risk that the analyst didn’t know something. And it’s not scary; it happens all the time and to everyone. The key is to not be afraid to discuss your issues with the team and be prepared to add new information to and correct mistakes.</p><p><strong>Risks of a Product Without Documentation</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9AXRYBc1ufyFNFcH2qs7JQ.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>In a live product, no one will wait for you to figure things out. Your app is running every day, users expect support and updates, the sales team expects new big features that will attract new customers, and management expects a steady flow of revenue. So, you’ll likely be learning your product simultaneously while writing new tasks and supporting the team during development. And there are few things to keep in mind.</p><p><strong>Risk # 1: Changes in requirements, priorities, and decisions will occur constantly.</strong></p><p>A developer during a refining session will accidentally drop a comment that forces you to completely rewrite everything; a stakeholder will contact you with comments on a feature you didn’t even know existed; a random diagram from five years ago will suddenly appear, completely changing your understanding of the interactions between objects in the system. And these are just some of the problems you’ll encounter while describing a product without having all the context for it.Your tasks will be reworked again and again because you’ll be acquiring new information as you go.What can we do about this?</p><ul><li>Establish communication. First and foremost, with the team, and, of course, with key stakeholders. Get to know them, and acclimate them to your presence and role.</li><li>Allocate time for the rough work. We know for sure that we’ll spend extra time finding all the data and making several more edits. So, while you’re getting the hang of it, increase your task estimates by 2–3 times to allow time for research, communication, and edits.</li><li>Layer your changes in documents gradually. Write down the obvious things first, then add details as new information becomes available, so there’s less rework.</li><li>Maintain traceability of requirements. Have an application diagram, key process diagrams, and entity descriptions handy to track the impact of a new task on other parts of the application.</li><li>Discuss the change process with the team. It’s important for the entire development team to understand that changes to requirements and implementation are practically inevitable, so they need to agree on how to quickly make changes without disrupting the process — who to notify, how to prioritize, and who makes decisions.</li><li>And finally, create a buffer for changes. It’s not just the analyst who needs additional time to complete tasks in the face of uncertainty. If a project lacks comprehensive documentation and shared knowledge, developers often need additional time to study the problem and develop an optimal solution. And of course, they need time to fix bugs and make changes.</li></ul><p><strong>Risk # 2: Decline in team metrics.</strong></p><p>Typically, when a team changes composition, extensive product research and documentation begins — transformations occur in the development process, and the usual way of doing things changes. Work moves more slowly than everyone is used to, and a lot of time is spent on approvals and discussions. And the management, seeing a drop in delivery, and the plans set before development may not be fully achieved. Any changes entail a drop in delivery speed, and you can only accept it and manage consequences:</p><ul><li>Immediately notify responsible people on potential deadline shifts so that plans can be adjusted to account for these factors.</li><li>Break down the tasks in the backlog as much as possible. This will reduce the risk of errors and changes in a specific task and allow you to be more flexible in prioritizing and managing the team’s workload.</li></ul><p><strong>Risk # 3: Changes made in a live product without a full understanding of the situation can lead to negative feedback from users.</strong></p><p>Sometimes, when we plan new features, some of the business logic can be not taken into account, or dependencies no one knows about creep in, or some important case is missed during testing. As a result, you have to rush changes, deal with unexpected issues, or even roll back to the previous version.This can certainly work, but there’s a high risk of causing even more problems at this fast pace. So, when identifying user issues after a new release, the best thing to do is:</p><ul><li>Calm down.</li><li>Assess the criticality of the problem and possible solutions.</li><li>Coordinate with the decision-maker, and make the appropriate changes with a cool head, making sure to link the new tasks to the old ones to maintain context.</li></ul><p>It’s important to strike a balance between reaction speed and meaningful actions, and this won’t happen overnight. The key is to remember the consequences of actions and changes and be able to document the decisions made so you can track them later.</p><p><strong>To summarize,</strong> when it comes to managing risks in a product you don’t yet understand very well, the key points can be summarized as follows:</p><ul><li>Allow a good buffer of time to understand the issue, agree on all the nuances, and potentially make changes mid-stream.</li><li>Cultivate the ability to calmly respond to problems and make the right decisions. If changes or improvements are necessary, they must be implemented to ultimately benefit the product and its users.</li><li>Learn from your mistakes. And don’t just draw your own conclusions, but educate your team through documentation. If you’ve documented all the changes you’ve made, identified risks and dependencies, your product awareness will increase, and many risks will be mitigated.</li></ul><p><strong>Where do we want to go as BAs?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g95BOZfEwcWbCz76dsIrBw.jpeg" /><figcaption>Pexels.com</figcaption></figure><p>So, we’ve covered the key issues in today’s scenario, discussed the problem of a lack of documentation, the specifics of working on a live product, sources of information, and risks inherent in a situation of poor product familiarity. Now let’s summarize, but not so much with conclusions, but with<strong> the goals we as analysts should set for ourselves</strong> when working on such a product.</p><ul><li><strong>Agility as the foundation of the process</strong>.</li></ul><p>A lack of documentation and poor product knowledge require action under conditions of uncertainty, so business analysts must structure their work so they can respond quickly to new information, promptly update documentation, and reprioritize tasks. We discussed possible ways to achieve this, but the key here is the ability to be flexible, and how exactly you achieve it is up to you.</p><ul><li><strong>Up-to-date and sufficient documentation is publicly available</strong>.</li></ul><p>We need to not only create a bunch of different articles in the knowledge base, but also describe the things the team needs first, and then add beauty later. We also need to structure our documentation and requirements management so that they are easily maintained and accessible to all stakeholders.</p><ul><li><strong>Standardized onboarding.</strong></li></ul><p>When preparing documentation, it’s a good practice to set up navigation and home pages so that your knowledge base is easy to use even for a newcomer, and the onboarding process for new team members becomes easier and more efficient. The entire team will benefit.</p><ul><li><strong>Established communication between the team and stakeholders.</strong></li></ul><p>A lack of documentation often leads to constant disconnects between different participants. Our goal is to create a common point of interest, increase transparency in the development process through roadmaps and other reporting artifacts, and give stakeholders a clear view of where their requests are and how they are being implemented.</p><ul><li><strong>A streamlined user feedback process.</strong></li></ul><p>A live product has real consumers, and not leveraging this advantage is simply wasteful. So, create a ritual with your support team for collecting requests and feedback, implement analytics, and regularly solicit feedback from the sales team on potential customers’ reactions to the product. This way, your task prioritization and user experience will remain grounded and will be much more likely to meet user needs, and the product will develop successfully with your help.</p><p>These goals are quite ambitious and hard to reach to one person only, but you can become a driver of change that will help your team to organize their development process and make it more stable, predictable and easy to join.</p><h4>📲 Follow us on social media to stay updated on upcoming events:</h4><p><a href="https://www.instagram.com/andersencompany/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=inst"><strong>Instagram</strong><br></a><a href="https://t.me/andersencompany?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=tg"><strong>Telegram</strong><br></a><a href="https://www.facebook.com/Andersensoft?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=fb"><strong>Facebook</strong></a></p><p><a href="https://people.andersenlab.com/vacancies?utm_source=medium&amp;utm_medium=article"><strong>💻Our open vacancies<br></strong></a><strong>📅</strong><a href="https://people.andersenlab.com/meetups-with-andersen-recaps?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=meetup"><strong>Upcoming meetups</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53c1f1034e81" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/business-analysis-in-undocumented-products-from-unknown-to-understood-53c1f1034e81">Business Analysis in Undocumented Products: From Unknown to Understood</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The First Workday and a Career that Grows “in Breadth and Height” (Part 3)]]></title>
            <link>https://medium.com/andersen-it-community/the-first-workday-and-a-career-that-grows-in-breadth-and-height-part-3-32d74d0d51cf?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/32d74d0d51cf</guid>
            <category><![CDATA[trainee]]></category>
            <category><![CDATA[intern]]></category>
            <dc:creator><![CDATA[Vitali Birchanka]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 14:40:53 GMT</pubDate>
            <atom:updated>2026-08-28T14:40:51.672Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0_DMbNonbw4FcFyfr7wAfw.png" /></figure><h4><strong>The first workday: what to expect?</strong></h4><p>The newcomer will be shown the office, explained how the company’s work is organized, introduced to the team. The project manager or the predecessor will show the new business analyst the ropes, documentation, and the analysis methodology.</p><p>The tools you will work with depend on the project. Atlassian Jira is usually used to track time and tasks, Atlassian Confluence is for the project’s wiki, Figma is for working with designs, Balsamiq/Axure is for prototyping, <a href="http://diagrams.net/">diagrams.net</a> and Lucidchart for modeling, etc. Sometimes you have to pick up the company’s internal courses to master the necessary tools.</p><p>The main thing is: don’t be afraid of anything, learn as you go. Remember that nobody will slow down the project or adapt to you, so, by default, filling in the gaps in knowledge and experience is expected to be your aspiration. On the other hand, everyone was once new in the profession and remembers their first day, so you’ll be understood and definitely receive help.</p><h4><strong>What are the prospects?</strong></h4><p>The career prospects for a business analyst are, as the saying is, both in breadth and height. Along with the vertical growth (Junior–Middle–Senior–Lead), transitioning to related specializations and areas is possible. For example, to system analysis (work with integrations, databases, systems modeling), to the position of product manager (responsible for product promotion and development), architect, and even business owner (product development in terms of contents, priorities, implementation peculiarities).</p><p>Of course, much depends on the difficulty of entering the profession. You can spend several years working on a single project with monotonous tasks, or you can try out all main activities — and even related specialties — in a year or two. It usually takes about two years to reach the middle level, and at least another two or three years to reach the senior level. But to become a leader, an architect, or a business owner, it’s not so much time that’s important but your credibility and ambition.</p><h4><strong>Your first job offer: tested on myself</strong></h4><ul><li>Your primary certificate is the certificate for the successful completion of the BA course and traineeship. But a confirmation of any other competencies, including knowledge of languages, is also nice to have;</li><li>Don’t be too picky about your first place of employment. Having experience will make you more valuable in the market;</li><li>Take composing your CV seriously. You are expected to provide a brief description of your skills, work experience, and participation in projects (to get an understanding of your domain knowledge). It’s unlikely that anyone will read 3–5 pages of text; ideally, it all should fit in one page. Write briefly and to the point. A certificate for winning a children’s math competition at a summer camp is certainly very important to your parents but not to your employer;</li><li>Make sure to adapt your CV to the vacancy. If you’re applying for a job at a company that is engaged in FinTech somehow, highlight your experience with financial products. If you have a logistics background, highlight everything related to auditing, transactions, financial reporting, etc. That is, you can use the same cases but present them in a way that will be interesting to your potential employer;</li><li>During the interview, respond to the situation depending on the interviewer’s requests. For example, your CV doesn’t say that at your previous place of work, you were involved in training staff using various learning management systems. But during the interview, it became clear that the company is developing an internal training platform. In this case, it’s worth mentioning that you’ve worked with similar products, and this will definitely be noted in the feedback;</li><li>Interview questions depend on the vacancy level. Nominal Juniors are asked about their experience and have their theoretical knowledge (types of requirements, the difference between a US and a UC, what change request is, names and purposes of basic tools, and so on) tested. Middles/Seniors may be asked to create an SQL query, write a US or a UC, create diagrams or prototypes, use certain tools (SWOT or RACI matrices). Various project situations are often simulated, with no strictly correct answers. This is a test to see if the candidate matches the stated experience, so be ready for that;</li><li>Apply for all possible vacancies. Don’t give up even if you get rejected many times. And don’t inflate your experience in your CV, as your lie will become obvious during an interview (if any).</li></ul><p><strong>How to apply?</strong><br>Join Andersen traineeship program by submitting your application via the<a href="https://people.andersenlab.com/trainee?utm_source=medium&amp;utm_medium=web&amp;utm_campaign=trainee"> link</a>.</p><p>You can find more details about our free online education on this<a href="https://people.andersenlab.com/trainee/courses?utm_source=medium&amp;utm_medium=web&amp;utm_campaign=traineeln"> page</a>.<br>Follow Andersen on<a href="https://t.me/+eGpcREbFAD5jZGYy"> Telegram.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=32d74d0d51cf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/the-first-workday-and-a-career-that-grows-in-breadth-and-height-part-3-32d74d0d51cf">The First Workday and a Career that Grows “in Breadth and Height” (Part 3)</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Does Not Remove Waste. It Moves It]]></title>
            <link>https://medium.com/andersen-it-community/ai-does-not-remove-waste-it-moves-it-6084baaebced?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/6084baaebced</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Drew Elen Maxwell]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 12:59:45 GMT</pubDate>
            <atom:updated>2026-06-19T12:59:43.804Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6qOtXwm3WK_Ho6T6mSE1RQ.png" /><figcaption>AI Does Not Remove Waste. It Moves It</figcaption></figure><p>Many managers look at AI-assisted software development through a very simple equation:</p><blockquote><em>Developers write code.<br>AI writes code faster.<br>Therefore, we need fewer developers.</em></blockquote><p>It is a tempting equation. It is also dangerously incomplete.</p><p>The problem is that software development is not the production of code. It is the production of accepted system behavior. A function is not “done” when code exists. It is done when the team understands what it should do, when the implementation fits the system, when the edge cases are handled, when tests prove the right things, when security concerns are addressed, and when someone with enough context is ready to accept responsibility for it.</p><p>AI makes code cheaper. It does not automatically make accepted software cheaper.</p><p>And there is another distinction that is often missed:</p><blockquote><em>AI may reduce ETA without reducing LoE.</em></blockquote><p>ETA is the estimated time of arrival.<br>LoE is how much real effort, attention, fuel, and wear it takes to make it ready.</p><p>These are not the same thing.</p><p>AI-assisted development can be like driving at high RPM. You arrive faster but burn more fuel, produce more heat, and reduce your margin for error.</p><p>This is not necessarily bad.</p><p>Sometimes, high RPM is exactly what you need. You have a hard deadline, a demo, a production incident, a migration window, a proposal, or a prototype due by tomorrow. In those cases, AI is extremely valuable because it compresses time. It gives you acceleration.</p><p>But acceleration is not the same as sustainable speed.</p><p>If the organization treats high-RPM development as the new normal, it may not be reducing effort. It may be increasing cognitive load, review pressure, rework, and long-term maintenance risk.</p><p>This distinction becomes especially important when we look at senior developers.</p><p>A senior developer working with AI is not simply a senior developer with a faster keyboard. The work changes shape. The senior developer becomes the person who frames the problem, narrows the solution space, prompts the AI, reads the output, removes unnecessary complexity, checks architectural fit, validates behavior, and accepts or rejects the result.</p><p>That means AI-assisted development introduces a new type of workflow. And if we look at it through the lens of Lean Software Development, we can see several additional wastes that are easy to miss.</p><h3>1. Task Switching</h3><p>Code review is not ordinary work time. It is concentrated attention.</p><p>When a senior developer works with AI, they constantly switch between different cognitive modes:</p><ul><li>understanding the problem;</li><li>translating intent into a prompt;</li><li>reading generated code;</li><li>comparing it with the actual system;</li><li>detecting subtle mistakes;</li><li>correcting the output;</li><li>integrating the result;</li><li>checking tests and behavior;</li><li>deciding whether the work is acceptable.</li></ul><p>This is not one continuous flow. It is a loop of micro-interruptions.</p><p>The dangerous part is that this load is not linear. A developer may be able to do a high-quality review for 8 hours a week. Another may handle 15 or 20. But almost nobody can do a deep review for 40 hours a week. Review capacity is not the same as working hours. Review capacity is attention bandwidth.</p><p>AI can increase the amount of code waiting for review, but it does not increase the human nervous system’s ability to review it.</p><p>At some point, the bottleneck moves from writing code to sustaining judgment under cognitive load.</p><p>This is where ETA and LoE start to diverge.</p><p>The work may appear to move faster because the code appears earlier. But the effort has not disappeared. It has moved into reading, checking, correcting, simplifying, validating, and deciding.</p><h3>2. Handoffs</h3><p>Before AI, a senior developer could hold the intent, context, constraints, and implementation in one mind.</p><p>With AI, the work becomes a loop of handoffs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kvXImf25CpxHgW62nNV4ZA.png" /><figcaption>Handoffs</figcaption></figure><p>This is not the same as working with another developer.</p><p>A human teammate gradually builds shared context. They learn about the project, domain, style, hidden constraints, and the reviewer&#39;s expectations. They also take responsibility for their work.</p><p>An AI assistant does not become a stable actor in the team in the same way. It does not own the consequences. It does not participate in production support. It does not remember the full social and technical context of the system unless that context is explicitly provided.</p><p>Prompting is context serialization. Review is context deserialization.</p><p>Both are work, <em>and</em> both have cost.</p><p>Both can become waste if the generated output does not reduce the total cost of delivering the accepted system function.</p><h3>3. Over-Processing</h3><p>AI often produces more than needed.</p><p>It can generate extra abstractions, defensive layers, helper functions, excessive tests, generic documentation, and “enterprise-ready” structures for problems that need a simple local solution.</p><p>This creates over-processing.</p><p>The senior developer is no longer just reviewing correctness. They are also deleting water.</p><p>The cost of AI-generated code is not only its production cost. It is also the cost of reading it, understanding it, rejecting parts of it, simplifying it, and making sure it does not introduce unnecessary complexity.</p><p>This is where the idea of “cost per line of code” becomes almost useless.</p><p>A better economic unit is:</p><blockquote>cost per accepted system function</blockquote><p>That cost includes problem understanding, solution framing, AI generation, review, cleanup, rework, testing, integration, and the risk of future maintenance.</p><p>If AI reduces generation time but increases review and rework, the total cost may not improve. It may simply move to a different part of the value stream.</p><p>In other words, the vehicle arrived earlier, but it may have burned more fuel to get there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/884/1*gy_muvTODa9lFda_adm2yA.png" /><figcaption>Over-Processing</figcaption></figure><h3>4. Unused Talent</h3><p>There is another hidden waste: unused talent.</p><p>A strong senior developer is not valuable because they can inspect endless streams of generated code. They are valuable because they can create technical direction.</p><p>They can simplify systems. They can choose architectural trade-offs. They can detect bad requirements. They can mentor others. They can protect the system from accidental complexity. They can see which solution should exist in the first place.</p><p>If AI adoption turns senior developers into full-time inspectors of AI output, the organization may lose much of their real value.</p><p>This is a serious management risk.</p><p>The goal should not be to make senior developers review more. The goal should be to preserve their ability to make high-quality technical decisions.</p><p>AI can help with implementation. But if the team spends most of its senior capacity filtering generated code, it may be optimizing the wrong part of the system.</p><p>A senior engineer should not become a sanitation worker for synthetic code.</p><h3>5. Defects</h3><p>AI is often described as a “pair programmer.” That metaphor is useful, but also misleading.</p><p>A pair programmer is an actor. They share context. They ask questions. They build memory. They challenge assumptions. They can be held accountable. They can later explain why something was done.</p><p>AI does not fully play that role.</p><p>This creates a defect risk.</p><p>If one senior developer asks AI to generate code, reviews it, accepts it, and merges it, the final responsibility is still concentrated in one human. The AI did not independently review the work. It did not create a second accountable perspective.</p><p>In practice, the senior developer can become a single point of failure.</p><p>This matters because AI-generated code can look clean while still being wrong. The problem is not always ugly code. The problem is plausible code with hidden defects: wrong domain assumptions, weak error handling, security gaps, inconsistent data models, missing edge cases, or tests that prove the wrong behavior.</p><p>AI increases the volume of plausible output.</p><p>That makes independent validation more important, not less.</p><h3>The Management Mistake</h3><p>The naive management model says:</p><blockquote><em>AI increases productivity by X%.<br>Therefore, we can reduce headcount by X%.</em></blockquote><p>But AI does not affect all types of work equally.</p><p>It has the strongest impact on execution-heavy work: boilerplate, simple CRUD, repetitive transformations, local refactoring, first drafts of tests, and routine implementation patterns.</p><p>It has a weaker impact on judgment-heavy work: system design, problem framing, architectural trade-offs, acceptance criteria, code review, risk management, and accountability.</p><p>That means AI does not simply reduce the need for developers. It changes which developers are critical.</p><p>In some teams, AI may reduce the need for junior-level execution capacity. But it may increase dependency on senior-level judgment. The dangerous scenario is cutting people linearly across the organization while accidentally overloading the key developers who actually hold the system together.</p><p>You do not make a software team leaner by removing hands and overloading the nervous system.</p><p>You also do not make a car more efficient by forcing it to run at high RPM all the time.</p><h3>What Should Be Measured Instead</h3><p>AI adoption should not be measured by the volume of generated code.</p><p>It should be measured by the economics of accepted change:</p><ul><li>cost per accepted system function;</li><li>ETA reduction versus LoE reduction;</li><li>review time per shipped change;</li><li>rework rate after AI-assisted implementation;</li><li>defect rate after AI-assisted changes;</li><li>senior attention consumed per feature;</li><li>amount of generated code deleted before merge;</li><li>preservation of key developer creative capacity.</li></ul><p>The important question is not:</p><p><em>How much code did AI generate?</em></p><p>The important question is:</p><p><em>How much human judgment was required to make that code acceptable?</em></p><p>And one more:</p><p><em>Did AI reduce total effort, or did it only compress the calendar?</em></p><p>This is where Lean thinking becomes useful.</p><p>AI may reduce waste in one part of the process: manual code production. But it can create waste elsewhere: task switching, handoffs, over-processing, unused talent, and defects.</p><p>A local optimization can become a system-level loss.</p><h3>Conclusion</h3><p>AI-assisted development is not automatically lean development.</p><p>AI can make code generation cheaper, faster, and easier. But software delivery is not limited by code generation alone. It is limited by understanding, validation, integration, accountability, and human attention.</p><p>The future software team may be smaller. It may be more AI-assisted. It may have fewer people doing mechanical implementation. But it will still need key developers who can narrow the solution space, define acceptance criteria, conduct in-depth reviews, and decide what should be in the system.</p><p>AI does not remove the human bottleneck. It moves the bottleneck from typing code to sustaining judgment. And judgment is not infinitely scalable.</p><p>AI is excellent for acceleration. But acceleration is not the same as sustainability. Sometimes, high RPM is exactly what the situation requires.</p><p>Just do not confuse arriving faster with burning less fuel.</p><h4>📲 Follow us on social media to stay updated on upcoming events:</h4><p><a href="https://www.instagram.com/andersencompany/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=inst"><strong>Instagram</strong><br></a><a href="https://t.me/andersencompany?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=tg"><strong>Telegram</strong><br></a><a href="https://www.facebook.com/Andersensoft?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=fb"><strong>Facebook</strong></a></p><p><a href="https://people.andersenlab.com/vacancies?utm_source=medium&amp;utm_medium=article"><strong>💻Our open vacancies<br></strong></a><strong>📅</strong><a href="https://people.andersenlab.com/meetups-with-andersen-recaps?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=meetup"><strong>Upcoming meetups</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6084baaebced" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/ai-does-not-remove-waste-it-moves-it-6084baaebced">AI Does Not Remove Waste. It Moves It</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When more AI enters analysis work]]></title>
            <link>https://medium.com/andersen-it-community/when-more-ai-enters-analysis-work-7630be67ee81?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/7630be67ee81</guid>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Alexander Malyarenko]]></dc:creator>
            <pubDate>Tue, 26 May 2026 07:34:44 GMT</pubDate>
            <atom:updated>2026-05-27T13:32:30.110Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PM5HwR6-tf4JDwEM53R6DA.png" /></figure><p><strong>When more AI enters analysis work, biases don’t disappear — they scale. This article explores how that happens and what business and system analysts can do to keep judgment in their own hands, not in the model’s.</strong></p><p><strong>When more data means worse decisions</strong></p><p>Over the past few years analysts have gained some really helpful tools: dashboards that show live data, AI helpers that sum up meetings and language models that turn fuzzy ideas into neat documents. This should mean that analysts face fewer surprises and make better decisions.</p><p>Many teams are actually seeing the opposite happen. Projects are still late, goals are still not right and big risks still pop up unexpectedly. There is data and AI-made stuff but the quality of decisions isn’t getting better. It might even be getting worse.</p><p>The main problem is simple: having more information doesn’t automatically mean making decisions. Often it just means making decisions faster and with more confidence. AI didn’t fix our thinking mistakes. It just made them sound more professional look nicer and spread faster.</p><p>This is especially risky for analysts. Business analysts, system analysts, data analysts, product owners and UX researchers often work at the start of a project. They deal with data disagreeing stakeholders and changing goals. That’s where thinking mistakes and biases thrive.</p><p><strong>Why analysts are structurally vulnerable</strong></p><p>The work of an analyst is about dealing with things that are not certain. When a project is just starting out the requirements are not clear. The constraints are not well defined. The people involved often do not agree on what the main problems are. Estimates have to be made before everything is fully understood. Meetings to verify things can be influenced by things like office politics, time limits and who speaks up first.</p><p>In a situation like this people do what they normally do when things are not clear: they look for ways to do things. They use experiences, familiar patterns and stories that seem plausible to fill in the gaps. This is normal. It is how people get things done when they are under pressure.</p><p>The strange thing is that the experience an analyst gets the less they notice when they are taking these easier ways. As they get more experienced they get what is called “pattern speed”. This means they feel like they have seen something before. They know how it will turn out. They start to think and make decisions without really questioning them. Most of the time this works out okay. Sometimes it can lead to very expensive mistakes.</p><p>The people and things, around the analyst do not always help with this. Deadlines are often too tight which means there is not time to question assumptions. If someone important says something people often stop questioning it. In meetings the person who speaks the loudest or is most confident can control the conversation. And then there is the “ trap”: people think that just because a document or report looks nice it must be true.</p><p>When artificial intelligence is added to this situation it does not get rid of these biases. It actually makes them a part of the documents and reports which can make them seem more convincing and polished.</p><p><strong>Six bias traps that AI amplifies</strong></p><p>Biases have always existed in interviews, estimations, metric selection, and retrospectives. What changes with AI is speed, scale, and appearance. Below are six common traps, each paired with a practical example of how AI makes them worse.</p><p><strong>1. Confirmation bias: AI gives you exactly what you wanted</strong></p><p>Confirmation bias is the tendency to search for, interpret, and recall information in a way that confirms existing beliefs. In the AI era, it often starts right in the prompt.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cfGnunJ7cNvfnrZ0Lj3RIg.png" /></figure><p>Imagine a discovery phase where the team is already convinced that the low conversion comes from a “bad registration UX”. The analyst writes: “Generate user stories to improve the registration flow to increase conversion.” The AI responds with a clean backlog, structured acceptance criteria, and maybe even test cases.</p><p>Everything looks professional. The team commits to multiple sprints of UX improvements. Only later does someone notice that the real problem was a backend validation bug that blocked a fraction of users, regardless of the interface.</p><p>The root cause was never investigated because the question itself was biased. The AI produced exactly what the team expected, and that felt like confirmation, not a warning. When AI delivers output that perfectly matches the initial assumption, that is not an automatic win — it is a red flag that alternative hypotheses may have been ignored.</p><p><strong>2. Anchoring: the first number becomes the project</strong></p><p>The anchoring bias happens when we use the piece of information as a reference point for all our judgments that follow. In projects this first piece of information is usually an estimate that someone makes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lZ3rvaBBFgKnxnmFWc4lkQ.png" /></figure><p>Imagine you are on a kickoff call. Somebody says that a project will probably take two weeks to complete. At this point nobody has broken down the project into tasks or talked about any potential problems that might come up. Even though it is just a casual comment it becomes the anchor that we use to make all our other judgments. Then the analyst asks AI to break down the project into tasks that can be finished in two weeks. AI does what it is asked to do. Comes up with a plan that fits the original two-week time frame.</p><p>As time goes on the project plan, the promises we make and what the client expects all become centered around the idea that the project will take two weeks. If we later find out that the project is actually going to take longer, it looks like we made a mistake rather than that we just got a more accurate picture of what is really going on. The problem is not that we use computer programs to help us make estimates. The problem is that we treat the estimate we get whether it comes from a person or programs as the correct one without ever questioning it again.</p><p>A better way to do things is to think of our estimate as a temporary guide. We should go back. Look at it again after we have learned more about the project and we should say openly that we are revising our original estimate. We should write down why our first estimate was wrong of just keeping it and pretending it is still correct. This way the anchoring bias of the project timeline the project timeline becomes more realistic, over time.</p><p><strong>3. False causality: plausible stories, wrong reasons</strong></p><p>Humans love stories where one thing clearly causes another. AI is great at making up stories even when the facts only show a connection, not a cause.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xRodsT2YT-tRAbv-_R2xow.png" /></figure><p>Let’s say a new tool is launched and over the month people stick around 12% more. The charts look good. The analyst asks AI: “Tell me how this tool made people stay longer and suggest how to make it bigger.” AI writes a story about people being more engaged having less trouble and having better experiences.</p><p>The story sounds good. It’s not complete. A week later it turns out that a different marketing effort, not the tool was responsible, for most of the change. By that time the team has already invested a lot in the tool used up development time and made plans based on an idea.</p><p>AI did not intentionally “lie”; it simply came up with an explanation that fits the available numbers and the question asked. The risk appears when teams think that “AI gave a story that fits the facts” means “we have figured out the cause”. Figuring out an explanation and checking if its true are things. AI helps with the first; only testing and measuring can handle the second.</p><p><strong>4. Overconfidence: clean dashboards, blind spots</strong></p><p>People often feel too sure about things when the information they have does not really support that level of confidence. This can happen when we look at dashboards or summaries made by AI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pXMWlbu5gxUUeOc31r4xaw.png" /></figure><p>Imagine a system architect who is looking at a monitoring dashboard. Everything on the dashboard looks good. The architect asks an AI assistant to summarize the health of the system and the main risks. The assistant says: “The system is working well and we do not see any problems.”</p><p>This statement is correct based on the information on the dashboard. It does not show the limits of that information. A weeks later a big problem happens in a part of the system that the dashboard was not monitoring. So when people say “everything was fine” they really mean “we were not monitoring the things”.</p><p>The point is that we should be careful not to be too confident just because things look good. Our confidence should be based on how information we have not on how nice the dashboard looks. Even if the information is presented in a way it is still only a part of the whole picture. When AI summarizes information it leaves out details. So people who analyze information need to ask: “What is not included in this dashboard or dataset?” before they accept that everything is okay.</p><p>System architects and analysts need to remember that AI summaries are limited. They need to think about what the AI is not telling them. System health is not about what the dashboard shows. It is about what’s outside the dashboard or dataset. So the time you look at a dashboard ask yourself: “What is, outside this dashboard or dataset?” and do not just trust that everything is fine because the dashboard looks good.</p><p><strong>5. Survivorship bias: learning only from what did not fail</strong></p><p>Survivorship bias happens when we focus on successes and ignore failures that quietly disappeared. AI can help turn that into formal guidelines — and that is exactly the problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mfwAyek791kZMJQS7v2E7A.png" /></figure><p>Imagine a team running a retrospective after a particularly successful project. They collect lessons learned and feed notes to an AI tool: “Turn this into a guideline of best practices for similar projects.” The AI produces a smooth, structured document that soon becomes a reference standard for other teams.</p><p>The issue is that three similar projects in the past two years failed or under‑delivered, and their lessons were never documented. Those missing data points mean the guideline describes surviving exceptions, not the typical pattern. Risks that did not trigger in the successful case silently drop out of future risk assessments.</p><p>To counter this, analysts should intentionally ask: “What comparable initiatives failed, and why are they not represented here?” AI can help search across internal documents for negative cases, but someone has to want those cases in the story. Without that intent, the model will faithfully amplify one‑sided input.</p><p><strong>6. Framing effects: same numbers, different decisions</strong></p><p>Framing is about how information is presented. The numbers may be identical, but the wording changes the perceived severity and, therefore, the decision.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9RBV90uo710vKWd9G9Ee1Q.png" /></figure><p>Take a simple example. An analyst prepares two versions of a status note:</p><ul><li>“The system fails in 5% of transactions.”</li><li>“The system works correctly in 95% of transactions.”</li></ul><p>Both statements describe exactly the same reality. However, in a steering meeting, the first framing will likely trigger urgency and discussion of hotfixes. The second may lead stakeholders to postpone action and focus on other topics.</p><p>AI tools that summarize or rewrite content often default to more neutral or positive phrasing unless explicitly instructed otherwise. Over time, this biased framing can shift how issues are presented in decks, emails, and reports. Decisions end up being driven by wording rather than substance.</p><p>The practical step is to consciously reframe important metrics in at least two ways: “How does this look if we want to highlight the problem?” and “How does this look if we want to highlight stability?” Reviewing both angles often reveals whether the chosen formulation is distorting the decision.</p><p><strong>Turning AI into a bias detector</strong></p><p>The core idea so far sounds pessimistic: AI makes existing biases faster and more scalable. But the same properties can be used to surface those biases — if analysts deliberately change how they use the tools.</p><p>One powerful pattern is to switch from “confirmation mode” to “disconfirmation mode”. Instead of only asking AI to refine or expand the current solution, introduce prompts that actively attack it:</p><ul><li><em>“What could be wrong with this approach?”</em></li><li><em>“List the main arguments against this solution from a skeptical stakeholder.”</em></li><li><em>“What assumptions must be true for this design not to fail?”</em></li></ul><p>This type of questioning turns AI into a friction generator rather than a justification engine. It pushes hidden assumptions to the surface and gives language to objections that might otherwise appear too late.</p><p>Another useful pattern is the “alternative path mode”. Rather than requesting a single optimal flow or design, analysts can ask:</p><ul><li><em>“Propose a fundamentally different solution using a different architecture/business model.”</em></li><li><em>“Give me an alternative user journey that solves the same problem with opposite trade‑offs.”</em></li></ul><p>The aim is not to blindly generate more options but to deliberately break the lock‑in around the first idea. Having at least two serious contenders makes subsequent discussion more analytical and less emotional.</p><p>A third pattern focuses on gap coverage. Prompts like “What edge cases and non‑happy paths are missing from this flow?” or “Which non‑functional requirements are likely to be relevant but are not mentioned?” turn AI into a checklist engine that searches for common omissions.</p><p>All three modes — disconfirmation, alternatives, and gaps — use the same underlying model. Only the intent encoded in the question changes. The mindset shift is from “make my idea look good” to “show me where my idea is weak”.</p><p><strong>Safe and dangerous ways to use AI</strong></p><p>For everyday analyst tasks, the difference between “dangerous mode” and “safe mode” often comes down to how much responsibility the analyst delegates to the AI. Below are a few concrete examples:</p><ul><li><em>Requirements drafting</em></li></ul><p><em>Dangerous mode: treat AI‑generated requirements as final, copy‑paste into the backlog, and move on.</em></p><p><em>Safe mode: use AI for a first draft, then validate every requirement with subject‑matter experts, check for missing edge cases, and explicitly mark unverified items.</em></p><ul><li><em>Root cause analysis</em></li></ul><p><em>Dangerous mode: accept the first causal explanation the AI proposes and base decisions on it.</em></p><p><em>Safe mode: ask the model for competing hypotheses, then design tests or measurements that can distinguish between them.</em></p><ul><li><em>Estimation support</em></li></ul><p><em>Dangerous mode: anchor on the AI’s first estimate and treat it as a commitment.</em></p><p><em>Safe mode: treat AI estimates as one scenario among several, compare them with team estimates, and document why the final number differs.</em></p><ul><li><em>Meeting summaries</em></li></ul><p><em>Dangerous mode: use AI summaries as the single source of truth about decisions and action items.</em></p><p><em>Safe mode: circulate the summary for confirmation, explicitly ask participants to correct inaccuracies, and track who signs off.</em></p><ul><li><em>Metrics interpretation</em></li></ul><p><em>Dangerous mode: trust the AI’s conclusion on system health without checking data coverage.</em></p><p><em>Safe mode: review which metrics and sources were actually used, document what is not monitored, and adjust confidence accordingly.</em></p><p>The pattern in all cases is consistent: AI is a tool for generation and support, not for final judgment. Responsibility for validation and decision‑making cannot be delegated.</p><p><strong>A practical checklist before releasing any AI‑supported artifact</strong></p><p>Before any document, backlog, or analysis that involved AI leaves your hands, a short, repeatable checklist can dramatically reduce bias‑driven errors:</p><ul><li><em>Grounded</em></li></ul><p><em>Is there a clear source for every important requirement, rule, or claim?</em></p><p><em>If the source is “AI suggested it”, should it be downgraded to an assumption instead?</em></p><ul><li><em>Accurate</em></li></ul><p><em>Have critical numbers and business rules been checked against systems of record or authoritative documents?</em></p><p><em>Are dates, thresholds, and definitions aligned with how the business actually operates?</em></p><ul><li><em>Complete</em></li></ul><p><em>Are edge cases, exceptions, and non‑happy paths reasonably covered?</em></p><p><em>Are non‑functional requirements (performance, security, availability, compliance) considered where relevant?</em></p><ul><li><em>Consistent</em></li></ul><p><em>Does this artifact contradict any other approved documents, diagrams, or decisions?</em></p><p><em>If there are conflicts, are they intentionally documented and resolved?</em></p><ul><li><em>Traceable</em></li></ul><p><em>Can you explain how each major conclusion was reached?</em></p><p><em>Is it clear which parts come from observed data, stakeholder input, or regulations, and which parts are inferred?</em></p><ul><li><em>Actionable</em></li></ul><p><em>Can the team use this artifact directly to make decisions, design, or implement?</em></p><p><em>Are there ambiguous phrases that need clarification before work starts?</em></p><p>Finally, add an explicit ownership check: who owns the truth for each critical element? For example, a product owner might own business rules, a tech lead might own architectural constraints, and a legal representative might own compliance requirements. Without named owners, “AI said so” becomes a dangerous default.</p><p>A helpful habit is to enforce a two‑section structure in any AI‑assisted artifact:</p><ul><li><em>“Observed / From sources” — everything backed by data or stakeholders.</em></li><li><em>“Proposed / Inferred” — everything generated, interpreted, or assumed, including AI suggestions.</em></li></ul><p>This separation instantly clarifies what is solid and what still needs discussion.</p><p><strong>The goal is not less AI — it is more visible bias</strong></p><p>It is tempting to respond to all these risks by saying, “Let’s just rely less on AI.” That is neither realistic nor necessary. Artificial Intelligence can significantly accelerate drafting, exploration and even risk discovery. Provided that analysts stay in control.</p><p>The real goal is not to eliminate bias; that is impossible. The goal is to make bias visible, discussable and manageable. Adding one question to most AI-related work. “What could be wrong with this?”. Already shifts the conversation, toward critical thinking.</p><p>Artificial Intelligence will not automatically turn anyone into an analyst. Seniority comes from owning judgment, validation and decisions in environments of uncertainty. Used thoughtfully AI can support that ownership by making invisible assumptions easier to see. Used carelessly it simply scales the biases that were already there.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7630be67ee81" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/when-more-ai-enters-analysis-work-7630be67ee81">When more AI enters analysis work</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Path to the BA Profession: Myths, Motivation, and the Cost of Entry (Part 2)]]></title>
            <link>https://medium.com/andersen-it-community/path-to-the-ba-profession-myths-motivation-and-the-cost-of-entry-part-2-fc1c3cf63697?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/fc1c3cf63697</guid>
            <dc:creator><![CDATA[Vitali Birchanka]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 17:25:47 GMT</pubDate>
            <atom:updated>2026-04-23T17:25:46.650Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DRfky0mMwiK57ICfn-nAjw.png" /></figure><p>Diplomas are received, a traineeship is completed — what’s next? In the second part of the series, Vitali Birchanka is sharing his personal experience and practical advice on finding the first BA position: how to create a CV, where to search for vacancies, what to expect in a job interview, and why connections are important.</p><p>*This is the second part of a three-part series. If you are just learning about the profession, we recommend starting with <a href="https://medium.com/andersen-it-community/path-to-the-ba-profession-myths-motivation-and-the-cost-of-entry-part-1-796df2f93628">Part 1</a>.*</p><p><strong>Is it easy for a Junior specialist to find a job?</strong></p><p>I would say that such specialists are quite sought-after, although there are some nuances. For instance, product companies usually look for someone experienced so that the specialist can start working right away (nevertheless, quite often, they also organize traineeships and training for newcomers). Things are different at outsourcing, where Juniors are welcome. However, given the number of job seekers on the market, requirements are growing as well, and the field that the candidate comes from (banking, medicine, logistics) is becoming increasingly important. Such specialists can be hired because of their domain knowledge to be trained by mentors later, on projects.</p><p><strong>How long does it take to find the first job?</strong></p><p>It’s obvious that you need to be as prepared for the interview as possible, but sometimes, even your polished CV and excellent answers don’t result in a job offer. I know that in the cases of some of my colleagues, an HR manager was hooked by their covering letters, but I have never written any in my life. So in this matter, it’s all about luck.</p><p>Looking for your first job is the most nerve-wracking and time-consuming process. Your connections will help a lot. Moreover, many companies have referral programs (meaning you can receive a bonus for recommending an employee), so it’s essential to ask your friends working in IT about vacancies. However, this does not mean that you will be hired just because you are somebody’s friend — you’ll have to prove your competencies.</p><p>Along with that, I can recommend looking through vacancies on dedicated websites or the websites of IT companies, add HR specialists and recruiters to your contacts on LinkedIn, attend meetups on business analysis and systems analysis to expand your network.</p><p>Generally speaking, undergoing a few job interviews is not a bad thing at all. On the contrary, this instills a certain confidence, highlights your weaknesses, relieves jitters, and gives you an idea of ​​what questions are usually asked.</p><p>As for the essence of questions, some companies even post job interview samples. You can find a mentor in a dedicated group and simulate a real interview. Still, the main thing is to understand what questions are theoretical, and what questions will require you to do something quickly (like user stories, diagrams, etc.). It is important not to get confused here.</p><p><strong>Is it an advantage to have multiple diplomas and certificates?</strong></p><p>It all depends on a company and a project. Until recently, knowledge of BI tools was valued, but now, the ability to work with AI is highly welcomed. In general, the more skills you have that are confirmed somehow (like by certificates from training platforms), the better. However, it is the candidate’s adequacy and soft skills are valued most of all (as cliche as it may sound). You would agree that it’s more pleasant to communicate with a person who is open, smiling, and thinks logically, rather than with a gloomy one telling you with anger how bad their previous employer was.</p><p>Incidentally, speaking of certificates: at the first stage, you shouldn’t try to bite more than you can chew and immediately aim for something like ECBA, PMI-PBA, and CPRE — let alone CBAP, etc. Not all employers will value them more than your participation in real-world projects and your answers to questions during an interview. Certificates are valued in Europe; they can be your ticket to certain projects if that’s what the customer wants, but overall (as I see it) they can only help when, all other things being equal, the choice is made between several candidates.</p><p>At a later stage in your career, something like this will be nice to have, but you shouldn’t worry about it right away.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc1c3cf63697" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/path-to-the-ba-profession-myths-motivation-and-the-cost-of-entry-part-2-fc1c3cf63697">Path to the BA Profession: Myths, Motivation, and the Cost of Entry (Part 2)</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simplifying UDS Protocol: Unified Diagnostic Services]]></title>
            <link>https://medium.com/andersen-it-community/simplifying-uds-protocol-unified-diagnostic-services-2f1dbf68fea0?source=rss----e06e8e31660a---4</link>
            <guid isPermaLink="false">https://medium.com/p/2f1dbf68fea0</guid>
            <category><![CDATA[embedded-systems]]></category>
            <category><![CDATA[vehicle-diagnostics]]></category>
            <category><![CDATA[automotive-engineering]]></category>
            <category><![CDATA[can-bus]]></category>
            <category><![CDATA[uds-protocol]]></category>
            <dc:creator><![CDATA[Luis Dias ]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 09:15:32 GMT</pubDate>
            <atom:updated>2026-04-13T09:15:31.162Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zf23r6EAt_N5zW7zN8bxEA.avif" /><figcaption>Simplifying UDS Protocol: Unified Diagnostic Services</figcaption></figure><h4>UDS protocol is used in the automotive industry. The main goal of this protocol is establish the communication between testing tools and the ECUs in the car.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/619/1*z8w40yUFg--M7RbVF4UnVg.png" /><figcaption>UDS connection schema and cable OBD2</figcaption></figure><p>The ECUs are Electronic Control Units, in other words, is like a small computer inside the car used to receive data from sensors and control car parts like the motor, for example. In the car, there are some ECUs with different responsibilities as presented in the following picture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cVOAqYwkHHe2wrr35OfWjg.png" /><figcaption>ECUs in the car</figcaption></figure><p>This protocol is managed in accordance with ISO 14229. This ISO defines how the protocol should work, including message size, reserved bytes, service IDs, and others. In other words, ISO14229 is the “game” list of rules, and the UDS protocol is the “game” itself. This protocol follows the client-server logic; the user/test tool is the client who sends the requests, and the ECU is the server that does the response. In USD, for each “Request” there are two types of response: “Positive” and “Negative.”</p><p><strong>Request:</strong><br>The first part is SID, the Service ID requested. The second part is the sub-functions that are added. This information can be checked in ISO 14229. And the last part is reserved for the data parameters.</p><p><strong>Positive response: <br></strong>The first byte is always the requested service + 0x40. The other bytes depend on the service and response structure. It can be consulted in the ISO 14229.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*wdPYwolDCZf1y-Xm9idXnA.png" /><figcaption>Positive response structure for 0x10 service (source ISO14229)</figcaption></figure><p><strong>Negative response: </strong><br>The first byte is always 0x7F; it is defined by the ISO14229. The second byte is the Service ID requested — Is the service ID sent in the request that generated the negative response. The third byte is the Negative Response Code (NRC) — it is the “error code” in the ISO14229; there is a list of codes and the reason associated according to the service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*p3xxrUVgD3bFgI4JERrGDg.png" /><figcaption>List of NRC for service 0x10 (source: ISO14229)</figcaption></figure><p>The UDS request is normally transported in a CAN frame message. As known space for data in CAN messages is 8 bytes. It means the UDS request or answers can have a maximum size of 8 bytes. Sometimes the message doesn’t fulfill the 8 bytes, and in this case, “padding” is used. By other words, it means fill the empty bytes with some data like “00” or “AA”.</p><p>There are also two concepts used in UDS called<strong> </strong>single frame<strong> </strong>and multi frame communication. Regarding a single frame, it happens when the data message response fits in 8 bytes, which means that one message sends all the data requested. The other case is multi-frame; in this case, some messages are needed some messages to send all the data requested by the UDS request.</p><p><strong>Single Frame flow explanation:<br></strong>The following picture presents a log of a single-frame communication. <br>In the first line is sent the request “03 22 F4 0D AA AA AA AA”. “0x03” is the PCI (Process Control Information) and is included in 8 bytes of the UDS message included in the CAN frame. The “0x22” is the service ID in this case, ReadDatabyIdentifier, according to ISO14229. The bytes “0xF4 0x0D” are part of the sub-function in this case, DID. And the other bytes are padding in this case, filled with AA.<br>In the second line, there is the response. First byte is PCI. The second byte is “0x62”, which means a positive response, because the requested service was “0x22”, and adding “0x40”, the result is “0x62”. The other bytes “0xF4 0x0D” are the DID sent in the request. The byte “0x32” is the data requested. The other bytes are padding filled with AA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mIbXUa1zcXELng3gdViDGA.png" /><figcaption><strong>Single Frame flow explanation</strong></figcaption></figure><p><strong>Multi-Frame flow explanation:<br></strong>The following picture presents a log of a multi-frame communication. <br>In the first line is sent the request “03 22 01 01 AA AA AA AA”. “0x03” is the PCI (Process Control Information) and is included in 8 bytes of the UDS message included in the CAN frame. The “0x22” is the service ID in this case, ReadDatabyIdentifier, according to ISO14229. The bytes “0x01 0x01” are part of the sub-function in this case, DID. And the other bytes are padding in this case, filled with AA.<br>In the second line, there is the response. First byte “0x10” is PCI. The second byte is “0x3E”, that mean the full size of data to transfer. In this case, converting 0x3E from hexadecimal to decimal, it means 63 bytes of response data. The third byte is “0x3E”, which means a positive response, because the requested service was “0x22”, and adding “0x40”, the result is “0x62”. The other bytes “0x01 0x01” are the DID sent in the request. The bytes “0xFF 0xF7 0xE7” are the first 3 bytes of the data requested. In this case, there isn’t any padding because the 8 bytes are filled. <br>In the third line, the client sends a message to the ECU with communication information to send the rest of the data. The message “0x30 0x00 0x00 AA AA AA AA AA” contains the first byte “0x30”, which means flow control message. The second byte “0x00” defines the block size, in this case, unlimiteded defined. The third byte “0x00” defines the delay between messages; in this case, no delay is defined. <br>The lines four to eleven are all messages from the ECU to the client. In those lines, the data requested in line one is sent. Each message sends PCI + 7 bytes of data. It means that in these eight lines are transmitted 7 x 8 = 56 bytes. Remember, 3 bytes were already sent in the message of the second line. Adding them means 56 + 3 = 59 bytes sent. Also, in the second line there are 3 bytes of the response “0x62 0x01 0x01”, adding them, 59 + 3 = 62 bytes. It matches the number “0x3E” of the second byte of the message in line two.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PucDXLN86Dtnw1GjzzlnkQ.png" /><figcaption><strong>Multi-Frame flow explanation:</strong></figcaption></figure><p>In summary, the UDS protocol is used and useful for diagnostic services. It is widely used in the automotive industry to send requests to car ECUs and receive information about different information and data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f1dbf68fea0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/andersen-it-community/simplifying-uds-protocol-unified-diagnostic-services-2f1dbf68fea0">Simplifying UDS Protocol: Unified Diagnostic Services</a> was originally published in <a href="https://medium.com/andersen-it-community">Andersen IT Community</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>