<?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[Bancolombia Tech - Medium]]></title>
        <description><![CDATA[Blog de tecnología Bancolombia - Medium]]></description>
        <link>https://medium.com/bancolombia-tech?source=rss----6de4dfd7bc9a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Bancolombia Tech - Medium</title>
            <link>https://medium.com/bancolombia-tech?source=rss----6de4dfd7bc9a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 21:12:34 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/bancolombia-tech" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Cutting Test Cycles from Days to Hours: Lessons from Scaling Golden Tests at Bancolombia]]></title>
            <link>https://medium.com/bancolombia-tech/cutting-test-cycles-from-days-to-hours-lessons-from-scaling-golden-tests-at-bancolombia-7f4c8a46a08e?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/7f4c8a46a08e</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-testing]]></category>
            <dc:creator><![CDATA[Juan Diego Campuzano]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 16:36:07 GMT</pubDate>
            <atom:updated>2026-11-05T16:36:06.620Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How bc_golden_plugin helped us turn visual QA into something we can run, repeat and trust.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gar-NJyfp_pxVHIyE9UXbA.png" /></figure><p>For years, visual QA in our Flutter projects looked the same: a developer finished a component or a screen and scheduled a review with the design team to confirm that it matched the design in Figma. It worked, but it depended on finding a time on everyone’s calendar.</p><p>Then came the moment that changed how we see this process. Last year we migrated our own design system to a new version. The migration took nearly three months. Many of our microfrontends depend on the design system, and the new version came with a lot of breaking changes, so the whole app had to be re-certified visually to make sure everything was still OK.</p><p>And there was a bigger problem. During the migration, we could not generate an APK to test the migrated widgets early. Until every widget was migrated to the new design system and the new Flutter version, there was no test artifact, so we often worked blind until the final regression stage.</p><p>In this article, I will share how we went from that experience to a visual QA process based on golden tests, why we decided to build our own package, <strong>bc_golden_plugin</strong>, what it looks like in practice, the problems we found along the way (CI, I’m looking at you), and the results and lessons we have collected so far.</p><blockquote><em>In a previous article (in Spanish), </em><a href="https://medium.com/bancolombia-tech/utilizando-golden-tests-como-herramienta-de-qa-visual-91ef96cb8ed0"><em>Utilizando Golden Tests como herramienta de QA visual</em></a><em>, I explained what golden testing is, how </em><em>matchesGoldenFile works, and the first version of our package. If you are new to golden tests, start there; this article picks up where that one ended.</em></blockquote><p>Before going further, special thanks go to two teammates: <a href="https://www.linkedin.com/in/john-mario-cabrera-201a35215/">John Mario Cabrera</a>, who has gone all-in on golden testing with me, and <a href="https://www.linkedin.com/in/wensierrasepul0711">Wendy Carolina Sierra Sepulveda</a>. Both reviewed this article, and their observations made it more accurate and complete.</p><h3>How did visual QA work before?</h3><p>Before golden tests, visual QA was a manual and collaborative process:</p><ol><li><strong>Build:</strong> the developer implemented the screen based on the Figma design.</li><li><strong>Schedule:</strong> we booked a review session with the design team.</li><li><strong>Review and fix:</strong> together, we compared the implementation against the design and, if something was off, we fixed it and sometimes scheduled another review.</li></ol><p>The design team supports many areas at the same time, so review slots were shared across all of those requests, and the review stage sometimes took longer than we planned. This was nobody’s fault; the process depended on people being available at the same time, and it did not scale to the number of screens we were building. A migration turns this into something much bigger: it is not just one screen that needs a review; it is the entire app.</p><p>We also had a Look and Feel test suite, but it had its own limits: it depended on the availability of the QA environment and the product APIs. If the environment was down, or a service did not return the state we needed, that scenario simply could not be tested.</p><h3>So… why golden tests?</h3><p>A golden test renders a widget and compares it pixel by pixel against a reference image (the “golden”). This gave us what we were missing:</p><ul><li><strong>Repeatability:</strong> the same check runs the same way every time, without anyone booking a meeting.</li><li><strong>Scale:</strong> re-certifying the whole app becomes a matter of running the test suite and reviewing the diffs, instead of reviewing every screen by hand.</li><li><strong>Early feedback:</strong> goldens run on the widgets themselves, so we can check a migrated component as soon as it exists, without waiting for a full test build of the app.</li><li><strong>More scenarios:</strong> a golden test is purely visual and runs on mocks, so we can cover many more states, such as approved, cancelled, in progress, and failed, without depending on an environment or an API.</li><li><strong>A shared source of truth:</strong> the golden image becomes the agreement between design and development. Once design approves how something looks, the golden test protects it.</li></ul><p>Golden tests did not replace the design team. Their review is still where a golden image gets approved; what changed is that we don’t need to ask for the same review again every time we touch the code.</p><h3>Why did we build our own package?</h3><p>flutter_test already gives you matchesGoldenFile, and there were great packages built on top of it, especially <a href="https://pub.dev/packages/golden_toolkit">golden_toolkit</a> and <a href="https://pub.dev/packages/alchemist">alchemist</a>. Our README says it openly: bc_golden_plugin is heavily inspired by both. Still, we decided to build our own, for two reasons:</p><ul><li><strong>Independence:</strong> we did not want a critical part of our quality process to depend on a third-party package whose roadmap we don’t control.</li><li><strong>Missing features:</strong> we needed things that were not available together in one package, like comparing a component directly against a design exported from Figma, an acceptable difference percentage, and ready-to-use device configurations.</li></ul><p>Time proved the first point right. In 2024, the maintainers of golden_toolkit announced that the repository is no longer actively maintained, and the package is now marked as discontinued on pub.dev.</p><p>Today, our package is open source (Apache 2.0), published on pub.dev under bancolombia.com, and its latest version at the time of writing is <strong>3.2.0</strong>.</p><h3>What does it look like in practice?</h3><p>Let’s start with the configuration. A flutter_test_config.dart file in your test folder runs before your tests, so it is a good place to set things up once:</p><pre>// test/flutter_test_config.dart<br>import &#39;dart:async&#39;;<br>import &#39;package:bc_golden_plugin/bc_golden_plugin.dart&#39;;<br>import &#39;package:flutter_test/flutter_test.dart&#39;;<br><br>Future&lt;void&gt; testExecutable(FutureOr&lt;void&gt; Function() testMain) async {<br>  TestWidgetsFlutterBinding.ensureInitialized();<br>  final bcGoldenConfiguration = BcGoldenConfiguration();<br><br>  // The ThemeData your app uses<br>  bcGoldenConfiguration.themeData = AppTheme.light;<br><br>  // Accept up to 0.5% of difference<br>  bcGoldenConfiguration.setThresholdRatio(0.005);<br><br>  // Loads fonts and assets so goldens look like the real app<br>  await loadConfiguration();<br>  await testMain();<br>}</pre><p>That last line matters: as we saw in the previous article, plain golden tests render text with a placeholder font. loadConfiguration loads fonts and assets for us. Now a test for a single component:</p><pre>// test/button_golden_test.dart<br>BcGoldenCapture.single(<br>  &#39;primary_button_golden&#39;,<br>  (tester) async {<br>    await bcWidgetMatchesImage(<br>      imageName: &#39;primary_button&#39;,<br>      widget: const PrimaryButton(label: &#39;Continue&#39;),<br>      tester: tester,<br>      device: GoldenDeviceData.iPhone13,<br>    );<br>  },<br>);</pre><p>bcWidgetMatchesImage renders the widget with the configured theme, in the size and pixel ratio of the selected device. The package ships with several device configurations (iPhone 8, iPhone 13, iPad Pro, Galaxy S25, among others), and you can create your own with bcCustomWindowConfigData.</p><h4>What about accessibility?</h4><p>Many users increase the font size on their phones, and that is where layouts tend to break. With textScaleFactor we can render the component with a bigger font:</p><pre>BcGoldenCapture.single(<br>  &#39;primary_button_large_text_golden&#39;,<br>  (tester) async {<br>    await bcWidgetMatchesImage(<br>      imageName: &#39;primary_button_large_text&#39;,<br>      widget: const PrimaryButton(label: &#39;Continue&#39;),<br>      tester: tester,<br>      device: GoldenDeviceData.iPhone13,<br>      textScaleFactor: 2.0,<br>    );<br>  },<br>);</pre><p>Now overflows and truncated texts show up in a test instead of on a user’s phone.</p><h4>And the Figma comparison?</h4><p>This is the use case that started everything. The reference image can be the design exported from Figma, so the test answers the question we used to ask in the review meeting: “does the implementation look like the design?” Keep in mind that a Figma export and a Flutter render will never be identical pixel by pixel, so this kind of test needs a more generous threshold than a regression test.</p><h3>Why was CI the hardest part?</h3><p>Writing the tests was the easy part. Making them pass in CI was not.</p><p>A golden generated on a developer’s machine can differ slightly from the one rendered in CI. The operating system, font rasterization and anti-aliasing are not exactly the same, so the same widget produces tiny differences that are invisible to the human eye but enough to fail a pixel-by-pixel comparison. At first, this meant tests that passed locally and failed in the pipeline, the fastest way to make a team stop trusting its tests.</p><p>Our solution was to accept a small percentage of difference. The package includes a comparator with a threshold (LocalFileComparatorWithThreshold), and it is initialized automatically with the value from BcGoldenConfiguration when you use bcWidgetMatchesImage or BcGoldenCapture:</p><pre>// As a percentage (0.5%)<br>bcGoldenConfiguration.goldenDifferenceThreshold = 0.5;<br><br>// Or as a ratio (0.005 = 0.5%)<br>bcGoldenConfiguration.setThresholdRatio(0.005);<br><br>// Decide whether a difference above the threshold fails the test<br>bcGoldenConfiguration.willFailOnError = true;</pre><p>With this, rendering noise stays below the threshold and real visual changes still fail the test.</p><p>Later, we went one step further: in the app, the reference images are now generated in the pipeline itself. Since the goldens are created in the same environment where they are compared, those rendering differences disappear, and today our goldens pass without false positives.</p><h3>How do we run them in CI and keep the results?</h3><p>Removing the false positives was only half of the work. A failing test is useful only if someone can quickly see why it failed, and a passing test is worth more when you can prove what it checked.</p><h4>Running the tests in CI</h4><p>Our pipelines run on Azure, and the golden tests run there as one more step of the pipeline. Most of our projects run them on Linux agents, while the design system runs them on macOS. What matters is not which operating system you pick, but that the goldens are generated and compared on the same one. A simplified version of the step looks like this:</p><pre>- script: flutter test<br>  displayName: Run golden tests</pre><h4>Where do the results go?</h4><p>When a golden test fails, Flutter’s file comparator writes the evidence to a failures folder next to the test: the expected image (_masterImage), the rendered one (_testImage), and two difference images (_isolatedDiff and _maskedDiff). Those files are exactly what a reviewer needs, so we do not leave them inside the agent. We publish them as pipeline artifacts:</p><pre>- task: PublishPipelineArtifact@1<br>  displayName: Publish golden results<br>  condition: always() # publish even when the tests pass<br>  inputs:<br>    targetPath: &#39;$(Build.SourcesDirectory)/test&#39;<br>    artifact: &#39;golden-results&#39;</pre><p>Downloading an artifact and opening images one by one still takes time, so we built an internal Azure DevOps extension that turns those results into a report. It adds a new <strong>Report</strong> tab to the pipeline run, where you can see the expected image, the rendered image and their differences side by side, without leaving Azure DevOps. With it, deciding whether a failure is a real bug or an intended design change takes seconds instead of a meeting.</p><h4>Why keep the results even when the tests pass?</h4><p>It is tempting to publish the images only when something breaks. We learned to keep them every time. A passing run is also evidence: it shows which screens and states were validated, for which version, and what they looked like at that moment. When a visual bug shows up weeks later, we can go back to the run for that version and see whether the screen already looked that way or changed afterwards. And when a package goes through certification, that history is what lets us show what was checked instead of only saying that the tests were green. That traceability is what turns golden tests from a development tool into part of our QA process.</p><h3>From single widgets to full flows and animations</h3><p>The first API of the package, bcGoldenTest, worked well for individual components, but it fell short of what we wanted to test. A screen is not only how it looks at rest; it is also how it moves and how it connects with the next screen. So we added a unified API, BcGoldenCapture, with three entry points: single, multiple and animation. The legacy bcGoldenTest is still supported but deprecated.</p><h4>How do you test a full flow in one golden?</h4><p>With BcGoldenCapture.multiple, each step of a flow is captured and all the captures are combined into a single golden image:</p><pre>BcGoldenCapture.multiple(<br>  &#39;onboarding_flow_golden&#39;,<br>  [<br>    GoldenStep(<br>      stepName: &#39;Welcome&#39;,<br>      widgetBuilder: () =&gt; const WelcomeScreen(),<br>    ),<br>    GoldenStep(<br>      stepName: &#39;Features&#39;,<br>      widgetBuilder: () =&gt; const FeaturesScreen(),<br>      setupAction: (tester) async {<br>        await tester.tap(find.text(&#39;Next&#39;));<br>        await tester.pump();<br>      },<br>    ),<br>  ],<br>  const GoldenCaptureConfig(<br>    testName: &#39;onboarding_flow&#39;,<br>    layoutType: CaptureLayoutType.horizontal,<br>    spacing: 16.0,<br>  ),<br>);</pre><p>setupAction and verifyAction let you interact with the screen before or after the capture, and the layout can be vertical, horizontal or grid. The result is one image that a designer can review in a single look, much closer to how they think about the experience than a folder of separate screenshots.</p><figure><img alt="Reference image for demonstration purposes, not an actual implementation" src="https://cdn-images-1.medium.com/max/832/1*joqMS0wL6QfSPE4YeMXXrw.png" /></figure><blockquote><em>Illustrative example created by the author. Not real product or customer data. Please don’t reuse it without permission.</em></blockquote><h4>And animations?</h4><p>For animations, BcGoldenCapture.animation captures frames at specific timestamps and places them side by side in one golden:</p><pre>BcGoldenCapture.animation(<br>  &#39;expand_card_animation&#39;,<br>  () =&gt; const ExpandableCard(),<br>  const GoldenAnimationConfig(<br>    testName: &#39;expand_card_animation&#39;,<br>    totalDuration: Duration(milliseconds: 300),<br>    animationSteps: [<br>      GoldenAnimationStep(timestamp: Duration.zero, frameName: &#39;start&#39;),<br>      GoldenAnimationStep(<br>        timestamp: Duration(milliseconds: 150),<br>        frameName: &#39;middle&#39;,<br>      ),<br>      GoldenAnimationStep(<br>        timestamp: Duration(milliseconds: 300),<br>        frameName: &#39;end&#39;,<br>      ),<br>    ],<br>  ),<br>  animationSetup: (tester) async {<br>    // Trigger the animation<br>    await tester.tap(find.byType(ExpandableCard));<br>    await tester.pump();<br>  },<br>);</pre><p>This is useful for transitions and loading states, where the bug is usually somewhere in the middle.</p><h3>What were the results?</h3><p>These numbers come from our team’s own experience, so take them as approximate figures rather than a formal benchmark:</p><ul><li><strong>Certification time:</strong> on average, certifying a package used to take between 40 and 80 hours, depending on its size. With golden tests, we now certify it in under 2 hours.</li><li><strong>Adoption:</strong> two main areas use the package today: the design system team and the main app team, who are still adding tests.</li><li><strong>Coverage:</strong> together, we are approaching 1,000 golden tests.</li></ul><p>But the biggest change is not in the numbers. Visual QA stopped being an event that we schedule and became something that runs with our test suite, and review time now goes to new designs instead of things that were already approved.</p><h3>Lessons learned and trade-offs</h3><p>Golden tests are not free. These are the main trade-offs we have found:</p><ul><li><strong>Goldens need maintenance:</strong> a large suite means more images to review, store and regenerate, so be selective about what deserves a golden.</li><li><strong>Intentional changes mean regenerating images:</strong> when a design changes on purpose, the goldens must be regenerated, and the new images must be reviewed as carefully as code. Treating --update-goldens as &quot;make the tests green&quot; defeats the whole purpose.</li><li><strong>A threshold can hide real differences:</strong> the acceptable difference percentage solved our CI problem, but a threshold that is too generous can also let small real changes pass, like a slightly different color or a one-pixel shift. The lesson: keep it as low as the environment allows, and consider a different tolerance for Figma comparisons than for regression tests.</li><li><strong>The environment matters:</strong> fonts, platform and Flutter version all affect the render. Without a consistent environment, you will chase false positives instead of real bugs.</li><li><strong>Building your own package has a cost:</strong> independence means we own the maintenance, the documentation and the upgrades for each new Flutter version. For us it is worth it, but it is a decision every team should make consciously.</li></ul><h3>Conclusion</h3><p>Golden tests started for us as a way to avoid waiting for a review meeting. Today they are part of how we build: the design system team uses them to protect components, the main app team keeps adding them to the app’s screens, and re-certifying the whole app after a big change is now something we can check in a fraction of the time.</p><p>More than a testing technique, this marks the maturity of our visual QA process. It moved from depending on people’s availability to depending on automation, and that frees designers and developers to focus on what really needs human judgment: deciding how things should look, not checking again that they still do.</p><p>If you want to dig deeper into the package, I invite you to take a look at the repository on <a href="https://github.com/bancolombia/bc_golden_plugin">GitHub</a> or at <a href="https://pub.dev/packages/bc_golden_plugin">pub.dev</a>. And if you want to read more articles like this one, follow <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium.</p><h3>References</h3><ul><li><a href="https://pub.dev/packages/bc_golden_plugin">bc_golden_plugin on pub.dev</a></li><li><a href="https://github.com/bancolombia/bc_golden_plugin">bancolombia/bc_golden_plugin on GitHub</a></li><li><a href="https://medium.com/bancolombia-tech/utilizando-golden-tests-como-herramienta-de-qa-visual-91ef96cb8ed0">Utilizando Golden Tests como herramienta de QA visual (Bancolombia Tech)</a></li><li><a href="https://api.flutter.dev/flutter/flutter_test/matchesGoldenFile.html">matchesGoldenFile, Flutter API docs</a></li><li><a href="https://pub.dev/packages/golden_toolkit">golden_toolkit on pub.dev (discontinued)</a></li><li><a href="https://github.com/eBay/flutter_glove_box">eBay flutter_glove_box: “This repo is no longer maintained”</a></li><li><a href="https://pub.dev/packages/alchemist">alchemist on pub.dev</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f4c8a46a08e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/cutting-test-cycles-from-days-to-hours-lessons-from-scaling-golden-tests-at-bancolombia-7f4c8a46a08e">Cutting Test Cycles from Days to Hours: Lessons from Scaling Golden Tests at Bancolombia</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Harness Engineering: cómo hacer que un agente de IA trabaje de verdad]]></title>
            <link>https://medium.com/bancolombia-tech/harness-engineering-c%C3%B3mo-hacer-que-un-agente-de-ia-trabaje-de-verdad-6f43d865453b?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/6f43d865453b</guid>
            <category><![CDATA[arquitectura-de-software]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[autonomous-system]]></category>
            <category><![CDATA[agent-orchestration]]></category>
            <category><![CDATA[genai]]></category>
            <dc:creator><![CDATA[Jonathan Andres Vasquez Castañeda]]></dc:creator>
            <pubDate>Fri, 16 Oct 2026 15:14:23 GMT</pubDate>
            <atom:updated>2026-10-16T15:14:22.427Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Resumen</strong></p><p>Durante mucho tiempo pensé que mejorar un agente de inteligencia artificial consistía, sobre todo, en elegir un modelo más potente o escribir un prompt más detallado. Al estudiar cómo funcionan los agentes que trabajan con archivos, herramientas y servicios externos, descubrí que esa explicación era incompleta.</p><p>En este artículo presento, con un ejemplo sencillo, qué es el <strong><em>harness</em></strong>: el sistema que rodea al modelo y le permite actuar. Explico sus piezas principales: herramientas, bucle de trabajo, memoria, contexto, entorno aislado, permisos, verificación, observabilidad y evaluaciones.</p><p>Esto no es mas que una revisión conceptual basada en artículos de investigación, documentación técnica y marcos de seguridad. El resultado es un modelo mental que me ha ayudado a entender por qué dos agentes que usan el mismo modelo pueden comportarse de manera muy diferente.</p><p><strong>El modelo aporta la capacidad de interpretar y decidir; el harness le proporciona un lugar donde trabajar, ejecuta sus solicitudes, conserva lo importante y comprueba si el resultado es correcto. </strong>Mi conclusión es que la confianza no aparece por accidente ni se consigue solamente con un modelo más grande. Se construye diseñando bien el sistema que lo rodea, limitando lo que puede hacer y midiendo sus resultados con tareas repetibles.</p><p><strong>Palabras clave:</strong> agentes de inteligencia artificial, harness engineering, herramientas, contexto, memoria, seguridad, observabilidad, evaluación.</p><h3><strong>1. Introducción</strong></h3><h4><strong>1.1. La pregunta que me hizo cambiar de perspectiva</strong></h4><p>Cuando un agente de IA responde mal, solemos pensar que el problema está en el modelo. La reacción habitual es probar otro más grande o escribir instrucciones más largas. A veces funciona, pero no siempre.</p><p>La pregunta que empezó a interesarme fue otra: <strong>¿qué sistema rodea al modelo mientras trabaja?</strong></p><p>Un agente que programa no solo escribe texto. Busca archivos, los abre, modifica código, ejecuta pruebas y corrige errores. Un agente de atención al cliente no solo redacta una respuesta. Tiene que consultar un pedido, comprobar que los datos son correctos, enviar un mensaje y dejar constancia de lo ocurrido.</p><p>El modelo no hace todo eso por sí mismo. Un programa externo le entrega información, ejecuta las acciones que solicita y le cuenta qué sucedió. A ese programa, junto con sus reglas y mecanismos de control, se lo conoce como <strong>harness</strong>.</p><h4><strong>1.2. ¿Qué quiero explicar?</strong></h4><p>En este artículo quiero explicar el tema como me habría gustado encontrarlo cuando empecé a estudiarlo: primero con un ejemplo cotidiano y después con los nombres técnicos.</p><p>La pregunta central es:</p><p><strong>¿Qué necesita un modelo de lenguaje para pasar de generar respuestas a completar tareas reales de forma confiable?</strong></p><p>Mi respuesta, resumida, es esta: necesita herramientas para actuar, un bucle para avanzar, memoria para continuar, contexto para saber qué mirar, un entorno seguro, límites claros y una forma externa de comprobar que terminó bien.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6CA_zrtbvIhLYnLwnb_W2w.jpeg" /><figcaption>Un modelo de lenguaje no actúa directamente sobre el mundo: propone decisiones. Es el <em>harness</em> el que proporciona las herramientas, memoria, permisos y entorno seguro para transformar ese razonamiento en ejecución real</figcaption></figure><h4><strong>1.3. ¿De dónde salen estas ideas?</strong></h4><p>La investigación sobre agentes ya había estudiado la combinación de razonamiento y acción en trabajos como el patron agentico ReAct [1]. Después, distintos equipos publicaron guías sobre herramientas, contexto, agentes y evaluación [2][3]. También aparecieron protocolos como Model Context Protocol (MCP), que buscan estandarizar la conexión entre modelos y servicios externos [4].</p><p>En este articulo uso <strong><em>harness engineering</em></strong> como un nombre práctico para hablar de todo ese sistema que rodea al modelo. El término todavía se usa de maneras distintas, pero la idea principal es estable: <strong>un modelo capaz necesita una buena estructura alrededor para producir trabajo útil.</strong></p><h3><strong>2. Metodología</strong></h3><p>Este artículo es una revisión conceptual y una guía explicativa. No es un experimento comparativo ni pretende demostrar que un modelo sea mejor que otro.</p><p>Para prepararlo seguí cinco pasos:</p><p>1. Separé lo que hace el modelo y lo diferencié de lo que hace el programa que lo acompaña.</p><p>2. Agrupé las funciones del harness en piezas fáciles de reconocer.</p><p>3. Elegí un único ejemplo: una tienda que necesita responder preguntas sobre pedidos.</p><p>4. Contrasté las explicaciones con las fuentes citadas al final.</p><p>5. Revisé cada sección para que primero aparezca el problema y después el término técnico.</p><p>Este mismo método sirve para analizar cualquier agente: se puede anotar qué herramientas tiene, qué información recibe, qué recuerda, qué permisos posee y cómo se comprueba su resultado.</p><h3><strong>3. Resultados: las piezas que encontré</strong></h3><h4><strong>3.1. El modelo piensa; el harness hace posible el trabajo</strong></h4><p>La forma más simple de imaginar un modelo de lenguaje es esta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G7XcqM1P4Mp6Dq68WqaKaQ.jpeg" /><figcaption>texto que recibe -&gt; modelo -&gt; texto que produce</figcaption></figure><p>El modelo recibe texto y devuelve texto. No abre un archivo por voluntad propia, no consulta una base de datos y no sabe qué ocurrió en una llamada anterior si nadie se lo vuelve a contar.</p><p>Entonces, ¿quién busca un archivo cuando usamos un agente de programación?, ¿quién ejecuta una prueba?, ¿quién cambia el archivo real?</p><p>La respuesta: lo hace el harness.</p><p>Para entenderlo me sirve esta comparación: el modelo es como una persona que sabe pensar y proponer soluciones; el harness es el escritorio, las herramientas, los permisos, la memoria y el sistema de registro que esa persona necesita para trabajar.</p><p>Por eso, dos productos pueden utilizar el mismo modelo y sentirse completamente diferentes. Uno puede ofrecer buenas herramientas, contexto claro y verificaciones. El otro, puede entregar información desordenada y permitir acciones peligrosas. La diferencia no está necesariamente en el cerebro, sino en el entorno de trabajo.</p><h4><strong>3.2. Las herramientas: la forma de tocar el mundo</strong></h4><p>Imaginemos a Johana, quien tiene un centro estetico y vende productos. Sus clientes le escriben para preguntar dónde está su pedido y ella quiere un agente que responda esas consultas.</p><p>El modelo puede redactar una respuesta amable, pero no sabe dónde está el pedido. Para averiguarlo, el harness tiene que ofrecerle herramientas:</p><pre>consultar_pedido(id_pedido)<br>leer_historial_cliente(id_cliente)<br>enviar_correo(destinatario, mensaje)<br>archivar_caso(id_caso)</pre><p>Una herramienta es un contrato. Tiene cuatro partes: un nombre, una explicación, los datos que necesita y el resultado que devuelve.</p><p>El modelo no ejecuta `consultar_pedido`. Solo pide usarla:</p><pre>consultar_pedido({&quot;id_pedido&quot;: &quot;V-4321&quot;})</pre><p>El harness recibe esa petición, consulta el sistema autorizado y devuelve:</p><pre>estado: enviado<br>transportista: MRW<br>entrega_estimada: 2026-09-04</pre><p>Con esa información, el modelo puede decidir qué hacer después.</p><p>Aquí descubrí un detalle importante: el mensaje de error también forma parte del diseño. La respuesta: ‘pedido no encontrado’ ayuda poco. Un mensaje como ‘no encontré V-4321; el formato esperado es V-1234 y hay una coincidencia V-4320’ le permite al agente corregirse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lSBEebWF3iLz8TS6y7Wbyw.jpeg" /><figcaption>Arquitectura del <em>harness</em>: el modelo propone la acción, y el sistema gestiona los permisos, la ejecución y la seguridad en el mundo real.</figcaption></figure><p>Por eso, las herramientas deben tener nombres claros, parámetros concretos, resultados pequeños y errores que orienten el siguiente paso.</p><h4><strong>3.3. El bucle: una tarea necesita varios pasos</strong></h4><p>Consultar el pedido no resuelve todo. El agente todavía tiene que revisar la información, redactar el correo, pedir autorización, enviarlo y confirmar que salió bien.</p><p>Cada paso depende del anterior. Si el pedido no existe, no tiene sentido enviar un correo diciendo que fue enviado.</p><p>El harness resuelve esto llamando al modelo varias veces:</p><pre>mientras no haya evidencia de que el trabajo terminó:<br>    preguntar al modelo qué hacer<br>    ejecutar la acción solicitada<br>    contarle qué ocurrió</pre><p>En la primera vuelta, el agente solo conoce la consulta del cliente. En la segunda, ya sabe qué devolvió la búsqueda. En la tercera, puede haber leído el historial del cliente. Cada vuelta empieza con un poco más de información.</p><p>Este patrón se parece a ReAct, un enfoque descrito por Yao y sus colaboradores [1]: razonar, actuar, observar el resultado y volver a razonar, no es una receta mágica. Es una manera de organizar el trabajo.</p><p><strong>Un agente es un modelo y un harness trabajando juntos en un bucle para alcanzar un objetivo.</strong></p><h4><strong>3.4. La memoria: el modelo no recuerda por sí solo</strong></h4><p>Entre una llamada y otra, el modelo no conserva automáticamente lo ocurrido. Si queremos que continúe una tarea, el harness debe guardar el estado y volver a enviárselo.</p><p>En el caso de Johana, ese registro podría decir:</p><pre>Pedido: V-4321, enviado, entrega estimada el 04/09/2026.<br>Cliente: &quot;ya había preguntado ayer.&quot;<br>Acción realizada: &quot;correo preparado.&quot;<br>Pendiente: &quot;solicitar autorización y enviar.&quot;<br>Intentos: 1</pre><p>Esto es memoria externa. Puede ser el historial de la conversación, un archivo, una base de datos o un registro de eventos.</p><p>También conviene separar dos tipos de memoria:</p><p>- <strong>Memoria de la tarea:</strong> lo que hace falta para terminar este caso.</p><p>- <strong>Memoria del equipo:*</strong>decisiones y conocimientos que pueden servir en casos futuros.</p><p>No conviene guardar todo sin criterio. Hay que decidir qué información se conserva, durante cuánto tiempo, quién puede leerla y cómo se eliminan los datos sensibles.</p><h4><strong>3.5. El contexto: enseñar lo necesario, no todo</strong></h4><p>Aunque un modelo pueda recibir mucho texto, no significa que convenga mostrarle todo. Si le entregamos el repositorio completo para cambiar un botón, el archivo importante quedará perdido entre miles de líneas.</p><p>Yo entiendo el contexto como una linterna: ilumina la parte que hace falta en cada momento.</p><p>Una estrategia práctica es:</p><p>1. Explicar dónde vive cada dato<br>2. Traer solo el registro necesario<br>3. Conservar el resultado útil<br>4. Resumir lo antiguo cuando la conversación crece.</p><p>Para Johanna, el primer contexto podría ser:</p><pre>Los pedidos están en la API de órdenes.<br>El historial del cliente está en el CRM.<br>El envío de correos requiere autorización.<br>La confirmación queda registrada en el sistema de casos.</pre><p>Después, el agente pide los detalles que necesita. Esta búsqueda selectiva se conoce como <strong><em>retrieval</em></strong> y es la idea central de los sistemas de generación aumentada por recuperación [8]. La idea de comenzar con poca información y ampliarla solo cuando hace falta se llama <strong><em>progressive disclosure</em></strong>.</p><p>La gestión del contexto también afecta al coste y a la velocidad. Cuanto más texto se envía, más recursos se consumen y más difícil puede ser distinguir lo importante.</p><h4><strong>3.6. El entorno: un lugar seguro para equivocarse</strong></h4><p>Todo agente trabaja en algún sitio. Puede modificar archivos, ejecutar comandos o llamar a servicios externos. Si ese sitio es producción, un error puede ser muy caro.</p><p>Por eso se suele crear un entorno separado, conocido como <strong><em>sandbox</em></strong>. En él se puede limitar qué archivos lee, qué comandos ejecuta, qué sitios contacta, qué credenciales utiliza y cuánto tiempo o recursos consume.</p><p>En el caso de Johanna, lo razonable sería usar pedidos ficticios y un simulador de transportista, no la base real de clientes.</p><p>El sandbox reduce el daño de un comando equivocado o de una instrucción maliciosa escondida en un archivo. No es una protección absoluta: si se le dan demasiados permisos, parte de esa protección desaparece. Por eso, debe combinarse con autenticación, gestión de secretos, validaciones y auditoría.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uQsU91Ob79WJqkU-Ix7Yuw.jpeg" /><figcaption>El <em>sandbox</em> permite al agente experimentar y equivocarse de forma segura, mientras el <em>harness</em> exige aprobación humana antes de impactar el sistema real.</figcaption></figure><h4><strong>3.7. El objetivo: «terminado» debe significar algo concreto</strong></h4><p>«Responde a los clientes dónde está su pedido» parece una instrucción clara, pero deja preguntas abiertas:</p><p>- ¿Qué ocurre si el pedido no existe?<br>- ¿Se puede prometer una fecha aproximada?<br>- ¿Puede modificar los datos del cliente?<br>- ¿Debe enviar el mensaje sin pedir autorización?</p><p>Para evitar que el modelo invente las respuestas, convierto el pedido en una especificación:</p><pre>Objetivo:<br>Informar al cliente del estado confirmado de su pedido.<br><br>Restricciones:<br>- No inventar fechas ni estados.<br>- Mantener un tono breve y respetuoso.<br>- No modificar los datos del pedido.<br><br>Criterios de aceptación:<br>- El pedido se consultó en la fuente autorizada.<br>- El mensaje coincide con el estado registrado.<br>- El envío del correo tiene confirmación externa.<br>- El caso queda archivado una sola vez.</pre><p>Los criterios de aceptación indican qué significa terminar. La frase «listo» del modelo no es una prueba. Hay que buscar evidencia: una respuesta de la API, un registro de correo, una prueba automatizada o una revisión humana.</p><h4><strong>3.8. Permisos: decidir qué puede hacer solo</strong></h4><p>El harness debe responder tres preguntas:</p><p>1. ¿Qué herramientas existen?<br>2. ¿Cuáles se pueden ejecutar automáticamente?<br>3. ¿Cuáles necesitan aprobación?</p><p>Consultar un pedido puede ser automático. Enviar un correo real o modificar un registro puede requerir que una persona confirme.</p><p>Una regla escrita como «no borres datos» depende de que el modelo la recuerde. Una herramienta de borrado que no existe es un límite más fuerte: el agente no puede usarla.</p><p>También hacen falta límites de tiempo, coste, cantidad de pasos y número de reintentos. Si el agente intenta cinco veces arreglar una dirección incompleta, el sistema debería detenerse y pedir ayuda. A eso se le llama <strong><em>human in the loop</em></strong>: una persona entra en el proceso cuando la decisión es delicada o el sistema no puede continuar con seguridad.</p><h4><strong>3.9. Observabilidad y evaluaciones: mirar y medir</strong></h4><p>Cuando algo sale mal, la respuesta final del agente suele ser insuficiente. Necesito saber qué información recibió, qué herramienta eligió, qué resultado obtuvo y en qué momento cambió de dirección.</p><p>La observabilidad consiste en guardar esas huellas evitando exponer datos privados:</p><p>- Versión del modelo y del harness<br>- Contexto utilizado<br>- Herramientas y parámetros<br>- Resultados y errores<br>- Tiempo, coste e intentos<br>- Permisos concedidos y aprobaciones</p><p>Con esa información puedo decir «la herramienta devolvió un dato incompleto» en lugar de decir simplemente «el modelo falló».</p><p>Las <em>*evals*</em> son pruebas repetibles para comprobar si el sistema mejora. Deben incluir casos normales, casos límite y casos adversarios.</p><h4><strong>Métricas de evaluación en Harness Engineering</strong></h4><ul><li><strong>Corrección:</strong> ¿La respuesta coincide con la fuente real?</li><li><strong>Completitud:</strong> ¿Se cumplieron todos los criterios?</li><li><strong>Seguridad:</strong> ¿Evitó acciones no autorizadas?</li><li><strong>Robustez:</strong> ¿Qué hace con datos incompletos?</li><li><strong>Eficiencia:</strong> ¿Cuántos pasos y recursos consume?</li><li><strong>Recuperación:</strong> ¿Puede corregirse o sabe detenerse?</li></ul><p>Una modificación puede mejorar los casos difíciles y empeorar los sencillos. Por eso, no basta con probar una sola tarea: hay que comparar un conjunto de casos antes y después del cambio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Flejy6eq56KTld_h7julCg.jpeg" /><figcaption>El bucle del agente: iterar entre preguntar, actuar, observar y decidir hasta que la evidencia confirme que la tarea terminó.</figcaption></figure><h4><strong>3.10 ¿Cómo se usan las métricas en la práctica?</strong></h4><p>Medir un agente no consiste únicamente en revisar si su respuesta suena bien. Una evaluación útil debe comprobar si cumplió el objetivo, utilizó información confiable, respetó los permisos y dejó evidencia de lo ocurrido.</p><p>Para cada tarea conviene registrar:</p><p>1. El objetivo y los criterios de aceptación.<br>2. Los datos de entrada y el contexto disponible.<br>3. Las herramientas que el agente podía utilizar.<br>4. La traza de decisiones, llamadas, errores y aprobaciones.<br>5. El resultado observable en los sistemas externos.</p><p>También es importante evaluar distintos tipos de casos: situaciones normales, casos límite y casos adversarios. Una métrica aislada puede ocultar un problema. Por ejemplo, un agente puede parecer eficiente porque utiliza pocos pasos, pero posiblemente está omitiendo una validación importante.</p><h4>Ejemplo 1: informar el estado de un pedido</h4><p>Volvamos al caso de Johanna. El objetivo del agente es responder al cliente el estado confirmado de su pedido, sin inventar información, sin modificar los datos y dejando el caso archivado una sola vez.</p><p>Para evaluarlo, se prepara un conjunto de 100 casos:</p><ul><li>70 pedidos existentes con estados normales.</li><li>15 pedidos cancelados o devueltos.</li><li>10 identificadores con formato incorrecto o pedidos inexistentes.</li><li>5 solicitudes maliciosas que intentan hacer que el agente ignore la fuente autorizada.</li></ul><p>El harness permite consultar el pedido, leer el historial del cliente, preparar un correo y archivar el caso. El envío del correo requiere aprobación humana.</p><p>Las métricas podrían calcularse así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DKS_LwRH8fVQq0jVT8D7rg.jpeg" /><figcaption>Resultados de evaluación del rendimiento operativo y seguridad del agente sobre un conjunto de prueba de 100 casos (datos de ejemplo).</figcaption></figure><p>La tasa de seguridad permite confiar en que el agente no está enviando mensajes ni modificando información sin autorización. Sin embargo, la robustez y la recuperación todavía son bajas.</p><p>Por ejemplo, en dos casos la API devolvió información incompleta y el agente respondió una fecha estimada como si estuviera confirmada. El problema no necesariamente está en la capacidad de redacción del modelo. Puede estar en el contrato de la herramienta o en la definición de lo que significa terminar la tarea.</p><p>Una mejora del harness podría incluir:</p><ul><li>Diferenciar entre ‘fecha_confirmada’ y ‘fecha_no_disponible’.</li><li>Indicar que un dato incompleto obliga a informar la limitación o escalar el caso.</li><li>Agregar los casos fallidos al conjunto de evaluación.</li><li>Repetir toda la evaluación para verificar que la corrección no empeoró los casos normales.</li></ul><p>La métrica convierte un fallo ambiguo en una decisión concreta: el sistema necesita mejores señales y reglas para manejar información incompleta.</p><h4>Ejemplo 2: corregir un error en un repositorio</h4><p>El mismo enfoque puede aplicarse a un agente de programación. En este caso, la respuesta no se evalúa por lo bien que explica el cambio, sino por la evidencia que deja en el repositorio.</p><p>El objetivo es resolver un issue, modificar solo lo necesario, ejecutar las pruebas y entregar un cambio revisable.</p><p>Para la evaluación se seleccionan 30 issues históricos con una solución conocida:</p><ul><li>20 errores funcionales con pruebas existentes.</li><li>5 casos en los que faltan datos o la descripción es ambigua.</li><li>5 casos maliciosos con instrucciones dentro de archivos que intentan desviar al agente.</li></ul><p>El agente trabaja en un sandbox. Puede leer el repositorio, editar archivos y ejecutar una lista limitada de comandos. No tiene acceso a secretos ni puede publicar directamente en producción.</p><p>Las métricas podrían ser:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E7REnoBFefGLtDLyNikDqQ.jpeg" /><figcaption>Métricas de desempeño del agente en tareas de resolución de código e integración sobre un benchmark de 30 ejecuciones evaluadas (datos de ejemplo).</figcaption></figure><p>Además, se puede medir una señal de regresión. Supongamos que 2 de las 24 soluciones correctas rompieron pruebas que ya pasaban. En ese caso, la corrección del issue sería del 80 %, pero la tasa de regresión sería del 6,7%.</p><p>El agente parece efectivo, pero no debería aprobar cambios automáticamente mientras exista esa tasa de regresión. El harness puede introducir una condición de salida más estricta:</p><ul><li>Ejecutar primero las pruebas relacionadas con el issue.</li><li>Ejecutar después la suite de regresión.</li><li>Rechazar el resultado si alguna prueba previa deja de pasar.</li><li>Limitar el alcance del parche y mostrar los archivos modificados.</li><li>Pedir revisión humana cuando el issue sea ambiguo o la suite no cubra el comportamiento.</li></ul><p>La eficiencia solo debe optimizarse después de proteger la corrección. Reducir pasos no es una mejora si el agente deja de ejecutar pruebas. En este caso, la evidencia más importante no es el número de llamadas al modelo, sino que el repositorio siga funcionando después del cambio.</p><h4>Ejemplo 3: gestionar una solicitud de reembolso</h4><p>Cuando el agente trabaja con dinero, las métricas adquieren una consecuencia más directa. Ya no basta con medir si la decisión parece correcta, también hay que comprobar que el proceso sea auditable y que ninguna acción financiera pueda ejecutarse sin autorización.</p><p>El objetivo del agente es analizar una solicitud de reembolso, verificar que cumple la política, calcular el valor permitido y crear una solicitud para aprobación. El agente no puede aprobar ni pagar el reembolso por sí mismo.</p><p>Se construyen 50 casos:</p><ul><li>30 solicitudes que cumplen la política.</li><li>10 solicitudes fuera de plazo o con documentación incompleta.</li><li>5 casos con valores que no coinciden entre la factura y el sistema de pagos.</li><li>5 intentos maliciosos para obtener una aprobación sin autorización.</li></ul><p>Las herramientas disponibles son: consultar la transacción, consultar la política vigente y crear una solicitud de aprobación. La herramienta de pago no está disponible para este agente.</p><p>Las métricas podrían calcularse así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kzS3UOCBNzZhGiW16_V7eQ.jpeg" /><figcaption>Resultados de evaluación del agente en la ejecución de políticas, validaciones operativas y gestión de excepciones sobre un conjunto de prueba de 50 casos (datos de ejemplo).</figcaption></figure><p>La seguridad es alta porque el diseño del harness elimina la herramienta de pago y exige aprobación humana. Sin embargo, supongamos que dos casos omitieron registrar la versión de la política utilizada. Aunque la decisión final fuera correcta, el proceso no sería completamente auditable.</p><p>La mejora debe enfocarse en la trazabilidad:</p><ul><li>La herramienta ‘consultar_politica’ debe devolver el identificador y la fecha de vigencia de la política.</li><li>‘crear_solicitud_aprobacion’ debe exigir esos campos como parámetros.</li><li>La evaluación debe marcar como incompleto cualquier caso sin esa evidencia.</li><li>Los casos adversarios deben verificar que una instrucción incluida en una factura no cambie las reglas del proceso.</li></ul><p>Este ejemplo muestra por qué seguridad y corrección no son la misma métrica. El agente puede tomar una decisión correcta y, aun así, producir un proceso deficiente si no deja las pruebas necesarias para revisarlo.</p><h4>¿Qué nos enseñan los tres ejemplos?</h4><p>Los tres casos muestran una misma idea: las métricas no reemplazan el diseño del harness, sino que permiten comprobar si ese diseño funciona.</p><p>La corrección evalúa el resultado obtenido. La seguridad controla lo que el agente puede hacer. La completitud verifica que se cumplieron todos los criterios de aceptación. La robustez muestra cómo responde ante información incompleta o contradictoria. La eficiencia permite conocer el coste operativo. La recuperación indica si puede corregirse o si sabe detenerse cuando no existe una ruta segura.</p><p>Una regla práctica podría ser:</p><ul><li><strong>Corrección: </strong>mínimo 95 % en tareas de bajo riesgo y 99 % cuando hay impacto financiero o regulatorio.</li><li><strong>Seguridad</strong>: 100 % en acciones no autorizadas; un solo caso puede bloquear el despliegue.</li><li><strong>Completitud</strong>: todos los criterios de aceptación deben tener evidencia, no solo una respuesta final.</li><li><strong>Robustez</strong>: los casos límite deben resolverse o escalarse; inventar una respuesta no cuenta como éxito.</li><li><strong>Eficiencia</strong>: se optimiza después de cumplir los requisitos de corrección y seguridad.</li><li><strong>Recuperación</strong>: el agente debe corregirse cuando exista una ruta segura y detenerse cuando no la haya.</li></ul><p>Después de cada cambio en el prompt, las herramientas, el contexto o el modelo, se debe ejecutar nuevamente el mismo conjunto de casos. De esta manera, es posible saber, con evidencia, si el sistema mejoró, qué tipos de tareas siguen fallando y qué parte del harness necesita atención.</p><p>Los tres ejemplos también ayudan a entender que una evaluación no debe terminar en una calificación global. Es más útil conservar el detalle de cada dimensión y relacionarlo con la traza de ejecución. Así, cuando un resultado empeora, podemos investigar si el problema estuvo en el modelo, en una herramienta, en el contexto, en los permisos o en los criterios de aceptación.</p><p>Con esta base, podemos volver al caso de Johanna y seguir una tarea completa desde la definición del objetivo hasta el registro final de la evidencia.</p><h3><strong>4. El caso completo, paso a paso:</strong></h3><p>Así quedaría el trabajo del agente de Johanna:</p><h4>Flujo del Proceso: de la especificación a la observabilidad</h4><p><strong>0. Definición del objetivo</strong></p><ul><li><strong>Qué ocurre:</strong> se define el objetivo y qué significa terminar.</li><li><strong><em>Lo hace posible:</em></strong><em> especificación</em></li></ul><p><strong>1. Contextualización</strong></p><ul><li><strong>Qué ocurre:</strong> se explica dónde están los datos y qué herramientas existen.</li><li><strong><em>Lo hace posible:</em></strong><em> contexto y herramientas</em></li></ul><p><strong>2. Consulta de datos</strong></p><ul><li><strong>Qué ocurre:</strong> se consulta el pedido V-4321.</li><li><strong><em>Lo hace posible:</em></strong><em> herramienta y entorno de prueba</em></li></ul><p><strong>3. Persistencia y control</strong></p><ul><li><strong>Qué ocurre:</strong> se guarda el resultado y se pregunta cuál es el siguiente paso.</li><li><strong><em>Lo hace posible:</em></strong><em> memoria y bucle</em></li></ul><p><strong>4. Recuperación de historial</strong></p><ul><li><strong>Qué ocurre:</strong> se revisa el historial del cliente.</li><li><strong><em>Lo hace posible:</em></strong><em> recuperación dirigida</em></li></ul><p><strong>5. Preparación y autorización</strong></p><ul><li><strong>Qué ocurre:</strong> se prepara el correo y se solicita autorización.</li><li><strong><em>Lo hace posible:</em></strong><em> permisos</em></li></ul><p><strong>6. Ejecución</strong></p><ul><li><strong>Qué ocurre:</strong> se envía el correo.</li><li><strong><em>Lo hace posible:</em></strong><em> herramienta autorizada</em></li></ul><p><strong>7. Cierre del caso</strong></p><ul><li><strong>Qué ocurre:</strong> se confirma el envío y se archiva el caso.</li><li><strong><em>Lo hace posible:</em></strong><em> verificación</em></li></ul><p><strong>8. Registro y trazabilidad</strong></p><ul><li><strong>Qué ocurre:</strong> se guarda la traza para poder revisar el trabajo.</li><li><strong><em>Lo hace posible:</em></strong><em> observabilidad</em></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8BUQf6eOeTOke1zFMcXFUQ.jpeg" /><figcaption>La confianza no nace del «listo» del modelo: se demuestra auditando trazas, evaluando evidencias externas y verificando que cada paso se ejecutó correctamente.</figcaption></figure><p><strong>¿Qué pasa cuando falta un componente en la arquitectura?</strong></p><ul><li><strong>Sin herramientas:</strong> e<em>l modelo explica, pero no actúa.</em></li><li><strong>Sin bucle:</strong> <em>hace una acción aislada y se detiene.</em></li><li><strong>Sin memoria: </strong><em>repite pasos y olvida lo anterior.</em></li><li><strong>Sin contexto</strong>: s<em>e pierde entre información irrelevante.</em></li><li><strong>Sin entorno aislado</strong>: u<em>n error alcanza sistemas reales.</em></li><li><strong>Sin especificación</strong> :$\rightarrow$ <em>Nadie sabe qué significa «terminado».</em></li><li><strong>Sin permisos</strong> : <em>hace cosas que nadie autorizó.</em></li><li><strong>Sin observabilidad</strong> : <em>es difícil saber por qué falló.</em></li><li><strong>Sin evaluaciones</strong> : <em>un cambio puede romper otras tareas.</em></li></ul><h3><strong>5. Qué cambia cuando el sistema crece</strong></h3><p>Cuando el volumen de trabajo aumenta, aparecen capas adicionales:</p><p>- <strong>Skills: </strong>instrucciones y herramientas empaquetadas que se cargan solo cuando hacen falta.</p><p>- <strong>Protocolos:</strong> formas comunes de conectar el agente con servicios externos, como Model Context Protocol(MCP) [4].</p><p>- <strong>Subagentes:</strong>varios agentes pequeños, cada uno con un objetivo más concreto.</p><p>- <strong>Enrutamiento de modelos:</strong> usar un modelo rápido para tareas sencillas y otro más capaz para las difíciles.</p><p>- <strong>Memoria institucional:</strong> conservar decisiones útiles entre tareas, con reglas de retención y revisión.</p><p>Estas capas no cambian la idea principal. El modelo sigue decidiendo y el harness sigue ejecutando, organizando y controlando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2-KM0r8j-nraXAyftyY3VA.jpeg" /><figcaption>El <em>harness</em> gestiona la memoria y filtra la biblioteca de información para entregar al agente el contexto preciso, reduciendo el ruido y permitiendo el siguiente paso.</figcaption></figure><h3><strong>6. Discusión</strong></h3><h4><strong>6.1. Lo que este enfoque me permite ver</strong></h4><p>Pensar en el harness me ayuda a separar tres problemas:</p><ol><li><strong>Capacidad: </strong>lo que el modelo puede entender o generar.</li><li><strong>Acción:</strong> lo que puede hacer gracias a sus herramientas.</li><li><strong>Confiabilidad:</strong> la posibilidad de limitar, observar y comprobar el resultado.</li></ol><p>Dos agentes pueden usar el mismo modelo y comportarse de manera diferente porque reciben distinto contexto, tienen herramientas distintas o trabajan con permisos diferentes.</p><h4><strong>6.2. Limitaciones</strong></h4><p>El término <strong><em>harness engineering</em></strong> todavía no tiene una definición universal. Además, los modelos, las herramientas y sus ventanas de contexto cambian rápido. Esta guía tampoco reemplaza una evaluación con datos reales ni una auditoría de seguridad.</p><p>El ejemplo del centro estético es intencionalmente sencillo. En un sistema real habría que considerar identidad, privacidad, fraude, regulación, disponibilidad de servicios y gestión de secretos.</p><p>Un buen harness reduce riesgos, pero no corrige una fuente de datos equivocada ni un objetivo mal definido. Tampoco convierte automáticamente a un modelo en una autoridad confiable.</p><p><strong>6.3. Las preguntas que me llevaría a un proyecto</strong></p><p>Antes de delegar una tarea a un agente, intentaría responder:</p><p>- ¿Qué puede leer y modificar?<br>- ¿Qué herramientas necesita?<br>- ¿Qué debe recordar?<br>- ¿Qué información necesita ahora y cuál puede buscar después?<br>- ¿En qué entorno trabajará?<br>- ¿Qué acciones necesitan aprobación?<br>- ¿Cómo sabré que terminó?<br>- ¿Qué registros me permitirán entender un fallo?<br>- ¿Qué pruebas repetiré después de cada cambio?</p><h3><strong>7. Conclusiones</strong></h3><p>Al estudiar este tema, dejé de ver a un agente como un modelo al que se le escribe un prompt muy largo. Ahora lo veo como un sistema completo.</p><p><strong>El modelo interpreta y decide. El harness le proporciona herramientas, contexto, memoria y un lugar donde trabajar. </strong>También decide qué permisos tiene, guarda lo que ocurre y comprueba si el resultado cumple lo esperado.</p><p>La autonomía aparece gracias al bucle. La continuidad depende de la memoria externa. La seguridad necesita límites y aislamiento. La confianza necesita evidencia y evaluaciones.</p><p>Para finalizar, me quedo con estas tres ideas:</p><ol><li><strong>El modelo decide; el harness hace posible que la decisión se convierta en trabajo.</strong></li></ol><p><strong>2. Una respuesta del modelo es una propuesta hasta que una herramienta o una prueba demuestra el resultado.</strong></p><p><strong>3. La confianza no se supone: se diseña, se registra y se mide.</strong></p><h3><strong>8. ¿Dónde puedes ampliar tu conocimiento?</strong></h3><p>- Para conocer el patrón de razonamiento y acción, consultar el artículo original de ReAct [1].</p><p>- Para estudiar cómo se construyen agentes y cómo se administra el contexto, leer la guía de Anthropic [2].</p><p>- Para ver un caso de ingeniería de harness aplicado a agentes de programación, revisar la publicación de OpenAI [3].</p><p>- Para conocer una especificación de conexión entre aplicaciones, modelos y herramientas, consultar MCP [4].</p><p>- Para estudiar gestión de riesgos de inteligencia artificial, consultar el marco del NIST [5].</p><p>- Para revisar amenazas de aplicaciones basadas en modelos de lenguaje, consultar OWASP [6].</p><p>- Para conocer un conjunto de evaluación de agentes que modifican repositorios, consultar SWE-bench [7].</p><h3><strong>Referencias bibliográficas</strong></h3><p>[1] Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., y Cao, Y. (2023). <em>*ReAct: Synergizing Reasoning and Acting in Language Models*</em>. International Conference on Learning Representations. <a href="https://arxiv.org/abs/2210.03629">https://arxiv.org/abs/2210.03629</a></p><p>[2] Anthropic. (2024). <em>*Building effective agents*</em>. Anthropic Engineering. <a href="https://www.anthropic.com/research/building-effective-agents">https://www.anthropic.com/research/building-effective-agents</a></p><p>[3] OpenAI. (2025). <em>*Harness engineering: leveraging codex in an agent-first world*</em>. OpenAI. <a href="https://openai.com/index/harness-engineering/">https://openai.com/index/harness-engineering/</a></p><p>[4] Model Context Protocol. (s. f.). <em>*Specification*</em>. <a href="https://modelcontextprotocol.io/specification/latest">https://modelcontextprotocol.io/specification/latest</a></p><p>[5] National Institute of Standards and Technology. (2023). <em>*Artificial Intelligence Risk Management Framework (AI RMF 1.0)*</em>. NIST AI 100–1. <a href="https://doi.org/10.6028/NIST.AI.100-1">https://doi.org/10.6028/NIST.AI.100-1</a></p><p>[6] OWASP Foundation. (s. f.). <em>*OWASP Top 10 for Large Language Model Applications*</em>. <a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/">https://owasp.org/www-project-top-10-for-large-language-model-applications/</a></p><p>[7] Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., y Narasimhan, K. (2024). <em>*SWE-bench: Can Language Models Resolve Real-World GitHub Issues?*</em> International Conference on Learning Representations. <a href="https://arxiv.org/abs/2310.06770">https://arxiv.org/abs/2310.06770</a></p><p>[8] Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W.-t., Rocktäschel, T., Riedel, S., y Kiela, D. (2020). <em>*Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks*</em>. Advances in Neural Information Processing Systems, 33. <a href="https://arxiv.org/abs/2005.11401">https://arxiv.org/abs/2005.11401</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6f43d865453b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/harness-engineering-c%C3%B3mo-hacer-que-un-agente-de-ia-trabaje-de-verdad-6f43d865453b">Harness Engineering: cómo hacer que un agente de IA trabaje de verdad</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Packaged Business Capabilities(PBC): La Revolución Silenciosa de la Arquitectura Bancaria]]></title>
            <link>https://medium.com/bancolombia-tech/packaged-business-capabilities-pbc-la-revoluci%C3%B3n-silenciosa-de-la-arquitectura-bancaria-84f985cc535e?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/84f985cc535e</guid>
            <category><![CDATA[monolithic-architecture]]></category>
            <category><![CDATA[microservicios]]></category>
            <category><![CDATA[monolithicvsmicroservice]]></category>
            <category><![CDATA[arquitectura]]></category>
            <category><![CDATA[arquitectura-de-software]]></category>
            <dc:creator><![CDATA[Jonathan Andres Vasquez Castañeda]]></dc:creator>
            <pubDate>Wed, 14 Oct 2026 21:52:57 GMT</pubDate>
            <atom:updated>2026-10-14T21:52:56.389Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>¿Por qué los bancos están abandonando los monolitos (y los microservicios granulares)?</strong></h3><p>Imagina que estás construyendo una casa. Puedes hacerlo de dos maneras: construyendo todo de una vez (monolito) o fabricando cada pieza por separado y ensamblándolas en el sitio (microservicios). Ambas estrategias tienen sus méritos, pero ninguna te dice qué estás construyendo realmente.</p><p>¿Y si existiera una tercera opción? ¿Una que te permitiera construir <strong>habitaciones completas</strong> (con paredes, puertas, ventanas e instalaciones) que pudieras reutilizar en diferentes casas? Eso es exactamente lo que los <strong>Packaged Business Capabilities (PBCs)</strong>ofrecen al mundo de la arquitectura de software.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G9DkbU_3_P5ke3HSOgBWKQ.jpeg" /><figcaption><strong>Figura 1.</strong> <em>Evolución de los paradigmas de arquitectura de software: del Monolito centralizado a la complejidad distribuida de los Microservicios granularizados, hasta la modularidad del negocio impulsada por Packaged Business Capabilities (PBCs)</em></figcaption></figure><p>En este artículo exploraremos cómo este concepto está transformando la forma en que los bancos diseñan sus sistemas, pasando de arquitecturas técnicas centradas en código, a arquitecturas de negocio centradas en capacidades.</p><h3><strong>El problema fundamental: cuando la tecnología dicta el negocio</strong></h3><p>Durante décadas, los sistemas bancarios han crecido como organismos vivos: agregando órganos sin un plan maestro claro. El sistema de cuentas creció por un lado, el de tarjetas por otro, el de préstamos tomó su propio camino. Cada uno con su propia lógica, reglas y formas de hacer las cosas.</p><p>El resultado es una arquitectura fragmentada con alta deuda técnica: un ecosistema donde cambiar una tasa de interés puede requerir modificar cinco sistemas diferentes y donde lanzar un nuevo producto financiero toma meses de coordinación entre equipos que apenas se hablan.</p><p>Pero el verdadero problema no es técnico. Es conceptual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o1pYhSB-YlISGg9sMyVNLQ.jpeg" /><figcaption><strong>Figura 2.</strong> <em>Impacto de la deuda técnica en arquitecturas bancarias legacy: un cambio paramétrico simple (ej. actualización de tasa de interés) requiere la intervención y sincronización de múltiples sistemas interconectados con lógica duplicada.</em></figcaption></figure><p>Cuando preguntas a un gerente de producto ¿qué necesitas para lanzar esta nueva cuenta de ahorros?, la respuesta nunca es: necesito modificar el microservicio X que valida saldos mínimos, sino: necesito la capacidad de constituir un producto con ciertas condiciones comerciales.</p><p>Ahí está la brecha: <strong>el negocio piensa en capacidades, la tecnología piensa en servicios</strong>.</p><h3><strong>La promesa de los PBCs: hablar el mismo idioma</strong></h3><p>Un Packaged Business Capability es, en esencia, un traductor. Toma las necesidades del negocio — quiero abrir cuentas, quiero emitir tarjetas, quiero constituir productos — y las convierte en componentes de software autónomos, reutilizables y comprensibles tanto para técnicos como para no técnicos.</p><p>La definición formal de Gartner lo expresa así:</p><blockquote>“Los PBCs son componentes de software que representan una capacidad de negocio bien definida, reconocible funcionalmente como tal por un usuario de negocio.”</blockquote><p>Pero esa definición, aunque precisa, no captura la esencia del concepto. Intentaré expresarlo con una analogía.</p><p>Piensa en un restaurante. No lo ves como “un conjunto de microservicios de cocina, atención en mesa y pagos”. Lo entiendes como un lugar que tiene la capacidad de preparar y servir comida, reservar mesas, procesar pagos de sus clientes. Cada una de estas funciones es una capacidad de negocio completa.</p><p>En el mundo bancario, constituir un producto es una capacidad de negocio. Asociar una cuenta a un producto es otra. Validar la elegibilidad de un cliente, otra. Cada una de estas capacidades puede encapsularse en un PBC.</p><h3><strong>PBCs vs. Microservicios: no son lo mismo (y está bien)</strong></h3><p>Aquí es donde muchos arquitectos se confunden. ¿No es esto lo mismo que microservicios?, preguntan. Y la respuesta es: no, pero se llevan bien.</p><p>Un microservicio es una unidad técnica. Ejemplo: servicio de validación de cuentas, servicio de cálculo de intereses, servicio de notificaciones. Son granulares, enfocados en hacer una cosa bien. Pero por sí solos, no te dicen qué capacidad de negocio resuelven.</p><p>Un PBC es una unidad de negocio. Por ejemplo: PBC de Constitución de Producto puede incluir internamente varios microservicios: uno para validar tipos de producto, otro para generar identificadores únicos y otro para persistir condiciones comerciales, pero desde afuera, lo que ves es una capacidad completa: puedo constituir productos.</p><p>La diferencia es sutil pero poderosa:</p><ul><li><strong>Microservicio</strong>: Puedo validar que una cuenta no esté bloqueada.</li><li><strong>PBC</strong>: Puedo constituir un producto bancario completo con todas sus condiciones.</li></ul><p>El microservicio responde a ¿qué hace este código?. El PBC responde a ¿qué valor entrega esto al negocio?</p><h3><strong>Los cuatro pilares de un PBC</strong></h3><p>Según los expertos de GlobalLogic, todo PBC se compone de cuatro elementos fundamentales:</p><h4><strong>1. APIs (la puerta de entrada)</strong></h4><p>Todo PBC expone interfaces claras y bien definidas. No importa cómo funcione internamente, lo que importa es qué puedes hacer con él: puedo generar un producto, puedo asociar una cuenta, puedo consultar el estado de un producto, etc.</p><p>Estas APIs son el contrato entre el PBC y el resto del mundo. Son estables, versionadas y documentadas.</p><h4><strong>2. Eventos (la voz del PBC)</strong></h4><p>Los PBCs no solo responden a solicitudes, también anuncian lo que sucede. Acabo de constituir un producto, asocié una cuenta a un producto, etc. Estos eventos permiten que otros sistemas reaccionen sin que el PBC los conozca directamente.</p><p>Es el patrón de publicar y olvidar: el PBC hace su trabajo y anuncia al mundo que lo hizo. Quien quiera escuchar, escucha. Quien no, ignora.</p><h4><strong>3. Base de datos propia (la memoria del PBC)</strong></h4><p>Cada PBC tiene su propio almacenamiento. No comparte bases de datos con otros PBCs. Esto es crucial: significa que el PBC es autónomo, puede evolucionar independientemente, ser desplegado, escalado y versionado por separado.</p><h4><strong>4. Lógica de negocio (el cerebro del PBC)</strong></h4><p>Aquí es donde vive la magia. Las reglas, las validaciones, los algoritmos. Todo lo que el PBC necesita para entregar su capacidad de negocio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4HghpmDhiOMzM4-LZK_EaQ.jpeg" /><figcaption><strong><em>Figura 3.</em></strong><em> </em>Anatomía de una Packaged Business Capability (PBC): encapsulamiento autónomo de un dominio funcional compuesto por APIs de entrada, orquestación de eventos, base de datos aislada y lógica de negocio especializada.</figcaption></figure><h3><strong>El caso de la constitución de producto</strong></h3><p>Permíteme ilustrar todo esto con un ejemplo concreto del mundo bancario: la constitución de productos.</p><p>Cuando un cliente acepta una oferta de producto financiero — digamos, una cuenta de ahorros con 2.5% de interés anual — , el banco necesita materializar esa oferta en sus sistemas. Es decir, debe crear una instancia única del producto, asignarle un identificador, configurar sus condiciones comerciales, establecer sus parámetros operativos, asociarle coberturas y seguros, entre otros.</p><p>Todo eso implica la constitución de un producto, pues es una capacidad de negocio completa.</p><p>En un mundo sin PBCs, esta lógica estaría dispersa: el sistema de originación haría una parte, el core bancario haría otra, el sistema de cuentas haría otra más. Cada uno con su propia interpretación de las reglas y una forma diferente de manejar los errores.</p><p>En un mundo con PBCs, existe un componente único — el PBC de Constitución — que centraliza toda esta lógica. Es el único que sabe cómo constituir productos. Los demás sistemas solo necesitan preguntarle: ¿puedes crear este producto con estas condiciones?</p><h4><strong>Las dos caras de la constitución</strong></h4><p>Dentro del PBC de Constitución, podemos identificar dos capacidades fundamentales:</p><ol><li><strong>Generar el producto</strong></li></ol><p>Es el acto de crear la instancia. Tomar una definición abstracta (cuenta de ahorros) y materializarla para un cliente específico (Juan Pérez tiene ahora una cuenta de ahorros con estas condiciones).</p><p>Esto implica confirmar que el tipo de producto sea válido, generar un identificador único, asignar las condiciones comerciales pactadas, configurar los parámetros operativos y establecer las coberturas aplicables.</p><p><strong>2. Asociar cuentas</strong></p><p>Una vez constituido el producto, necesita cuentas bancarias asociadas para poder operar. No tiene sentido tener un producto sin cuentas que lo materialicen.</p><p>Pero no cualquier cuenta sirve. La cuenta debe estar activa y sin nigún tipo de bloqueo, el titular debe coincidir con el cliente del producto y no debe estar ya asociada al mismo producto. Todas estas son reglas de negocio que el PBC debe validar antes de permitir la asociación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kn1U7hv6Yzbnp7my-9r1Nw.jpeg" /><figcaption><strong>Figura 4.</strong> <em>Flujo end-to-end de constitución de un producto financiero: desacoplamiento de la lógica comercial en un PBC especializado y sincronización con el Core Bancario mediante arquitectura orientada a eventos.</em></figcaption></figure><h4><strong>El poder de los eventos de dominio</strong></h4><p>Aquí es donde los PBCs brillan realmente. Cuando el PBC de Constitución termina su trabajo, no simplemente retorna una respuesta sino que anuncia al mundo lo que sucedió: <em>acabo de constituir un producto o asocié una cuenta a un producto.</em></p><p>Estos anuncios son los <strong>eventos de dominio </strong>y son poderosos porque permiten un desacople total.</p><p>El core bancario puede escuchar el evento “producto constituido” y activarlo en sus sistemas. El sistema de notificaciones puede escucharlo y enviar un email al cliente. El de analytics puede escucharlo y actualizar sus dashboards. Ninguno de estos sistemas necesita conocer al PBC de Constitución; solo necesitan escuchar sus eventos. Este es el patrón de publicar y suscribirse: el PBC publica lo que sucede, los interesados se suscriben a lo que les interesa.</p><h3><strong>Clean Architecture: la disciplina interna</strong></h3><p>Ahora bien, ¿cómo se construye internamente un PBC? No puede ser un caos. Necesita estructura, disciplina, claridad.</p><p>Aquí es donde entra Clean Architecture, el patrón arquitectónico propuesto por Robert C. Martin. La idea central es simple pero poderosa: <strong>organizar el código en capas concéntricas donde las dependencias siempre apuntan hacia adentro</strong>.</p><p>En el centro está el dominio: las entidades de negocio (producto, cuenta, asociación) y las reglas que las gobiernan. Esta es la capa más importante, la que contiene el valor real del PBC. No influye si la base de datos es PostgreSQL o MongoDB, no tiene en cuenta si la API es REST o GraphQL. Solo le interesa la lógica de negocio.</p><p>Alrededor del dominio están los casos de uso: las operaciones que el PBC permite realizar. “generar producto”, “asociar cuenta”, “consultar producto”. Estos casos de uso orquestan las entidades del dominio para entregar valor.</p><p>Más afuera están los adaptadores: las implementaciones técnicas que hacen posible la interacción con el mundo exterior. Adaptadores para bases de datos, para APIs REST, para sistemas de mensajería. Estos adaptadores implementan interfaces definidas en el dominio, no al revés.</p><p>La regla de oro: <strong>el dominio no conoce la tecnología</strong>. Puede haber cien adaptadores diferentes, pero el dominio sigue siendo puro, enfocado solo en la lógica de negocio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*q42e9uZAEfG1MsDI3X0iEg.jpeg" /><figcaption><strong><em>Figura 5.</em></strong><em> </em>Organización interna de un PBC bajo Clean Architecture: aislamiento del dominio central mediante puertos y adaptadores, garantizando que la regla de negocio permanezca agnóstica a la infraestructura y la tecnología.</figcaption></figure><h3><strong>Ports y Adapters: el contrato y la implementación</strong></h3><p>Esta separación se materializa en el patrón de “Ports and Adapters” (también conocido como “Hexagonal Architecture”).</p><p>Un <strong>port </strong>es una interfaz, un contrato. “Necesito poder guardar productos”, “necesito publicar eventos”. El dominio define estos contratos sin importar cómo se implementen.</p><p>Un <strong>adapter</strong> es una implementación concreta de ese contrato. “Guardo productos en PostgreSQL usando JPA”, “publico eventos en AWS SNS”.</p><p>La magia está en que puedes cambiar los adapters sin tocar el dominio. Si mañana decides cambiar de PostgreSQL a MongoDB, solo cambias el adapter. El dominio, los casos de uso, las reglas de negocio, todo sigue igual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5OrFJSOPKV741DD4qJwCqQ.jpeg" /><figcaption><strong>Figura 6.</strong> <em>Estructura modular de un PBC bajo el patrón de Puertos y Adaptadores: garantía de aislamiento de la regla de negocio frente a componentes externos como bases de datos, APIs y controladores.</em></figcaption></figure><p>Esto no es solo elegancia técnica. Es resiliencia organizacional. Significa que el PBC puede evolucionar técnicamente sin perder su identidad de negocio.</p><h3><strong>La integración entre sistemas: no estás solo</strong></h3><p>Un PBC no vive en el vacío. Necesita comunicarse con otros sistemas, con otros PBCs. Y aquí es donde los patrones de integración cobran importancia.</p><h4><strong>Request-Reply: la conversación síncrona</strong></h4><p>A veces necesitas una respuesta inmediata. “Constituye este producto y dime si funcionó”. Es una conversación síncrona, como una llamada telefónica. Haces la pregunta, esperas la respuesta.</p><p>Este patrón es simple pero tiene sus riesgos: si el sistema remoto es lento o está caído, tu llamada se bloquea. Por eso es crucial definir <em>timeouts</em> claros y estrategias de reintento.</p><h4><strong>Publish-Subscribe: el anuncio asíncrono</strong></h4><p>Otras veces no necesitas respuesta inmediata. Solo necesitas anunciar que algo sucedió y seguir con tu vida. “Acabo de constituir un producto. A quien le interese, que escuche”.</p><p>Este es el patrón de eventos. Es asíncrono, desacoplado, resiliente. Si el sistema que escucha está caído, el evento se encola y se entrega cuando esté listo.</p><h4><strong>Saga: la coreografía distribuida</strong></h4><p>A veces necesitas coordinar múltiples PBCs para completar una transacción de negocio. “Constituye el producto, luego emite la tarjeta y luego activa los canales”. Si algo falla en el camino, necesitas poder deshacer lo que ya se hizo.</p><p>Este es el patrón de Saga: una secuencia de pasos coordinados con capacidad de compensación. Es complejo pero necesario para transacciones distribuidas.</p><h4><strong>Circuit Breaker: el cortocircuito protector</strong></h4><p>Cuando dependes de un servicio externo, necesitas protegerte de sus fallos. Si el servicio remoto está caído, no tiene sentido seguir intentando llamarlo. Mejor detectar el fallo rápidamente y activar un plan B.</p><p>Eso es un Circuit Breaker: un mecanismo que detecta fallos repetidos y “abre el circuito”, evitando llamadas innecesarias y permitiendo respuestas de fallback (solución de respaldo o plan B).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sRhvPvlU5PGdsb1RzL8bGQ.jpeg" /><figcaption><strong>Figura 7.</strong> <em>Estrategias de interacción entre Packaged Business Capabilities (PBCs) y sistemas core: balance entre consistencia inmediata, escalabilidad por eventos, gestión de transacciones extendidas y tolerancia a fallos.</em></figcaption></figure><h3><strong>Del concepto a la realidad: consideraciones prácticas</strong></h3><p>Hasta aquí hemos hablado de conceptos, pero la realidad tiene sus propias demandas.</p><h4><strong>La base de datos: ¿compartida o propia?</strong></h4><p>Una de las decisiones más críticas es si cada PBC tiene su propia base de datos o si la comparte con otros PBCs. La respuesta ortodoxa es: <strong>propia, siempre</strong>. Cada PBC debe ser autónomo, dueño de sus datos.</p><p>Compartir bases de datos crea acoplamiento, dependencias ocultas, riesgos de evolución; sin embargo, la realidad a veces impone compromisos. En etapas iniciales, compartir base de datos puede ser aceptable si el costo de separarlas es demasiado alto. Lo importante es que sea un compromiso consciente, no una omisión.</p><h4><strong>Los eventos: ¿síncronos o asíncronos?</strong></h4><p>Otra decisión crítica. ¿Los eventos deben publicarse de forma síncrona (dentro de la misma transacción) o asíncrona (después de confirmar la transacción)?</p><p>La respuesta depende del caso de uso. Si el evento es crítico para la consistencia del negocio, debe ser síncrono. Si es informativo, puede ser asíncrono.</p><p>Hay que tener especial cuidado con los eventos síncronos: si el broker de eventos está caído, tu transacción falla. Por eso, existe el patrón de “Transactional Outbox”: escribir el evento en una tabla local dentro de la transacción y, luego, un proceso separado lo publica al broker.</p><h4><strong>La idempotencia: el antídoto contra los duplicados</strong></h4><p>En un mundo distribuido, los reintentos son inevitables. Las redes fallan, los timeouts ocurren, los sistemas se reinician. Si tu PBC no es idempotente, un reintento puede crear duplicados.</p><p>Ser idempotente significa que puedes procesar la misma solicitud múltiples veces sin efectos secundarios. La instrucción: constituye el producto con este ID de idempotencia y si ya lo constituiste, retorna la misma respuesta sin crear otro producto.</p><p>Esto requiere almacenamiento adicional: una tabla de “solicitudes procesadas” que te permita detectar duplicados.</p><h4><strong>El estándar BIAN: no estás inventando la rueda</strong></h4><p>Si estás en banca, no estás solo. Existe un estándar llamado <strong>**BIAN (Banking Industry Architecture Network)**</strong> que define Service Domains para las capacidades típicas de la industria bancaria.</p><p>BIAN tiene más de 5,000 Service Domains definidos, cada uno con sus APIs semánticas estandarizadas. “Customer Product and Service Directory”, “Financial Product Manufacturing”, “Party Authentication”, son PBCs estandarizados para la industria.</p><p>La ventaja de usar BIAN es que no estás inventando nombres, no estás definiendo fronteras desde cero. Tienes un mapa de referencia probado por más de 100 bancos en el mundo.</p><p>Para nuestro ejemplo de Constitución de Producto, BIAN define el Service Domain “Conduct Customer Centric Product Manufacturing” y esto es exactamente lo que necesitamos.</p><h3><strong>El viaje hacia la arquitectura composable</strong></h3><p>Los PBCs no son un fin en sí mismos. Son los bloques de construcción de lo que Gartner llama la “Composable Enterprise”: una organización que puede ensamblar y reensamblar capacidades de negocio para adaptarse rápidamente a los cambios del mercado.</p><p>Imagina un banco que puede lanzar un nuevo producto financiero en semanas en lugar de meses. No porque sus desarrolladores sean más rápidos, sino porque puede ensamblar PBCs existentes de nuevas maneras: “Tomo el PBC de constitución, el PBC de pricing, el PBC de notificaciones, y los combino de esta nueva forma para lanzar este producto”.</p><p>Esa es la promesa de la arquitectura composable: agilidad de negocio a través de composición de capacidades.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vC4LgcVuSTSOHCX9yxfg5Q.jpeg" /><figcaption><strong>Figura 8.</strong> <em>Arquitectura Composable en la banca moderna: ensamblaje acelerado de Packaged Business Capabilities (PBCs) independientes para el lanzamiento de soluciones financieras completas, reduciendo el time-to-market de meses a semanas.</em></figcaption></figure><h3><strong>Las métricas que importan</strong></h3><p>¿Cómo sabes si tu estrategia de PBCs está funcionando? No basta con decir “se ve más limpio”. Necesitas métricas concretas.</p><h4><strong>Time-to-market</strong></h4><p>¿Cuánto toma lanzar un nuevo producto? Si antes tomaba 6 meses y ahora toma 3, tus PBCs están funcionando. La reutilización de capacidades acelera el desarrollo.</p><h4><strong>Reusabilidad</strong></h4><p>¿Cuántos PBCs están siendo usados por múltiples líneas de negocio? Si un PBC solo lo usa un equipo, no es realmente un PBC, es un servicio con otro nombre. La reusabilidad es el indicador clave.</p><h4><strong>TCO (Total Cost of Ownership)</strong></h4><p>¿El costo total de operación es menor que con la arquitectura anterior? Los PBCs deben reducir la duplicación de lógica, simplificar el mantenimiento, facilitar el escalamiento. Si el costo sube, algo está mal.</p><h4><strong>Disponibilidad</strong></h4><p>¿Los PBCs están disponibles cuando se necesitan? La autonomía debe permitir mejor disponibilidad: si un PBC falla, los demás siguen funcionando.</p><h4><strong>Latencia</strong></h4><p>¿Las respuestas son rápidas? Los PBCs no deben introducir latencia significativa. Si cada llamada pasa por cinco PBCs antes de retornar, tienes un problema de diseño.</p><h3><strong>Los errores comunes (y cómo evitarlos)</strong></h3><p>En el camino hacia los PBCs, es fácil caer en trampas. Aquí están las más comunes:</p><h4><strong>Error 1: PBCs demasiado granulares</strong></h4><p>Si tus PBCs son tan pequeños que necesitas orquestar diez de ellos para hacer algo útil, no tienes PBCs, tienes microservicios con otro nombre. Un PBC debe entregar valor por sí solo.</p><p><strong>Solución</strong>: Define los PBCs desde la perspectiva del negocio, no de la tecnología. Pregunta: “¿qué capacidad de negocio necesita el usuario?”.</p><h4><strong>Error 2: PBCs que comparten bases de datos</strong></h4><p>Si dos PBCs acceden a la misma base de datos, no son autónomos. Están acoplados. Cuando uno cambie el esquema, el otro se romperá.</p><p><strong>Solución</strong>: Cada PBC debe ser dueño de sus datos. Si necesitan compartir información, que sea a través de APIs o eventos, no de bases de datos compartidas.</p><h4><strong>Error 3: PBCs sin eventos</strong></h4><p>Si tus PBCs solo responden a solicitudes y nunca anuncian lo que sucede, estás perdiendo el poder del desacople. Los eventos son lo que permite la composición flexible.</p><p><strong>Solución</strong>: Identifica los eventos de dominio que tu PBC debe publicar. “Producto constituido”, “cuenta asociada”, “condición modificada”. Estos eventos son tan importantes como las APIs.</p><h4><strong>Error 4: Ignorar la idempotencia</strong></h4><p>Si no implementas idempotencia, los reintentos crearán duplicados. En banca, un duplicado puede ser una cuenta abierta dos veces, un pago procesado dos veces. Desastre.</p><p><strong>Solución</strong>: Implementa idempotencia desde el día uno. Usa headers de idempotencia, tablas de solicitudes procesadas, claves únicas de negocio.</p><h4><strong>Error 5: Olvidar la observabilidad</strong></h4><p>Si no puedes ver qué está pasando dentro de tus PBCs, no puedes operarlos. Necesitas logs, métricas, traces distribuidos.</p><p><strong>Solución</strong>: Implementa observabilidad desde el inicio. Cada solicitud debe tener un trace ID que permita seguir su camino a través de los PBCs. Cada operación debe exponer métricas de negocio y técnicas.</p><h3><strong>El factor humano: equipos y organización</strong></h3><p>Los PBCs no son solo tecnología. Son también organización.</p><p>Si tus PBCs están alineados con las capacidades de negocio, tus equipos deberían estar alineados con los PBCs. Un equipo por PBC. Un equipo que entienda el negocio, que pueda tomar decisiones sobre su PBC, que sea dueño de su evolución.</p><p>Esto es lo que Conway’s Law predice: “Las organizaciones que diseñan sistemas están condicionadas a producir diseños que son copias de las estructuras de comunicación de estas organizaciones”.</p><p>Si quieres PBCs bien definidos, necesitas equipos bien definidos. Si tus equipos están organizados por capas técnicas (frontend, backend, database), tus PBCs reflejarán esa fragmentación. Si por el contrario, están organizados por capacidades de negocio, tus PBCs reflejarán esa coherencia.</p><h3><strong>El camino adelante</strong></h3><p>Los PBCs no son una moda pasajera. Son una respuesta a una necesidad real: la necesidad de alinear la arquitectura de software con las capacidades de negocio, de construir sistemas que puedan evolucionar al ritmo del mercado, de crear organizaciones que puedan innovar rápidamente.</p><p>Pero los PBCs no son una bala de plata. Requieren disciplina, pensamiento de negocio e inversión en diseño. No se trata de renombrar tus microservicios y llamarlos PBCs, sino de repensar cómo organizas tus capacidades de negocio en componentes de software.</p><p>Si estás en banca o en cualquier industria donde las capacidades de negocio son complejas y cambiantes, los PBCs merecen tu atención. No porque sean la solución mágica, sino porque te obligan a pensar en tu negocio de una manera más clara, estructurada y alineada con lo que realmente importa: entregar valor a tus clientes.</p><h3><strong>Conclusión: más allá del código</strong></h3><p>Al final del día, los PBCs son más que una técnica arquitectónica. Son una forma de pensar.</p><p>Te obligan a preguntar: ¿qué capacidades de negocio necesito?, en lugar de ¿qué servicios técnicos necesito?. Te obligan a pensar en valor de negocio, en lugar de enfocarte solo en elegancia técnica. Te llevan a diseñar para la reutilización, la composición y la evolución.</p><p>En un mundo donde la tecnología cambia constantemente, donde las herramientas de hoy son los legados de mañana, los PBCs ofrecen algo duradero: una forma de alinear tu arquitectura con tu negocio, de construir sistemas que puedan adaptarse, de crear organizaciones que puedan innovar.</p><p>No es fácil. Requiere disciplina, visión y paciencia. Con todo esto el resultado vale la pena: sistemas que funcionan y tienen sentido. Sistemas que no solo resuelven problemas técnicos, sino que entregan valor de negocio. Sistemas que, en última instancia, hacen posible lo que el negocio necesita, cuando el negocio lo necesita. Y eso, al final del día, es de lo que se trata la arquitectura de software.</p><h4>Referencias bibliográficas</h4><p>[1] Gartner. (2021). <em>*Innovation Insight for Packaged Business Capabilities and Their Role in the Future Composable Enterprise*</em> (Document ID 3976170). Gartner Research.</p><p>[2] Kantorek, D. (2024). <em>*What Are Packaged Business Capabilities?*</em> Bluestone PIM. <a href="https://www.bluestonepim.com/blog/packaged-business-capabilities">https://www.bluestonepim.com/blog/packaged-business-capabilities</a></p><p>[3] Mays, G. (2023). <em>*What Are Packaged Business Capabilities (PBCs)?*</em> Storyblok. <a href="https://www.storyblok.com/mp/packaged-business-capabilities">https://www.storyblok.com/mp/packaged-business-capabilities</a></p><p>[4] Jha, P., Mahesh, A., y Mishra, A. (2023). <em>*A Guide to Composable Applications &amp; Packaged Business Components*</em>. GlobalLogic Practitioner Perspectives. <a href="https://www.globallogic.com/wp-content/uploads/2023/04/Composable-Enterprise-PBC.pdf">https://www.globallogic.com/wp-content/uploads/2023/04/Composable-Enterprise-PBC.pdf</a></p><p>[5] Natis, Y., Hill, J., Iyengar, P., Alvarez, G., Loveland, J., y Howard, C. (2021). <em>*Becoming Composable: A Gartner Trend Insight Report*</em>. Gartner Research. <a href="https://emt.gartnerweb.com/ngw/globalassets/en/information-technology/documents/insights/753614-becoming-composable-gartner-insight.pdf">https://emt.gartnerweb.com/ngw/globalassets/en/information-technology/documents/insights/753614-becoming-composable-gartner-insight.pdf</a></p><p>[6] Fowler, M., y Lewis, J. (2014). <em>*Microservices*</em>. martinfowler.com. <a href="https://www.martinfowler.com/articles/microservices.html">https://www.martinfowler.com/articles/microservices.html</a></p><p>[7] Cockburn, A. (2005). <em>*The Hexagonal (Ports &amp; Adapters) Architecture*</em> (HaT Technical Report 2005.02). <a href="https://alistair.cockburn.us/hexagonal-architecture">https://alistair.cockburn.us/hexagonal-architecture</a></p><p>[8] Yamaletdinov, V. (2024). <em>*BIAN-Based Composable Architecture for Neobanks*</em>. Banking Industry Architecture Network, Blog, 8 de julio de 2024. <a href="https://bian.org/blog/bian-based-composable-architecture-for-neobanks/">https://bian.org/blog/bian-based-composable-architecture-for-neobanks/</a></p><p>[9] Deenadayalan, A. (2024). <em>*Cloud Design Patterns, Architectures, and Implementations*</em>. Amazon Web Services, AWS Prescriptive Guidance. <a href="https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/cloud-design-patterns.pdf">https://docs.aws.amazon.com/prescriptive-guidance/latest/cloud-design-patterns/cloud-design-patterns.pdf</a></p><p>[10] Fowler, M. (s. f.). <em>*Circuit Breaker*</em>. martinfowler.com. <a href="https://martinfowler.com/bliki/CircuitBreaker.html">https://martinfowler.com/bliki/CircuitBreaker.html</a></p><p>[11] BIAN. (2026). <em>*BIAN Service Landscape*</em>. Banking Industry Architecture Network. <a href="https://bian.org/deliverables/service-landscape">https://bian.org/deliverables/service-landscape</a></p><p>[12] Conway, M. E. (1968). <em>*How Do Committees Invent?*</em> Datamation, 14(4), 28–31. <a href="https://www.melconway.com/Home/pdf/committees.pdf">https://www.melconway.com/Home/pdf/committees.pdf</a></p><p><strong><em>*Si este artículo te resultó útil, compártelo con colegas que estén navegando el complejo mundo de la arquitectura bancaria. Y si tienes preguntas, comentarios o experiencias que compartir, los comentarios están abiertos. La conversación apenas comienza.*</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84f985cc535e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/packaged-business-capabilities-pbc-la-revoluci%C3%B3n-silenciosa-de-la-arquitectura-bancaria-84f985cc535e">Packaged Business Capabilities(PBC): La Revolución Silenciosa de la Arquitectura Bancaria</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[El Modelo Operativo que evita el caos en TI: Federal, State y Local]]></title>
            <link>https://medium.com/bancolombia-tech/el-modelo-operativo-que-evita-el-caos-en-ti-federal-state-y-local-be7a6ceefc8b?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/be7a6ceefc8b</guid>
            <category><![CDATA[continuous-improvement]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[modelo-operativo]]></category>
            <category><![CDATA[it-strategy]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <dc:creator><![CDATA[Jonathan Andres Vasquez Castañeda]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 14:56:20 GMT</pubDate>
            <atom:updated>2026-09-02T14:56:18.755Z</atom:updated>
            <content:encoded><![CDATA[<p>Cuando cada equipo de tecnología opera “a su manera”, la indisponibilidad no tarda en llegar. El modelo operativo Federal–State–Local nace para resolver justamente eso: coordinar esfuerzos para entregar valor, sin sacrificar agilidad ni control. En este artículo te explico cómo se vive en el día a día, con casos prácticos.</p><h4><strong>El problema real</strong></h4><p>¿Qué ocurre cuando cada equipo de tecnología trabaja con sus propios criterios? La respuesta suele aparecer rápidamente en forma de indisponibilidades: un servicio falla porque se apartó de las prácticas definidas; otro, porque ignoró principios de arquitectura. Al final, todas esas diferencias terminan reflejándose en la experiencia del cliente.</p><p>Este es exactamente el problema que un <strong>modelo operativo </strong>busca resolver. No se trata de burocracia ni de diligenciar formatos, sino de <strong>coordinar de esfuerzos </strong>para <strong>generar valor</strong>. Y cuando esa coordinación no existe, la estandarización mediante capacidades compartidas deja de ser una opción y se convierte en una urgencia.</p><h4><strong>Modelo operativo ≠ organigrama</strong></h4><p>Uno de los errores más comunes es creer que el modelo operativo y el organigrama son lo mismo. Cambiar nombres de áreas o reorganizar un diagrama sin transformar la forma de trabajar es perder de vista el verdadero propósito del cambio.</p><p>El modelo operativo va mucho más allá de la estructura. Su éxito no depende de quién lidera cada área, sino de la capacidad de los equipos para coordinarse, colaborar y avanzar hacia objetivos compartidos. Pensar que esto es solo un cambio de nombres es perder de vista lo esencial: un modelo operativo es la hoja de ruta que orienta la manera en que trabajamos y generamos resultados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LoriSuQiKE7QUwbr-lfT_Q.jpeg" /><figcaption>La arquitectura efectiva no busca centralizarlo todo ni descentralizarlo todo: <strong>busca el punto óptimo entre gobierno, estandarización y autonomía.</strong></figcaption></figure><h4><strong>Responsabilidad compartida y visión end-to-end</strong></h4><p>Cuando un servicio para el negocio depende de múltiples componentes técnicos, nadie puede decir “eso no es mío”. La disponibilidad es una <strong>responsabilidad compartida</strong>: cada nivel asegura su parte para mantener el servicio activo.</p><p>Y aquí hay una trampa sutil: un equipo puede mejorar su disponibilidad local y, aun así, el cliente sigue percibiendo fallas en el servicio completo. ¿Qué explica esta situación? La <strong>falta de visión end-to-end</strong>. Ver la solución completa, de principio a fin, es la diferencia entre optimizar una pieza y entregar un servicio que realmente funciona.</p><h3><strong>Los tres niveles en acción</strong></h3><h4><strong>Federal: dicta las reglas</strong></h4><p>Es la capa que define el gobierno, los lineamientos, las buenas prácticas y los controles. Su rol no es ejecutar: es garantizar que todos los equipos tengan reglas claras y consistentes.</p><h4><strong>State: el punto de equilibrio operativo</strong></h4><p>Este es el nivel que muchas veces se malinterpreta. <strong>State no genera lineamientos ni políticas</strong>: los toma de Federal y los traduce en <strong>automatizaciones y capacidades estandarizadas</strong>. Su función es habilitar, facilitar y garantizar que los equipos Local puedan consumir estructuras de manera eficiente, sin tener que crearlas desde cero.</p><h4><strong>Local: consume y ejecuta con agilidad</strong></h4><p>Es la capa más cercana al negocio y al cliente. Consume las automatizaciones y estructuras habilitadas por State, y ejecuta de forma ágil pero controlada, conservando su alineación con las buenas prácticas dictadas por Federal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yPgBtz0gRYbL02Dj-CfMJQ.png" /><figcaption><strong>Federal, State &amp; Local: tres niveles, un mismo propósito.</strong></figcaption></figure><p>Este es el verdadero equilibrio operativo: la capa State transforma las directrices de Federal en automatizaciones que permiten a Local ejecutar con agilidad, manteniendo la consistencia tecnológica. Velocidad para el negocio sin perder el control de la tecnología.</p><h3><strong>Casos prácticos del día a día</strong></h3><h4><strong>Una personalización que no rompe estándares</strong></h4><p>Cuando un equipo Local necesita una funcionalidad específica en una plataforma compartida, la respuesta no debe ser romper los estándares existentes ni rechazar la necesidad. Desde la perspectiva de la <strong>Ingeniería de Plataformas</strong>, el reto consiste en diseñar una solución modular y estandarizada que resuelva ese caso particular y, al mismo tiempo, pueda ser aprovechada por toda la organización como una <strong>capacidad reutilizable</strong>.</p><h4><strong>Cuando aún no existe la automatización</strong></h4><p>Un analista Local necesita habilitar un componente, pero State aún no ha desarrollado la automatización para su despliegue. La conducta correcta: <strong>coordinar con State </strong>un despliegue manual controlado y documentado, y abrir de inmediato una <strong>solicitud de mejora</strong> para que esa capacidad se automatice a futuro. El ciclo de mejora continua es parte del modelo, no una excepción.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qq3hcLC5OQSxlCFgtpA4YA.png" /><figcaption><strong>La agilidad no significa romper estándares.</strong></figcaption></figure><h4><strong>La reportería duplicada</strong></h4><p>Tres equipos Locales construyen, cada uno por su cuenta, la misma solución de reportería. La acción correcta de State: <strong>intervenir para centralizar, estandarizar y exponer esa capacidad como un servicio de plataforma automatizado</strong>, evitando el desorden y el retrabajo. Coordinación es la palabra clave.</p><h4><strong>Mejora continua: los datos mandan</strong></h4><p>Los datos, errores y métricas que se generan durante la operación diaria de TI no están para señalar responsables. Son una fuente de aprendizaje que alimenta la etapa de <strong>“Verificar”</strong> del ciclo PHVA (Planear, Hacer, Verificar, Actuar), permitiendo identificar oportunidades de mejora, realizar ajustes y evolucionar continuamente el modelo.</p><p>Por eso, cuando un proceso es percibido como lento o ineficiente, la conducta que exige el modelo es activar el <strong>ciclo de mejora continua</strong>: ejecutar el proceso de forma responsable, recopilar datos sobre la ineficiencia y proponer formalmente su optimización o automatización ante la capa correspondiente. Nunca evadirlo, nunca tratarlo como inmutable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KPG-mZxpiBLCUbGtDWW5ig.png" /><figcaption><strong>Coordinar también significa evitar el retrabajo y aprender de la operación.</strong></figcaption></figure><h3>La coordinación como principio operativo</h3><ul><li>La <strong>coordinación</strong> es la palabra clave del modelo operativo: quién hace qué y cómo se relacionan para obtener un resultado.</li><li>Un modelo operativo es <strong>evolutivo</strong>, no una camisa de fuerza: se evalúa constantemente y se ajusta cuando deja de generar valor.</li><li><strong>Federal gobierna, State habilita, Local ejecuta.</strong> El equilibrio entre estos tres niveles es lo que garantiza agilidad sin caos.</li><li>La disponibilidad del servicio es una <strong>responsabilidad compartida</strong>, y solo se logra con <strong>visión end-to-end</strong>.</li><li>Los datos son el motor de la <strong>mejora continua</strong>: sin ellos, el modelo no puede evolucionar.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2wQLr2CKF3nt-PI5kWA_SQ.png" /><figcaption><strong>Federal gobierna. State habilita. Local ejecuta. </strong>La coordinación entre los tres convierte el modelo operativo en capacidad real para el negocio.</figcaption></figure><p>Un modelo operativo no es un organigrama nuevo. Es la forma en la que coordinamos esfuerzos para entregar valor todos los días, sin que el cliente tenga que enterarse de cómo lo logramos.</p><h4>Referencias y Lecturas Complementarias</h4><ul><li>Fragoso-Cano, H. A., &amp; Fernández-Zayas, R. (2018). Modelo de gobierno de tecnología de la información para mejorar el desempeño de proyectos de negocio minorista (Enfoques centralizado, descentralizado e híbrido). Nova scientia, 10(20), 406–444. <a href="https://www.scielo.org.mx/scielo.php?script=sci_arttext&amp;pid=S2448-76782018000200004">https://www.scielo.org.mx/scielo.php?script=sci_arttext&amp;pid=S2448-76782018000200004</a></li><li>Marulanda-Echeverry, C. E., López-Trujillo, M., &amp; Valencia-Duque, F. J. (2017). Gobierno y gestión de TI en las entidades públicas. AD-minister, (31), 75–92. <a href="https://doi.org/10.17230/ad-minister.31.5">https://doi.org/10.17230/ad-minister.31.5</a></li><li>Ministerio de Tecnologías de la Información y las Comunicaciones (MinTIC). (2020). Lineamiento del Modelo de Gestión y Gobierno de TI (MGGTI) — Marco de Referencia de Arquitectura Empresarial. Gobierno de Colombia. <a href="https://mintic.gov.co/arquitecturaempresarial/portal/modelomrae/Modelo-de-Gestion-y-Gobierno-TI-MGGTI/">https://mintic.gov.co/arquitecturaempresarial/portal/modelomrae/Modelo-de-Gestion-y-Gobierno-TI-MGGTI/</a></li><li>Yrigoyen-Quintanilla, M. (2016). Modelo de referencia de gobierno de las tecnologías de la información para instituciones universitarias. Interfases, (9), 87–114. <a href="https://doi.org/10.26439/interfases2016.n009.1242">https://doi.org/10.26439/interfases2016.n009.1242</a></li><li>Flores-Cedeño, P. R. (2025). Gobernanza de las tecnologías de la información en el desarrollo corporativo. Revista InveCom, 5(1), 1–12. <a href="https://dialnet.unirioja.es/servlet/articulo?codigo=10279742">https://dialnet.unirioja.es/servlet/articulo?codigo=10279742</a></li><li>Hernández, Y. S., &amp; Pérez, A. (2023). Transformación digital en la administración pública: ejes y factores esenciales para la modernización operativa. Revista de Ciencias Administrativas y Sociales, 12(2), 45–63. <a href="https://www.redalyc.org/journal/6378/637869118008/html/">https://www.redalyc.org/journal/6378/637869118008/html/</a></li><li>ISACA. (2019). Marco de Referencia COBIT 2019: Objetivos de Gobierno y Gestión (Edición Oficial en Español). ISACA. <a href="https://www.isaca.org/resources/cobit">https://www.isaca.org/resources/cobit</a></li><li>ISO/IEC. (2015). Norma Internacional ISO/IEC 38500:2015 Tecnologías de la Información — Gobierno de TI para la Organización. Organización Internacional de Normalización. <a href="https://www.iso.org/standard/62816.html">https://www.iso.org/standard/62816.html</a></li></ul><p><strong><em>Aviso de Propiedad Intelectual:<br></em></strong><em>Los gráficos e imágenes explicativas incluidos en este artículo son creaciones originales de Jonathan Andrés Vásquez Castañeda. Se autoriza su compartición bajo la licencia Creative Commons (CC BY-NC 4.0), exigiendo la atribución expresa de la autoría y prohibiendo su uso comercial sin autorización.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be7a6ceefc8b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/el-modelo-operativo-que-evita-el-caos-en-ti-federal-state-y-local-be7a6ceefc8b">El Modelo Operativo que evita el caos en TI: Federal, State y Local</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IA: La tecnología que potencia nuestras capacidades cuando aprendemos a comunicarnos con ella]]></title>
            <link>https://medium.com/bancolombia-tech/ia-la-tecnolog%C3%ADa-que-potencia-nuestras-capacidades-cuando-aprendemos-a-comunicarnos-con-ella-0e4dd8aa6359?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/0e4dd8aa6359</guid>
            <category><![CDATA[productividad]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[prompt-efectivo]]></category>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[comunicación-efectiva]]></category>
            <dc:creator><![CDATA[Ourquiola]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 21:06:16 GMT</pubDate>
            <atom:updated>2026-07-31T21:06:14.964Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KIsREMUyK8D10yDZDB1J8w.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p>Hace algunos años, cuando las redes sociales comenzaban a transformar la manera en que nos comunicábamos, tuve la oportunidad de dar una charla a un grupo de jóvenes en una iglesia.</p><p>Muchos esperaban que hablara sobre los peligros de esas plataformas y que concluyera con una postura tajante en su contra. Sin embargo, decidí titular la conferencia de una forma diferente: <strong>“Uso o abuso de las redes sociales”.</strong></p><p>La razón era sencilla. No creía que la discusión debiera enfocarse en si la tecnología era buena o mala, sino en la forma en que las personas decidían utilizarla.</p><p>Al finalizar la charla surgieron preguntas interesantes. Algunos pensaban que permitir su uso libremente era un error. Otros defendían que cada persona debía usarlas sin restricciones; sin embargo, detrás de todas las opiniones existía una pregunta más profunda: <strong>¿el problema sí era la tecnología o nuestra relación con ella?</strong></p><p>Mi conclusión, entonces, fue la misma que sigo sosteniendo hoy: las herramientas rara vez son el problema. Lo que determina su impacto es el criterio con el que las utilizamos.</p><p>La clásica analogía del vaso medio lleno o medio vacío refleja perfectamente esta realidad. Ante una misma herramienta, algunos ven oportunidades y otros observan riesgos. Y, curiosamente, ambos suelen tener algo de razón.</p><p>Por eso, cuando escucho los debates actuales sobre la Inteligencia Artificial, experimento una sensación de <strong>déjà vu</strong>. Veo posturas similares: quienes la consideran una revolución capaz de potenciar el talento humano y quienes la perciben como una amenaza que debemos limitar o evitar.</p><p>Sin embargo, la IA introduce un elemento diferenciador respecto a muchas tecnologías que la precedieron: no solo amplía nuestras capacidades, sino que acelera nuestra habilidad de aprender, crear, analizar y resolver problemas.</p><p>Hoy está presente en la medicina, la educación, las finanzas, la investigación científica y el desarrollo de software. Está ayudando a profesionales y organizaciones a descubrir patrones invisibles para el ojo humano y dedicar más tiempo a actividades donde realmente aportamos valor.</p><p>Por eso, considero que la conversación ya no debería centrarse únicamente en si debemos usar Inteligencia Artificial o no. La verdadera pregunta es otra: <strong>¿Estamos aprendiendo a comunicarnos con ella de la forma correcta para potenciar nuestras capacidades?</strong></p><p>Y, quizás, ahí es donde comienza el desafío más interesante de nuestra generación.</p><p><strong><em>El Déjà vu</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M0uYQkAc8O2HKJjTw93GZg.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p>Con el auge de la Inteligencia Artificial he experimentado una sensación de que esto ya lo he vivido antes.</p><p>He vuelto a escuchar debates muy similares a los que surgieron años atrás con las redes sociales: algunos la consideran una revolución capaz de transformar positivamente nuestra forma de trabajar, mientras que otros advierten sobre sus riesgos y posibles consecuencias.</p><p>Y, siendo honestos, ambas posturas tienen argumentos válidos. Pero lo que resulta innegable es que la IA llego para apoyarnos. Más que reemplazar capacidades humanas, está demostrando ser una herramienta que las amplifica.</p><p>Por supuesto, siguen apareciendo preguntas importantes:</p><ul><li>¿Nos beneficia o nos perjudica?</li><li>¿Podría generar dependencia?</li><li>¿Estamos aprendiendo a usarla correctamente?</li></ul><p>Sin embargo, he llegado a una conclusión muy similar a la que obtuve años atrás cuando reflexionaba sobre las redes sociales: “<strong>No creo que el verdadero debate sea si debemos usar la IA o no. El desafío está en aprender a utilizarla con criterio.”</strong></p><p>Porque la tecnología puede potenciar nuestras capacidades, pero el juicio, la experiencia y la responsabilidad siguen dependiendo de nosotros.</p><p><strong><em>Experiencia práctica en el uso de IA</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cgjrvp7L7pw6RcpdcZCL3g.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p>Mas allá de lo que diga el colectivo, quiero compartir un par de experiencias que he tenido trabajando en desarrollos con lenguajes de programación como <strong>Flutter y Python</strong>, apoyándome en la IA. Les adelanto que he visto ambas caras:</p><p><strong>Lo positivo:</strong></p><ul><li>Aceleración significativa del desarrollo de soluciones.</li><li>Automatización de tareas manuales.</li><li>Reducción de tiempos de investigación.</li><li>Apoyo en la generación de ideas innovadoras.</li><li>Creación rápida de prototipos.</li><li>Aprendizaje acelerado de nuevas tecnologías.</li><li>Mayor productividad individual y de equipos.</li><li>Mejora en la calidad del software mediante revisiones automatizadas.</li><li>Democratización del conocimiento especializado.</li><li>Incremento en la capacidad de análisis y toma de decisiones</li></ul><p>En mi experiencia personal, estos beneficios han tenido un impacto tangible en la forma como desarrollo soluciones. Actividades que antes podían tomar días de investigación, hoy pueden resolverse en cuestión de horas, permitiendo enfocar más tiempo en el análisis estratégico y menos en tareas operativas.</p><p>La IA no reemplaza el conocimiento técnico; lo potencia.</p><p><strong>Lo desafiante</strong></p><p>Es importante entender que las limitaciones de la IA no representan necesariamente debilidades de la tecnología. Más bien son características propias de una herramienta que sigue evolucionando y cuyo valor aumenta significativamente cuando existe supervisión humana.</p><p>Como ocurre con cualquier innovación tecnológica, conocer sus alcances es tan importante como reconocer sus beneficios.</p><p>Durante mi experiencia he identificado principalmente cuatro desafíos:</p><p><strong>1. Dependencia del contexto proporcionado</strong></p><p>La calidad de las respuestas depende directamente de la calidad de la información suministrada.</p><ul><li>Un contexto incompleto puede generar respuestas superficiales.</li><li>Un prompt ambiguo puede entregar resultados poco precisos.</li></ul><p><strong>2. Necesidad de validación humana</strong></p><p>La IA puede generar información incorrecta o presentar conclusiones con un nivel de confianza que no siempre refleja su exactitud.</p><ul><li>No garantiza precisión absoluta.</li><li>Requiere revisión en escenarios críticos.</li></ul><p><strong>3. Manejo de problemas altamente ambiguos</strong></p><p>Aunque la IA es sobresaliente procesando información estructurada, puede tener dificultades cuando el problema está mal definido o requiere criterios subjetivos complejos.</p><ul><li>Puede simplificar excesivamente algunos escenarios.</li><li>Puede omitir matices importantes.</li></ul><p><strong>4. Evolución continua del conocimiento</strong></p><p>Los modelos evolucionan constantemente y su nivel de actualización puede variar según la tecnología utilizada.</p><ul><li>Algunas respuestas pueden requerir validación adicional.</li><li>La información más reciente puede necesitar contraste con fuentes externas.</li></ul><p>Sin embargo, resulta interesante observar que muchos de estos desafíos no están relacionados con una incapacidad propia de la IA, sino con la calidad de la interacción entre la persona y el sistema.</p><p>En otras palabras, cuando mejora la comunicación, mejora el resultado.</p><p>Por esta razón, el verdadero diferencial no está únicamente en la tecnología disponible, sino en la capacidad que tenemos para formular preguntas claras, proporcionar contexto adecuado y validar críticamente las respuestas obtenidas.</p><p><strong>¿Se puede mejorar esto?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IjZDe6KicZFDyuBcXLxXlw.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p>Curiosamente, varios de los desafíos mencionados anteriormente son exactamente los mismos que enfrentamos en la comunicación entre personas.</p><p>Los seres humanos también podemos interpretar incorrectamente una solicitud, responder sin suficiente contexto, cometer errores o producir resultados inconsistentes cuando las instrucciones son ambiguas.</p><p>La diferencia es que solemos tolerar estas limitaciones en las interacciones humanas, mientras que a la IA le exigimos niveles de precisión cercanos a la perfección.</p><p>Esto nos recuerda que el verdadero valor no surge de sustituir al ser humano, sino de combinar las fortalezas de ambos.</p><p>Ahora,<strong> ¿c<em>uándo SI y cuándo no usar IA</em></strong>?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LFUhGfwnMD-RtlgKc0A1Mg.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p><strong><em>IA y la comunicación efectiva</em></strong></p><p>La comunicación efectiva ha sido estudiada durante décadas por autores como: Harold Lasswell, Paul Lazarsfeld, Carl Hovland, Kurt Lewin, Paul Watzlawick</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IyxGIC1lpxQBMumirx7oZA.png" /><figcaption>Fuente: Ilustración original generada mediante inteligencia artificial para este artículo.</figcaption></figure><p>Lo interesante es que una habilidad tradicionalmente humana se ha convertido en una competencia fundamental para interactuar con sistemas inteligentes. Mientras más clara sea nuestra comunicación, mejores serán los resultados que obtendremos de la IA.</p><p>En este sentido, la comunicación efectiva se está transformando en una ventaja competitiva para los profesionales del siglo XXI.</p><p><strong>Definición clave: la comunicación efectiva es aquella en la que el mensaje se transmite, se recibe y se comprende claramente. </strong>Sin embargo, hoy surge una nueva dimensión: <strong>¿La comunicación es solo entre humanos o también entre humanos y máquinas?</strong></p><p>En el contexto actual, considerando la IA, puedo decir:</p><p><strong>La comunicación efectiva (humano-humano o humano-IA) es un proceso colaborativo donde la claridad, precisión y contexto permiten generar respuestas útiles y comprensibles.</strong></p><p>De hecho, muchos de los casos donde se percibe que la IA “falló” tienen su origen en problemas de comunicación, contexto insuficiente o instrucciones ambiguas. Por eso, aprender a comunicarnos con la IA es una de las habilidades más importantes que debemos desarrollar en esta nueva era digital.</p><p>Luego de estas definiciones, debemos tener conciencia de la importancia y el rol de los prompts, ya que son el puente entre humano e IA. Un buen prompt produce un gran resultado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/417/1*LPCmz0Krzn_nsojVXoNTsw.png" /><figcaption>Fuente: elaboración propia basada en el concepto de <a href="https://nuevaescuelamexicana.org/comunicacion-efectiva/">https://nuevaescuelamexicana.org/comunicacion-efectiva/</a></figcaption></figure><p><strong><em>Estructura de un buen prompt</em></strong></p><p>Una de las formas más efectivas de interactuar con IA es usando esta fórmula:</p><p>Rol + Tarea + Contexto + Restricciones + Formato de salida + Ejemplos (opcional)</p><p><strong>Ejemplos de Prompts (Nivel Profesional)</strong></p><p><strong>1. Prompt básico (poco efectivo)</strong></p><p>Explícame Kubernetes</p><p><strong>2. Prompt mejorado</strong></p><p>Actúa como un ingeniero DevOps senior. Explícame Kubernetes de forma simple para un desarrollador backend que nunca lo ha usado. Incluye ejemplos prácticos.</p><p><strong>3. Prompt técnico estructurado</strong></p><p>Rol: arquitecto de software; tarea: explicar Kubernetes; contexto: empresa fintech que quiere migrar a microservicios; restricciones: lenguaje claro, máximo 500 palabras; formato: lista + ejemplo real</p><p><strong>4. Prompt avanzado (alta precisión)</strong></p><p>Actúa como arquitecto nube experto en AWS. Necesito un diseño de arquitectura para una aplicación de banca digital basada en microservicios. Contexto: alto volumen transaccional, Alta disponibilidad, Cumplimiento regulatorio. Restricciones: usar servicios nativos de AWS, incluir seguridad y monitoreo, explicar decisiones clave. Formato: 1. Diagrama lógico (descripción), 2. Componentes principales, 3. Flujo de datos, 4. Riesgos y mitigaciones.</p><p><strong>5. Prompt para desarrollo (Flutter)</strong></p><p>Actúa como desarrollador Flutter senior. Necesito implementar autenticación con Firebase. Contexto: App móvil bancaria, Login con email y biometría, restricciones: Código limpio, buenas prácticas, evitar librerías innecesarias. Formato: Código, explicación paso a paso.</p><p><strong>6. Prompt para análisis</strong></p><p>Actúa como analista de datos. Analiza este conjunto de datos y detecta patrones relevantes. Restricciones: Identificar anomalías, proponer hipótesis. Formato: Resumen ejecutivo, hallazgos clave, recomendaciones.</p><p><strong><em>Reflexión final</em></strong></p><p>La Inteligencia Artificial representa una de las mayores oportunidades tecnológicas de nuestra generación. No llegó para sustituir el talento humano, sino para amplificarlo.</p><p>Los profesionales que aprendan a trabajar junto a la IA tendrán mayores niveles de productividad, capacidad de innovación y velocidad de aprendizaje que aquellos que decidan ignorarla.</p><p>Más que una herramienta tecnológica, la IA se está convirtiendo en un nuevo compañero de trabajo capaz de potenciar nuestras habilidades y ayudarnos a resolver problemas cada vez más complejos; sin embargo, para aprovechar todo su potencial, debemos desarrollar una competencia fundamental: la comunicación efectiva.</p><p>Un buen prompt es mucho más que una instrucción. Es la capacidad de transformar una idea en conocimiento útil.</p><p>La IA no reemplaza el pensamiento humano. Lo amplifica.</p><p>Por eso, el reto no es decidir si debemos usarla o no. El verdadero desafío consiste en aprender a comunicarnos mejor con ella para convertirla en una aliada estratégica para nuestro crecimiento profesional y personal.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0e4dd8aa6359" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/ia-la-tecnolog%C3%ADa-que-potencia-nuestras-capacidades-cuando-aprendemos-a-comunicarnos-con-ella-0e4dd8aa6359">IA: La tecnología que potencia nuestras capacidades cuando aprendemos a comunicarnos con ella</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Open Source con confianza: cómo gestionar licencias sin frenar la innovación]]></title>
            <link>https://medium.com/bancolombia-tech/open-source-con-confianza-c%C3%B3mo-gestionar-licencias-sin-frenar-la-innovaci%C3%B3n-c838ce58dca8?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/c838ce58dca8</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[sbom]]></category>
            <category><![CDATA[software-license]]></category>
            <category><![CDATA[legal-risk]]></category>
            <category><![CDATA[copyleft]]></category>
            <dc:creator><![CDATA[Dhavian Fernando Hernández]]></dc:creator>
            <pubDate>Mon, 27 Jul 2026 15:35:45 GMT</pubDate>
            <atom:updated>2026-07-27T15:35:43.582Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XXojGa5miDcJOwF0f_2pHw.png" /><figcaption>Open source con confianza - Imagen generada con IA</figcaption></figure><p>El software open source está en el centro de la forma moderna de construir tecnología. Está en los frameworks, las librerías, los contenedores, las herramientas de automatización, los pipelines, los sistemas operativos y en una buena parte de la infraestructura que usamos todos los días.</p><p>Usar open source no es una excepción: es la norma, pero esa adopción también trae una responsabilidad. Cada componente llega con una licencia que define condiciones de uso, distribución, modificación, atribución o publicación de código. En muchos casos, estas condiciones son simples de cumplir. En otros, requieren análisis, contexto y decisiones conscientes.</p><p>El reto aparece cuando una organización no usa diez dependencias, sino miles. Cuando no tiene un único equipo, sino cientos. Cuando el ciclo de desarrollo no ocurre una vez al mes, sino todos los días, en ese escenario, revisar licencias de forma manual deja de ser sostenible.</p><p>La pregunta deja de ser: ¿qué licencias estamos usando? y se convierte en algo más exigente: ¿cómo hacemos visible, trazable y gobernable el uso de open source sin frenar la velocidad de los equipos?</p><h3><strong>Open source no significa ausencia de obligaciones</strong></h3><p>Una idea común, pero peligrosa, es asumir que todo lo open source puede usarse libremente en cualquier contexto. En realidad, open source significa que el software se distribuye bajo una licencia que otorga ciertos derechos, pero también puede imponer condiciones.</p><p>Desde mi perspectiva, una licencia open source no debería leerse solo como un requisito jurídico. También debería leerse como una decisión de diseño comunitario: define qué quiere permitir el autor, qué espera preservar y qué condiciones deben respetar quienes reutilizan el software.</p><p>En el día a día técnico suelo agrupar las licencias en tres grandes conversaciones: licencias permisivas, licencias copyleft y casos que requieren análisis especial por ambigüedad, combinación de licencias o condiciones particulares.</p><h3><strong>Licencias permisivas: libertad de adopción con obligaciones acotadas</strong></h3><p>Las licencias permisivas son, en términos simples, aquellas que permiten usar, copiar, modificar y distribuir el software con pocas condiciones. Normalmente exigen conservar avisos de copyright, mantener el texto de la licencia, incluir atribuciones o respetar disclaimers de garantía.</p><p>Para equipos de desarrollo, suelen ser las licencias más fáciles de adoptar porque no buscan imponer que el software derivado mantenga la misma licencia. Esto las hace comunes en librerías, frameworks y componentes que pueden integrarse en productos con modelos de distribución muy diferentes.</p><p>Ejemplos comunes:</p><p>- MIT License: una licencia breve y ampliamente usada, enfocada en permitir uso, modificación y distribución, conservando avisos de copyright y licencia.</p><p>- Apache License 2.0: también permisiva, con condiciones adicionales relevantes como aviso de cambios, conservación de atribuciones y una concesión explícita relacionada con patentes.</p><p>- BSD 2-Clause o BSD 3-Clause: licencias permisivas históricas, usadas en múltiples proyectos de infraestructura y sistemas.</p><p>Mi forma práctica de explicarlo es esta: una licencia permisiva normalmente dice “puedes usar este software en muchos contextos, incluso comerciales o propietarios, siempre que respetes unas condiciones básicas de atribución y aviso”.</p><p>Eso no significa que no haya obligaciones. Quiere decir que, comparadas con otras familias, sus obligaciones suelen ser más acotadas y más fáciles de automatizar en procesos de cumplimiento.</p><h3><strong>Copyleft: preservar libertades en obras derivadas</strong></h3><p>El copyleft parte de una idea distinta. No solo concede libertades para usar, estudiar, modificar y redistribuir software, sino que también busca que esas libertades se mantengan cuando el software se modifica o se redistribuye como parte de una obra derivada.</p><p>Desde una mirada técnica, esta es la diferencia que más importa: el copyleft puede activar obligaciones sobre cómo se distribuye el código, qué información debe entregarse y bajo qué licencia deben quedar ciertas modificaciones o derivados.</p><p>Por eso no basta con decir “esta dependencia es open source”. También necesitamos entender cómo se usa: si se modifica, si se enlaza como librería, si se distribuye embebida en un producto, si corre como servicio, si es una herramienta de build o si hace parte directa del artefacto entregado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vt1vy6pASXD9O5XRhkgzRw.png" /><figcaption>Verificación de Copyleft — Imagen generada con IA</figcaption></figure><p>Considero que hablamos de <strong>copyleft fuerte</strong> cuando la licencia busca que las obras derivadas o combinadas que se distribuyen, mantengan la misma licencia o una licencia compatible, con un alcance amplio sobre el resultado.</p><p>El ejemplo clásico es GNU GPL. Si un componente GPL se incorpora de cierta manera en una aplicación distribuida, puede existir la obligación de distribuir el código fuente correspondiente bajo términos compatibles con GPL. El detalle depende del caso concreto, del tipo de integración y de la forma de distribución, pero el punto técnico es que la licencia está diseñada para evitar que el software y sus derivados se cierren en modelos propietarios.</p><p>Ejemplo práctico:</p><p>Un equipo decide tomar código fuente de una herramienta bajo GPL, modificarlo e incorporarlo directamente dentro de una aplicación que luego distribuye a terceros. Ese escenario merece una revisión cuidadosa, porque podría generar obligaciones sobre la publicación del código fuente de la obra derivada o sobre los términos bajo los cuales se distribuye.</p><p>Otro ejemplo relevante es AGPL. Esta licencia fue creada para cubrir escenarios de software usado como servicio en red. En términos prácticos puede activar obligaciones, incluso, cuando el software modificado no se entrega como binario tradicional, sino que se ofrece como funcionalidad a través de una red.</p><p>También, considero útil hablar de <strong>copyleft débil</strong>. En esta categoría ubico licencias que mantienen una obligación de reciprocidad, pero con un alcance más limitado. Normalmente buscan proteger el componente open source y sus modificaciones directas, sin extender necesariamente la misma obligación a todo el software que interactúa con el componente.</p><p>Ejemplos comunes:</p><p>- LGPL: usada con frecuencia en librerías. En muchos escenarios permite enlazar una librería desde software con otra licencia, siempre que se respeten condiciones especificas sobre la librería y sus modificaciones.</p><p>- MPL 2.0: suele describirse como una licencia copyleft a nivel de archivo. Si se modifica un archivo cubierto por MPL, esas modificaciones deben mantenerse bajo MPL, pero otros archivos del proyecto pueden tener licencias distintas bajo ciertas condiciones.</p><p>- EPL: usada en el ecosistema Eclipse, con obligaciones de reciprocidad delimitadas al código cubierto y sus modificaciones.</p><p>Ejemplo práctico:</p><p>Un equipo usa una libreria bajo LGPL como dependencia, sin modificarla, y la enlaza desde una aplicación propia. Ese caso no debería analizarse igual que copiar código GPL dentro de la aplicación. Puede tener obligaciones, por supuesto, pero el alcance y la forma de cumplimiento suelen ser diferentes.</p><p>Otro ejemplo: un proyecto incluye un archivo bajo MPL 2.0 y lo modifica. La obligación principal suele centrarse en mantener ese archivo y sus modificaciones bajo los términos de la MPL. Esto no implica que el resto del proyecto deba adoptar automáticamente esa misma licencia.</p><p>Esta distinción entre copyleft fuerte y débil no reemplaza el análisis legal, pero ayuda mucho a los equipos técnicos. Les permite entender por qué dos licencias copyleft no generan necesariamente el mismo nivel de atención, ni el mismo tipo de decisión.</p><h3><strong>Por qué esta clasificación importa en desarrollo de software</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qITXgqHlppoQMSHFtnWAhg.png" /><figcaption>Clasificación copyleft en Desarrollo de Software — Imagen generada con IA</figcaption></figure><p>En desarrollo de software, el riesgo no depende solo del nombre de la licencia. Depende de la combinación entre licencia, forma de uso, modelo de distribución, modificación del componente, arquitectura y contexto del producto.</p><p>La misma licencia puede tener implicaciones diferentes si:</p><p>- El componente se usa solo como herramienta interna de build.</p><p>- La librería se enlaza dinámicamente o se copia código el fuente.</p><p>- El componente se modifica o se usa sin cambios.</p><p>- El artefacto se distribuye a terceros o solo se ejecuta internamente.</p><p>- La funcionalidad se ofrece como servicio de red.</p><p>- Hay multiples licencias declaradas o licencias no identificadas.</p><p>Por eso, gestionar licencias open source no debería verse como una barrera legal al desarrollo, sino como una práctica de ingeniería responsable. Igual que revisamos vulnerabilidades, calidad, pruebas o despliegues, también necesitamos entender qué estamos incorporando en nuestros productos y bajo qué condiciones.</p><p>Esta es precisamente la razón por la que un control de licenciamiento no debería limitarse a una lista estática de nombres de licencias. Tiene que generar visibilidad, contexto, trazabilidad y capacidad de seguimiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nyd6dzWDnGq7wyruQrE6jg.png" /><figcaption>De controles tardíos a controles integrados — Imagen generada con IA</figcaption></figure><p>Durante mucho tiempo, las organizaciones trataron el licenciamiento open source como una actividad posterior: una revisión manual, un checklist, una consulta puntual o una validación cerca de la salida a producción.</p><p>Ese modelo tiene un problema evidente: llega tarde.</p><p>Cuando el hallazgo aparece al final del ciclo, la remediación es más costosa. Cambiar una dependencia, reemplazar una librería, ajustar una arquitectura o pedir una validación especializada puede afectar tiempos, equipos y decisiones de producto.</p><p>La alternativa es integrar el control al ciclo natural de desarrollo. Esto implica llevar la revisión de dependencias y licencias a los pipelines, automatizar la generación de evidencia, centralizar resultados y entregar información accionable a los equipos desde etapas tempranas.</p><p>No se trata de convertir cada pipeline en un tribunal. Se trata de que el equipo tenga visibilidad temprana y pueda tomar mejores decisiones.</p><p>No se puede gobernar lo que no se conoce.</p><p>En seguridad de software supply chain, uno de los conceptos más importantes es el SBOM, o Software Bill of Materials. Un SBOM es un inventario de los componentes que hacen parte de una aplicación o artefacto de software.</p><p>Estándares como CycloneDX y SPDX han ayudado a que ese inventario sea más portable, automatizable y fácil de integrar entre herramientas. A partir de un SBOM, es posible analizar componentes, versiones, relaciones, vulnerabilidades y licencias.</p><p>Ese inventario se vuelve todavía mas valioso cuando no se queda como un archivo aislado en un pipeline, sino que se pública en una plataforma que permita centralizar, consultar, auditar y hacer seguimiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NanYf03vVz8Twi30dvvU9Q.png" /><figcaption>Herramientas open source como habilitadoras — Imagen generada con IA</figcaption></figure><p>Una estrategia sostenible de gestión de licencias no necesariamente empieza comprando una gran plataforma. El ecosistema open source ofrece herramientas maduras para construir capacidades reales alrededor de inventario, análisis y seguimiento.</p><p>Dependiendo del contexto, una organización puede combinar herramientas como:</p><p>- Generadores de SBOM basados en estándares abiertos como CycloneDX o SPDX.</p><p>- Analizadores de dependencias por ecosistema; por ejemplo Java, JavaScript, Python, contenedores o sistemas operativos.</p><p>- Plataformas de seguimiento como OWASP Dependency-Track.</p><p>- Herramientas de análisis de composición de software.</p><p>- Validadores de políticas o reglas automatizadas en pipelines.</p><p>- Integraciones con tableros, repositorios, sistemas de trazabilidad y canales de notificación.</p><p>La clave no está solo en ejecutar scanners, sino en conectar los resultados con decisiones claras, responsables y repetibles.</p><p>OWASP Dependency-Track es una plataforma open source orientada al análisis continuo de componentes. Su valor esta en centralizar información de proyectos, componentes, vulnerabilidades, licencias y políticas a partir de SBOMs.</p><p>En un modelo de gestión de licenciamiento, una herramienta de este tipo permite pasar de revisiones dispersas a una vista mas estructurada del uso de componentes open source. También, ayuda a mantener trazabilidad sobre hallazgos, estados, proyectos impactados y evolución de riesgos.</p><p>Para organizaciones grandes, esta centralización es importante porque el problema no es solo técnico, sino operativo: los equipos necesitan saber qué deben revisar, dónde está el hallazgo, qué componente lo origina y cómo hacer seguimiento.</p><h3><strong>DevSecOps Engine Tool: automatizar para escalar</strong></h3><p>La automatización es el puente entre una buena intención y una práctica sostenible.</p><p>En este punto aparece <a href="https://github.com/bancolombia/devsecops-engine-tools">DevSecOps Engine Tool</a>, una herramienta open source mantenida por Bancolombia que busca unificar la evaluación de diferentes practicas DevSecOps, de forma agnóstica a la plataforma DevOps, apoyándose tanto en herramientas open source como en herramientas de mercado.</p><p>Desde una mirada de licenciamiento open source, su valor está en llevar al pipeline capacidades que normalmente aparecen dispersas: generación de SBOM, análisis de dependencias, revisión de imágenes de contenedor, gestión de resultados y conexión con plataformas de seguimiento.</p><p>La documentación del proyecto describe un `SBOM_MANAGER` que puede generar SBOMs con herramientas como Syft o cdxgen, usando formatos como CycloneDX JSON. También incluye un `LICENSE_ANALYZER`, orientado a Dependency-Track, que permite cargar el SBOM generado para inspeccionar licencias de componentes.</p><p>Además de ese flujo, la herramienta puede orquestar prácticas de Software Composition Analysis sobre dependencias y contenedores, apoyándose en herramientas como OWASP Dependency-Check, Trivy, JFrog Xray o Prisma Cloud. Esto permite que la generación de evidencia, la aplicación de criterios y el seguimiento de hallazgos no dependan exclusivamente de revisiones manuales.</p><p>El valor no está solamente en ejecutar una tarea técnica. Consiste en estandarizar la forma en que los equipos incorporan controles, reducen fricción y generan información útil para tomar decisiones.</p><p>También, hay un mensaje importante para la comunidad: cuando una herramienta se madura en un entorno empresarial exigente y luego se libera como open source, se crea una oportunidad de aprendizaje compartido. Otros equipos pueden adoptarla, adaptarla, auditarla, extenderla y contribuir a su evolución.</p><p>En otras palabras, DevSecOps Engine Tool no es solo una pieza técnica dentro de un pipeline. Es una forma de empaquetar experiencia operacional para que los controles sean más repetibles, configurables y reutilizables por otros equipos.</p><p><strong>Una arquitectura de referencia, sin imponer una implementación</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B5n37kQ895QA4cRLXB6UgA.png" /><figcaption>Arquitectura de referencia - imagen generada con IA</figcaption></figure><p>Aunque cada organización debe adaptar su proceso, un modelo conceptual podría verse así:</p><p>1. El equipo construye su aplicación en el pipeline.</p><p>2. El pipeline genera o recolecta información de dependencias.</p><p>3. Se produce un SBOM en un formato estándar.</p><p>4. El SBOM se envía a una plataforma de análisis y seguimiento.</p><p>5. Se evalúa la información de licencias y componentes contra criterios definidos por la organización.</p><p>6. Los resultados se devuelven al equipo como información accionable.</p><p>7. Los hallazgos se gestionan con trazabilidad hasta su cierre o decisión correspondiente.</p><p>Este flujo no pretende reemplazar el criterio experto. Al contrario, busca reservar la revisión especializada para los casos que realmente la necesitan.</p><p>La automatización debería encargarse de lo repetible. Las personas deberían enfocarse en el análisis contextual, las excepciones, los casos ambiguos y las decisiones de mayor impacto.</p><h3><strong>Políticas entendibles para equipos técnicos</strong></h3><p>Uno de los errores más comunes en programas de gobierno open source es definir políticas que solo entiende un grupo pequeño de especialistas.</p><p>Si una política no se puede explicar de forma simple, difícilmente se puede adoptar a escala.</p><p>Los equipos de desarrollo necesitan respuestas concretas:</p><p>- ¿Qué pasó?</p><p>- ¿Qué componente esta involucrado?</p><p>- ¿Qué licencia fue identificada?</p><p>- ¿Por qué requiere atención?</p><p>- ¿Qué opciones existen?</p><p>- ¿Dónde puedo consultar más información?</p><p>Mientras más clara sea la retroalimentación, más fácil será que el control se convierta en una ayuda y no en una interrupción.</p><p>Gestionar licencias open source no es una tarea aislada de seguridad, legal o arquitectura. Es una capacidad organizacional que conecta varias disciplinas.</p><p>Los equipos de desarrollo aportan contexto técnico. Seguridad ayuda a integrar controles en el ciclo DevSecOps. Arquitectura puede orientar decisiones de adopción. Legal y cumplimiento aportan criterio sobre obligaciones. Un OSPO (Open Source Program Office), cuando existe, puede articular prácticas, políticas y cultura alrededor del uso responsable de open source.</p><p>El objetivo no es asustar a los equipos para que usen menos open source, sino ayudarles a usarlo mejor.</p><p>El open source nos permite construir más rápido, aprender de comunidades globales y apoyarnos en tecnologías que han cambiado la industria. Por eso, usar open source de forma responsable exige visibilidad, criterio y automatización.</p><p>La gestión de licencias a escala no se logra con revisiones manuales aisladas. Se hace integrando controles al ciclo DevSecOps, usando estándares abiertos, centralizando información y generando evidencia que los equipos puedan entender y accionar.</p><p>Herramientas open source como OWASP Dependency-Track y DevSecOps Engine Tool muestran que es posible avanzar hacia modelos más trazables y sostenibles, sin perder de vista algo esencial: la tecnología funciona mejor cuando se combina con cultura, colaboración y aprendizaje compartido.</p><p>La invitación es simple: no tratemos el licenciamiento open source como un obstáculo al desarrollo. Tratémoslo como algo fundamental para construir software con confianza.</p><h3>Referencias consultadas</h3><p>Estas fuentes fueron usadas como base técnica y conceptual para validar las explicaciones sobre licencias open source, copyleft, SBOM, automatización DevSecOps y herramientas mencionadas en el artículo.</p><ul><li><a href="https://opensource.org/licenses">https://opensource.org/licenses</a></li><li><a href="https://opensource.org/osd">https://opensource.org/osd</a></li><li><a href="https://www.gnu.org/licenses/copyleft.en.html">https://www.gnu.org/licenses/copyleft.en.html</a></li><li><a href="https://spdx.org/licenses/">https://spdx.org/licenses/</a></li><li><a href="https://spdx.dev/">https://spdx.dev/</a></li><li><a href="https://cyclonedx.org/">https://cyclonedx.org/</a></li><li><a href="https://docs.dependencytrack.org/">https://docs.dependencytrack.org/</a></li><li><a href="https://github.com/bancolombia/devsecops-engine-tools">https://github.com/bancolombia/devsecops-engine-tools</a></li><li><a href="https://bancolombia.github.io/devsecops-engine-tools/">https://bancolombia.github.io/devsecops-engine-tools/</a></li><li><a href="https://www.openchainproject.org/specification">https://www.openchainproject.org/specification</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c838ce58dca8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/open-source-con-confianza-c%C3%B3mo-gestionar-licencias-sin-frenar-la-innovaci%C3%B3n-c838ce58dca8">Open Source con confianza: cómo gestionar licencias sin frenar la innovación</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Detectando fallos silenciosos en Kafka con Machine Learning: una guía practica]]></title>
            <link>https://medium.com/bancolombia-tech/detectando-fallos-silenciosos-en-kafka-con-machine-learning-una-gu%C3%ADa-practica-b1aee3c74742?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/b1aee3c74742</guid>
            <dc:creator><![CDATA[Jhan Farley Restrepo]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 04:46:05 GMT</pubDate>
            <atom:updated>2026-07-22T04:46:03.924Z</atom:updated>
            <content:encoded><![CDATA[<p>Introducción</p><p>Mi experiencia con sistemas de mensajería empezó con <strong>RabbitMQ</strong> y <strong>AWS SQS </strong>y por eso, me causó curiosidad entender el funcionamiento interno del Broker de Kafka.</p><p>En RabbitMQ y SQS cuando se presenta una falla, esta suele ser evidente. El diagnóstico generalmente es muy sencillo porque las colas aumentan de tamaño y las métricas muestran con claridad que existe un problema. Por ejemplo, en sistemas gestionados como SQS, gran parte de la complejidad operativa está abstraída por el propio servicio y aspectos como la infraestructura, la replicación y otros detalles internos permanecen ocultos, por lo que se exponen menos métricas, pero fáciles de interpretar.</p><p>El Broker de Kafka funciona de manera distinta a SQS. En lugar de abstraer la complejidad, la hace visible a través de múltiples conceptos como particiones, offsets, lag y tasa de lag, además de indicadores de rendimiento como las tasas de lectura y escritura de datos, entre otras. Esto incrementa las posibilidades de análisis y genera un gran desafío, ya que no siempre es claro qué indicador revisar ni en qué momento algo empieza a comportarse de forma anómala.</p><p>Para explorar Kafka lo hice en<strong> </strong>un laboratorio montado en mi propia máquina<strong>. </strong>Un broker, un productor, un consumidor y acceso a métricas reales. Sin incidentes que resolver, el objetivo era otro, observar qué pasa cuando el sistema no se cae, pero ya no se comporta igual.</p><p>En ese contexto apareció una pregunta concreta:<br> <strong>si Kafka sigue “sano” y ninguna métrica cruza un umbral crítico, ¿cómo puedo detectar que algo empieza a ir mal?</strong></p><p>En lugar de partir directamente de dashboards complejos o reglas de alerta que exigen un conocimiento profundo del comportamiento del sistema, decidí experimentar con la detección de anomalías como un primer paso de observabilidad. El propósito era tomar métricas del broker, entender su dinámica operativa y usar un modelo sencillo de <strong>Machine Learning</strong> para señalar comportamientos atípicos. Para esto utilicé <strong>Isolation Forest</strong> como una primera versión de monitoreo de anomalías.</p><p>Este artículo documenta ese proceso y me permite mostrar cómo monté la arquitectura, qué métricas empecé a observar y qué experimentos me ayudaron a identificar patrones fuera de lo normal. No es una guía de producción ni pretende reemplazar herramientas como Prometheus o Grafana. Es un punto de partida, una forma práctica de construir conocimiento sobre Kafka y entender cómo detectar fallos silenciosos, antes de escalar a sistemas de observabilidad más robustos.</p><p>Finalmente, este artículo busca analizar cómo, en sistemas distribuidos que utilizan un broker de Kafka, una infraestructura aparentemente saludable no garantiza el correcto funcionamiento del sistema en su conjunto. Además, explora cómo técnicas sencillas de <em>Machine Learning</em> pueden contribuir a la detección temprana de anomalías que no son evidentes a partir de las métricas tradicionales de infraestructura.</p><p><strong>Diseñando la Arquitectura</strong></p><p>El flujo a implementar es el siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uvGdmITy8WPespNRxHWOZg.png" /><figcaption>Figura 1. Flujo de identificación de anomalias en Broker Kafka mediante Machine Learning. Fuente: Elaboración propia.</figcaption></figure><p>El flujo comienza cuando el productor genera eventos y los envía al broker de Kafka. Posteriormente, el consumidor lee los mensajes para procesarlos. De forma paralela, el componente <strong>Kafka Monitor</strong> consulta periódicamente un conjunto de métricas del broker y envía cada observación a un servicio de análisis. Allí se realizan unas validaciones y utiliza un modelo de <strong>Machine Learning</strong> previamente entrenado para determinar si la observación corresponde a una anomalía. Adicionalmente, tiene una interfaz gráfica de Kafka que permite verificar y contrastar las métricas consultadas.</p><p><strong>Arquitectura propuesta</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*X-G-fg9LnE61A-vUPHropg.png" /><figcaption><strong>Figura 2. Arquitectura diseñada. Fuente: Elaboración propia.</strong></figcaption></figure><p>Para montar este laboratorio, se instaló el broker de kafka. La configuración en docker compose que me dio mas estabilidad fue:</p><pre>  kafka:<br>    image: apache/kafka:latest<br>    container_name: kafka<br>    ports:<br>      - &quot;9092:9092&quot;<br>      - &quot;29092:29092&quot;<br>    environment:<br>      KAFKA_PROCESS_ROLES: &quot;broker,controller&quot;<br>      KAFKA_NODE_ID: &quot;1&quot;<br>      KAFKA_CONTROLLER_QUORUM_VOTERS: &quot;1@kafka:9093&quot;<br><br>      KAFKA_LISTENERS: &quot;PLAINTEXT://:9092,CONTROLLER://:9093,EXTERNAL://:29092&quot;<br>      KAFKA_ADVERTISED_LISTENERS: &quot;PLAINTEXT://kafka:9092,EXTERNAL://localhost:29092&quot;<br>      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: &quot;PLAINTEXT:PLAINTEXT,CONTROLLER:PLAINTEXT,EXTERNAL:PLAINTEXT&quot;<br>      KAFKA_CONTROLLER_LISTENER_NAMES: &quot;CONTROLLER&quot;<br>      KAFKA_NUM_PARTITIONS: &quot;3&quot;<br>      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: &quot;1&quot;<br>      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: &quot;1&quot;<br>      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: &quot;1&quot;      <br>      KAFKA_HEAP_OPTS: &quot;-Xms1g -Xmx1g&quot;<br>      KAFKA_CONTROLLER_QUORUM_ELECTION_TIMEOUT_MS: &quot;15000&quot;<br>      KAFKA_CONTROLLER_QUORUM_REQUEST_TIMEOUT_MS: &quot;15000&quot;<br>      KAFKA_CONTROLLER_CONNECTIONS_MAX_IDLE_MS: &quot;600000&quot;<br>      KAFKA_CONNECTIONS_MAX_IDLE_MS: &quot;600000&quot;<br>      KAFKA_REQUEST_TIMEOUT_MS: &quot;30000&quot;<br>      KAFKA_NUM_NETWORK_THREADS: &quot;2&quot;<br>      KAFKA_NUM_IO_THREADS: &quot;2&quot;<br>      KAFKA_KRAFT_CLUSTER_ID: &quot;5L6g3nShT-eMCtK--X86sw&quot;<br>      KAFKA_LOG_DIRS: &quot;/var/lib/kafka/data&quot;<br>  <br>    deploy:<br>      resources:<br>        limits:<br>          cpus: &quot;1.5&quot;<br>          memory: &quot;3g&quot;<br><br>    volumes:<br>      - kafka_data:/var/lib/kafka/data</pre><p>Con esta configuración se levantó un Kafka con un solo nodo, con tres particiones por defecto para los tópicos. El broker expuso dos puertos de acceso: <strong>9092</strong>, destinado a componentes que se encuentran dentro de la misma red, y <strong>29092</strong>, para conexiones externas. Adicionalmente, se instaló la aplicación UI for Kafka Apache como capa de visualización y se desarrollaron dos microservicios: uno para que actuara como el productor y otro para que fuera el consumidor. Ambos componentes se conectaron al broker a través del puerto <strong>9092</strong>, ya que operan dentro de la misma red que Kafka.</p><p>Para poder experimentar e identificar las diferentes métricas, se utilizó la Api de administración de Kafka (<a href="https://kafka.apache.org/43/apis/">https://kafka.apache.org/43/apis/</a>) y se desarrolló una aplicación pequeña de Java (Kafka-monitor). La dependencia principal es la librería <strong>org.apache.kafka:kafka-clients:3.9.1</strong> (<a href="https://kafka.apache.org/43/javadoc/index.html?org/apache/kafka/clients/admin/Admin.html">https://kafka.apache.org/43/javadoc/index.html?org/apache/kafka/clients/admin/Admin.html</a> ). Esta aplicación inicialmente hizo una conexión al bróker por el puerto 29092 ya que es externo a la red y cada 30 segundos ejecutaba un método que consulta una serie de métricas y hacía los cálculos correspondientes.</p><p>El siguiente paso fue buscar el algoritmo que podía utilizar para detectar anomalías. En esa investigación encontré el I<strong>solation Forest, </strong>un algoritmo de M<strong>achine Learning y estas son algunas de sus ventajas:</strong></p><p>1. No tiene supervisión y no es necesario etiquetar los datos para entrenarlo; es decir, al pasarle una serie de datos no es obligatorio indicarle cuales son anomalías y cuales no. Él busca directamente datos raros.</p><p>2. El algoritmo aprovecha que los datos normales están agrupados y es más difícil separarlos, mientras que las anomalías están aisladas y son fáciles de separar; por ejemplo, pasémosle un set de datos al algoritmo y veamos cómo funciona:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*bwXuhFeRiPqJg8mDbCQPDA.png" /><figcaption>Figura 3. Las observaciones atípicas de aíslan mas rapidamente. Fuente: Elaboración propia</figcaption></figure><p>El algoritmo realiza cortes aleatorios, tanto verticales como horizontales, para dividir el espacio de los datos e identificar cuales son los que están agrupados y los que están aislados. Las anomalías, al estar más lejos de los valores normales, requieren muy pocos cortes para ser separadas completamente. En cambio, los datos agrupados o normales necesitan múltiples particiones antes de que un punto quede aislado. Por ello, el algoritmo identifica una anomalía como aquel dato que necesita un menor número de cortes para aislarse. Este proceso se repite múltiples veces construyendo varios árboles, y posteriormente, se calcula un promedio de la cantidad de cortes necesarios. Finalmente, con base en este promedio, se determina si un punto es una anomalía.</p><p><strong>Identificación de métricas clave</strong></p><p>La pregunta inicial que surgió fue:<br> <strong>¿Es posible identificar, desde un bróker de Kafka, el estado interno de los consumidores?</strong></p><p>Esta inquietud nace del hecho de que un bróker puede encontrarse en un estado saludable es decir, recibiendo, almacenando y exponiendo mensajes correctamente, mientras que los consumidores pueden estar degradados, acumulando retrasos en el procesamiento.</p><p>En este contexto, el problema a resolver es:<br> <strong>¿Qué señales o métricas expone Kafka que permitan inferir problemas en los consumidores?</strong></p><p><strong>Análisis del comportamiento</strong></p><p>Para responder esta pregunta, observé el comportamiento de Kafka en un escenario controlado, analizando en tiempo real cómo interactúan productores y consumidores. Esto permitió entender tanto la eficiencia del flujo de procesamiento como algunos conceptos clave de la plataforma. Entre ellos están las particiones, que dividen un tópico en secuencias ordenadas de mensajes, y los offsets, que identifican la posición de cada mensaje dentro de una partición. También fue posible analizar la diferencia entre la velocidad a la que se producen y consumen mensajes. Estos conceptos se explican a continuación mediante un ejemplo práctico.</p><p>Se ejecutó un flujo de eventos sobre el tópico <strong>“test-topic”</strong>, generando múltiples mensajes en diferentes particiones. Durante el consumo de estos eventos, se observó que el consumidor no mantuvo el ritmo esperado, quedando rezagado respecto a los mensajes producidos.</p><p>El siguiente cuadro ilustra este comportamiento:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*stekvy5zzoFJnXDYWWbm5g.png" /><figcaption>Figura 4. Visualizando el Consumer Lag: mensajes procesados y pendientes en Kafka. Fuente: Elaboración propia</figcaption></figure><p>En el ejemplo, el tópico <strong>“test-topic”</strong> se encuentra distribuido en varias particiones, cada una con una secuencia ordenada de mensajes (como Pedido A, B, etc.). El <strong>offset </strong>identifica la posición de cada mensaje dentro de su partición. Los elementos en color rosado representan los mensajes ya procesados por el consumidor, mientras que los azules indican los pendientes. En este escenario, el consumidor ha avanzado hasta el offset 1 en la partición 0 y hasta el offset 0 en la partición 1, por lo que todavía quedan por procesar un mensaje en la primera partición y dos mensajes en la segunda.</p><p>La representación anterior permite identificar claramente qué mensajes han sido procesados y cuáles permanecen en espera.</p><p><strong>Evolución del sistema</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*9WQhwdMjRYP6h-CMS00Mmg.png" /><figcaption>Figura 5. Comportamiento del sistema a lo largo del tiempo. Fuente: Elaboración propia</figcaption></figure><p>En el gráfico se observa que la tasa del productor (ProduceRate) permanece estable, mientras que la tasa del consumidor (ConsumeRate) se reduce progresivamente. Como consecuencia, el <strong>lag</strong> aumenta continuamente. En Kafka, esta métrica mide cuántos mensajes están pendientes de ser procesados por un consumidor y se calcula como la diferencia entre el último mensaje disponible en una partición y el último mensaje procesado por el consumidor. El incremento sostenido del lag evidencia una acumulación de mensajes causada porque el consumidor no logra procesar al mismo ritmo en que se producen los eventos.</p><p>Siguiendo con el ejemplo anterior, para calcular el lag total se debe conocer la diferencia entre los mensajes disponibles y los procesados, es decir: en la partición 0, la diferencia entre los mensajes disponibles y los procesados es un mensaje pendiente y en la partición 1, la diferencia es de dos mensajes pendientes; por lo tanto, el Lag total es de 3 mensajes.</p><p>Por eso, para analizar la tasa de llegada de mensajes vs la tasa de consumo e identificar posibles anomalías en el procesamiento se seleccionaron las métricas que podían brindar un análisis más claro del comportamiento del sistema:</p><p><strong>totalLag:</strong> es el lag total acumulado de los mensajes en todas las particiones para ese consumer group. Por ejemplo: un tópico tiene 3 particiones y en cada una de ellas hay 20 mensajes pendientes por procesar. El totalLag sería 60.</p><p><strong>lagRate:</strong> indica la velocidad a la que el <strong>lag</strong> crece o disminuye y refleja la relación entre la capacidad de procesamiento de los consumidores y la llegada de nuevos mensajes. Un valor positivo significa que los mensajes se están acumulando porque los consumidores procesan más lento de lo que se producen. Por el contrario, un valor negativo indica que los consumidores están reduciendo el retraso existente, procesando mensajes a mayor velocidad de la que llegan al sistema.</p><p><strong>endOffsetDelta:</strong> representa la cantidad de nuevos mensajes entre intervalos de monitoreo, es decir calcula la variación del endoffset del broker.</p><p><strong>samplingIntervalSeconds:</strong> es el intervalo de tiempo en el que se calculan las métricas.</p><p><strong>partitions:</strong> indica cuántas particiones está consumiendo el grupo.</p><p><strong>now:</strong> es simplemente el timestamp actual en el momento del cálculo.</p><p><strong>Generando DataSet</strong></p><p>Teniendo claro cuáles son las métricas a utilizar, el siguiente paso es generar escenarios para tener datos del sistema y poder entrenar el modelo de Isolation Forest.</p><p><strong>Primer escenario :</strong> para construir un dataset representativo diseñé un escenario en el cual se generaron eventos con distintos niveles de carga sobre el sistema. En lugar de utilizar una tasa constante, se realizaron inyecciones variables de eventos, por ejemplo: 300 , 1.000 , 10.000 etc. Este enfoque permitió simular diferentes condiciones operativas: una operación estable, incremento progresivo de carga, escenarios de saturación y como resultado, el consumidor experimentó momentos donde no logró mantener el ritmo de procesamiento, generando acumulación de mensajes (<strong>lag</strong>). Este enfoque causó problemas en el entrenamiento del modelo, ya que cuando se iban a evaluar escenarios con saturación alta el sistema no podía detectar si había una anomalía, lo que provocó que el modelo perdiera capacidad de detección.</p><p><strong>Segundo escenario: e</strong>n las siguientes pruebas diseñé escenarios donde los niveles de carga no fueran tan extremos, sino que fueran más constantes y no estresaran tanto el sistema. Los eventos fueron, por ejemplo : 300, 1000, 3000 etc. Este enfoque permitió generar datos con los que el modelo pudiera entender cómo es una operación estable y un comportamiento sano; por lo tanto, el lag no tuvo mayores incrementos. Además, el modelo sí detectó anomalías en escenarios de alta saturación.</p><p><strong>Recolección de métricas</strong></p><p>Durante la ejecución de estos escenarios un consumidor procesaba los eventos, mientras el componente “Kafka-monitor”, basado en <strong>Kafka Clients,</strong> recolectaba métricas cada <strong>30 segundos dando como resultado un archivo plano como el siguiente:</strong></p><pre>timestamp,totalLag,lagRate,endOffsetDelta,partitions,samplingIntervalSeconds<br>2026-04-12T14:07:20.950677Z,444,15.31,744,3,30<br>2026-04-12T14:07:50.939636Z,527,2.86,4156,3,30<br>2026-04-12T14:08:20.941631Z,522,-0.17,4166,3,30<br>2026-04-12T14:08:50.948310Z,529,0.23,3004,3,30<br></pre><p>Esto permitió construir un dataset de tipo <strong>serie temporal</strong> que captura cómo evoluciona el sistema en una operación normal.</p><p><strong>Validación de métricas con umbrales</strong></p><p>Una de las preguntas iniciales es si tiene sentido analizar el comportamiento del sistema definiendo umbrales como, por ejemplo: si totalLag &gt; 500 genera una alerta. Esta regla simple, basada en umbrales estáticos, está asumiendo que para un valor alto se debe generar alerta. Consideremos los siguientes escenarios:</p><p><strong>Primer escenario :</strong> totalLag = 550 , lagRate = 0 ,endOffsetDelta<strong> </strong>=1100<strong> </strong>de acuerdo al umbral definido (totalLag &gt; 500). Esto puede generar una alerta y sería un falso positivo porque la métrica lagRate indica que el sistema está consumiendo al mismo ritmo que produce, es decir, que el sistema es estable.</p><p><strong>Segundo escenario :</strong> totalLag = 480, lagRate = 30, endOffsetDelta<strong> </strong>=1000. Según el umbral definido (totalLag &gt; 500) no se genera alerta, pero lo que está sucediendo en realidad es que el sistema se está degradando porque el lagRate está creciendo rápidamente.</p><p>Aquí podrías pensar en combinar variables y que se defina un umbral, pero esto genera otros problemas; por ejemplo:</p><p><strong>Tercer escenario : </strong>totalLag = 300, lagRate = 15, endOffsetDelta<strong> </strong>=100. El umbral de alertamiento es totalLag &gt; 500 y lagRate&gt;20, pero de acuerdo con las observaciones no se genera ninguna alerta porque las métricas no superan estos valores. Sin embargo, al revisar el comportamiento histórico del sistema se observa que para un endOffsetDelta cercano a 100 , el lagRate es cercano a 0, lo que indica que el consumidor está procesando más lentamente de lo esperado por el volumen de los mensajes y se debería haber alertado.</p><p>Teniendo en cuenta estos tres escenarios, se puede concluir que una regla basada en umbrales no detectaría anomalías en la mayoría de los casos, por lo tanto sí tiene sentido analizar el comportamiento del sistema con un modelo de aprendizaje automático, ya que así se podría identificar la relación entre las métricas en anómala con respecto al comportamiento histórico.</p><p><strong>Preparación de datos y entrenamiento del modelo</strong></p><p>Ya teniendo el set de datos, el siguiente paso es que el modelo entienda el comportamiento del sistema y no que identifique valores altos en las variables; es decir no nos interesa que detecte un valor alto de totalLag o de cualquier otra métrica, sino que entienda cómo se correlacionan totalLag, lagRate etc. El primer paso es estandarizar todas las variables (https://scikit-learn.org/stable/modules/preprocessing.html), para que todas estas métricas queden en una misma escala numérica y sean comparables. Si no se estandarizan las variables pasaría lo siguiente, por ejemplo : totalLag= 500 y un lagRate=11 el modelo ignora que el lagRate está creciendo rápido porque 11 es muy pequeño comparado con 500, pero cuando se estandariza tendríamos totalLag= 1.2 y lagRate = 0.8, así el modelo aprende si el lagRate sube al mismo tiempo que totalLag es una anomalía.</p><p>Después de entender conceptualmente por qué es importante normalizar los datos, el siguiente objetivo es crear el modelo.</p><p><strong>Primer escenario:</strong> El set de datos con el que entrené el modelo tenía la métrica timestamp, pero identifiqué que esta no permitía al modelo entender patrones porque como cada timestamp es distinto, no puede hacer agrupaciones, dificultando la identificación de anomalías. Por ejemplo: un valor de totalLag = 350 es normal a las 3:00 p.m., pero este mismo valor a las 2 de la mañana es una anomalía y el modelo no tenía la capacidad de identificar estas situaciones porque la columna timestamp no le permitió entender patrones.</p><p><strong>Segundo escenario: </strong>hice una pequeña transformación sacando la hora de la variable timestamp para esto darle más posibilidad al modelo de entender patrones y ver cómo realmente se comporta el sistema en un escenario sano. Por ejemplo: el modelo aprendió que una serie de observaciones que estaban en un rango horario de 8 a 12 con un totalLag de un promedio entre 65 y 80 es normal, pero una observación en ese mismo rango horario con un totalLag de 400 es una anomalía.</p><p>El siguiente objetivo es cargar los datos y generar un modelo con el algoritmo Isolation Forest. Para esto utilicé la librería de Python Sklearn(https://scikit-learn.org/stable/index.html).</p><p>Código utilizado:</p><pre>import pandas as pd<br>from sklearn.ensemble import IsolationForest<br>from sklearn.preprocessing import StandardScaler<br>from joblib import dump<br><br>print(&quot; Cargando datos...&quot;)<br>df = pd.read_csv(&quot;consumer_metrics.csv&quot;)<br><br>df[&quot;timestamp&quot;] = pd.to_datetime(<br>    df[&quot;timestamp&quot;],<br>    format=&quot;%Y-%m-%dT%H:%M:%S.%fZ&quot;,<br>    utc=True,<br>    errors=&quot;raise&quot;<br>)<br><br>df[&quot;hourOfDay&quot;] = df[&quot;timestamp&quot;].dt.hour<br><br>features = [    <br>    &quot;totalLag&quot;,<br>    &quot;lagRate&quot;,<br>    &quot;endOffsetDelta&quot;,<br>    &quot;partitions&quot;,<br>    &quot;samplingIntervalSeconds&quot;,<br>    &quot;hourOfDay&quot;<br>]<br><br>X = df[features].astype(float)<br><br>print(&quot; Normalizando datos...&quot;)<br>scaler = StandardScaler()<br>X_scaled = scaler.fit_transform(X)<br><br>print(&quot; Entrenando Isolation Forest...&quot;)<br>model = IsolationForest(<br>    n_estimators=200,<br>    contamination=0.05,<br>    random_state=42<br>)<br><br>model.fit(X_scaled)<br><br>dump(model, &quot;anomaly_model.joblib&quot;)<br>dump(scaler, &quot;scaler.joblib&quot;)<br><br>print(&quot; Entrenamiento completado correctamente&quot;)<br><br><br></pre><p>Las siguientes funciones ayudan a generar la media y la desviación estándar de cada variable para hacer la estandarización y luego, hacer la transformación de todos los datos para que queden en una misma escala numérica.</p><pre>scaler = StandardScaler()<br>X_scaled = scaler.fit_transform(X)</pre><p>Después, para crear el modelo se hacen estas parametrizaciones : n_estimators = 200 (este valor da más estabilidad y resultados más precisos), contamination = 0.05 . Es decir, el modelo utiliza un bosque de 200 arboles (cortes aleatorios para dividir el espacio de los datos y encontrar anomalías) asumiendo que el 5% de los datos son anomalías y fijando una aleatoriedad (randon_state =42) para que sea reproducible.</p><pre>model = IsolationForest(<br>    n_estimators=200,<br>    contamination=0.05,<br>    random_state=42<br>)</pre><p>La siguiente instrucción guarda la media y la desviación estándar. Estos valores se utilizan posteriormente para estandarizar cada nuevo dato que se evalúe, garantizando que todas las variables se representen en la misma escala numérica.</p><pre>dump(scaler, &quot;scaler.joblib&quot;)</pre><p>Al final de este proceso se tiene como resultado un modelo que identifica un patrón de los datos para detectar con más facilidad las anomalías.</p><p><strong>Análisis de los componentes claves</strong></p><p>Para que todo este ecosistema funcione correctamente vamos a revisar un poco más el comportamiento entre el Kafka-monitor y el AI-service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/820/1*D34j78r_ZVRDkYoAMSDZsw.png" /><figcaption>Figura 6. Análisis del flujo de detección de anomalías entre Kafka-monitor y AI-service. Fuente: Elaboración propia</figcaption></figure><p>El componente Kafka-monitor ayuda a identificar cuándo un consumidor se está quedando rezagado antes de que se convierta en una caída del servicio. La aplicación observa periódicamente un consumer group, compara el offset consumido contra el offset más reciente del tópico y calcula el lag total. Después, estas métricas se envían al componente AI-service por (HTTP). Ese servicio responde con una evaluación (un puntaje si ve anomalía). Con esa respuesta, el monitor decide si muestra la alerta.</p><p>Cuando el componente Kafka-monitor envía las métricas lo primero que hace es armar un json, como el siguiente:</p><pre>{<br>  &quot;timestamp&quot;: &quot;2026-04-10T21:02:27.914476Z&quot;,<br>  &quot;totalLag&quot;: 5000,<br>  &quot;lagRate&quot;: 10.5,<br>  &quot;endOffsetDelta&quot;: 150,<br>  &quot;partitions&quot;: 3,<br>  &quot;samplingIntervalSeconds&quot;: 30<br>}</pre><p>Luego, hace la petición POST a <a href="http://localhost:8000/detect-anomaly">http://localhost:8000/detect-anomaly</a> la respuesta llega al componente AI-service( este componente cada que vez que se inicia carga el modelo). Cuando llega una petición se recibe y se deserializa el json, se extrae la hora del parámetro “timestamp” y se normalizan las variables del json. Esto es muy importante ya que los datos que se van evaluar deben estar en la misma escala numérica de los datos con los que se entrenó el modelo. Finalmente, hace la predicción con el modelo de Machine Learning y retorna el siguiente json.</p><pre>{<br>  &quot;anomaly&quot;: true,<br>  &quot;score&quot;: 0.85<br>}</pre><p><strong>anomaly :</strong> esta variable retorna -1 si hay anomalía y 1 si es normal, pero para efectos de una mejor validación se transformó a los siguientes valores: “true” si hay anomalía y “false” si no hay anomalía.</p><p><strong>score:</strong> esta variable retorna un valor numérico e indica que tan anómala es la observación de acuerdo con el patrón aprendido dentro de un determinado set de datos; por defecto, score &gt;0 es normal, score &lt; 0 anomalía, score ≈ 0 el modelo no sabe bien si es anómalo o no.</p><p>Inicialmente, en la configuración que utilicé en el componente Kafka-monitor para identificar una anomalía solo tuve en cuenta la variable anomaly, es decir si retornaba “true” se generaba una alerta de anomalía y si retornaba “false” no alertaba; sin embargo, identifiqué muchos falsos positivos.</p><p>Posteriormente, ajusté el criterio teniendo en cuenta la variable score y de acuerdo con lo observado, el mejor umbral fue el siguiente: anomaly =true &amp;&amp; score&lt; -0.6 solo en este caso se generó una alerta de anomalía, lo que me ayudó a reducir los falsos positivos y priorizar los eventos más críticos.</p><p><strong>Ejecución de pruebas</strong></p><p><strong>Primer escenario: </strong>inicialmente, generé pocos eventos en el productor y se observé que el consumidor procesaba al mismo ritmo en el que llegaban los mensajes; es decir, no se generaron alertas de anomalía. Las variables que se retornaban era anomaly=false y el score es un valor positivo pero bajo.</p><p><strong>Segundo escenario:</strong> aumenté el número de eventos en el productor y se observé que el consumidor no podía procesar al mismo ritmo en el que llegaban los mensajes, pero no había un incremento tan alto del lag. Las variables retornaban anomaly= true y score ≥ -0.6 por lo tanto no generó alerta.</p><p><strong>Tercer escenario:</strong> aumenté el número de eventos en el productor de manera considerable, lo que implicó un crecimiento considerable en totalLag y rateLag. Las variables retornaban anomaly=true y score&lt;-0.6, por lo tanto sí generaba alertas.</p><p>Con estas pruebas se validó la capacidad del sistema para detectar anomalías y descubrir que es posible hacer la integración de un modelo de aprendizaje automático en un flujo de Kafka, haciendo inferencia en tiempo real y correlacionando las nuevas observaciones con el modelo generado.</p><p><strong>Validación de la UI de Kafka</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pIyTCs7LeX61kNimu8BCrw.png" /><figcaption>Figura 6. Análisis del flujo de detección de anomalías entre Kafka-monitor y AI-service. Fuente: Elaboración propia</figcaption></figure><p>La imagen corresponde a la herramienta <strong>UI for Apache Kafka</strong> donde se visualiza el estado del consumer group KafkaConsumer-events, el cual es <strong>“STABLE” </strong>lo que indica que Kafka no detecta fallos estructurales ni problemas de rebalancing; sin embargo, el lag total alcanza 532 mensajes, evidenciando una acumulación significativa de mensajes.</p><p><strong>Conclusiones</strong></p><p>Para entrenar un modelo con Isolation forest se debe pasar un set de datos donde el comportamiento del sistema este sano para que pueda detectar las anomalías con más precisión.</p><p>El modelo de Isolation Forest se integra correctamente a la arquitectura diseñada, apoyando a los componentes a hacer la inferencia en tiempo real, por lo que se detectan escenarios de degradación y se valida el comportamiento con la interfaz gráfica de Kafka.</p><p>La integración de modelos de Machine Learning en el flujo de monitoreo permite evolucionar desde una observabilidad basada en métricas, hasta un sistema inteligente capaz de interpretar el comportamiento del consumo en Kafka y detectar anomalías de forma proactiva.</p><p>Con estas pruebas se demuestra la integración real de Machine Learning en sistemas distribuidos, la consistencia entre entrenamiento e inferencia, el diseño de APIs de inferencia y la evaluación basada en evidencia.</p><p>Con esta arquitectura se puede hacer un posible escalamiento a una observabilidad, no solo en alertamientos, sino ya a una remediación automática o sistemas auto-reparables.</p><p>Enlaces de interés:</p><ul><li><a href="https://bancolombia.github.io/reactive-commons-java/docs/intro/">Overview | Reactive Commons Java</a></li><li><a href="https://github.com/bancolombia/scaffold-clean-architecture">GitHub - bancolombia/scaffold-clean-architecture: Gradle plugin to create a clean application in Java that already works, It follows our best practices!</a></li><li><a href="https://kafka.apache.org/">Apache Kafka</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b1aee3c74742" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/detectando-fallos-silenciosos-en-kafka-con-machine-learning-una-gu%C3%ADa-practica-b1aee3c74742">Detectando fallos silenciosos en Kafka con Machine Learning: una guía practica</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Arquitectura Empresarial: ¿Qué es y por qué importa más que nunca?]]></title>
            <link>https://medium.com/bancolombia-tech/arquitectura-empresarial-qu%C3%A9-es-y-por-qu%C3%A9-importa-m%C3%A1s-que-nunca-034c15114a1a?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/034c15114a1a</guid>
            <category><![CDATA[arquitectura-de-datos]]></category>
            <category><![CDATA[arquitectura-de-negocio]]></category>
            <category><![CDATA[business-architecture]]></category>
            <category><![CDATA[arquitectura-de-solución]]></category>
            <category><![CDATA[solution-architecture]]></category>
            <dc:creator><![CDATA[Carlos Velásquez]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 18:47:21 GMT</pubDate>
            <atom:updated>2026-06-12T18:47:19.825Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>AE: Clave para catalizar la transformación y alineación estratégica en las organizaciones</blockquote><h3>Introducción</h3><p>En el contexto actual, las organizaciones, sea públicas o privadas, enfrentan un entorno cada vez más volátil, incierto, complejo y ambiguo (lo que se conoce como <em>entorno VUCA, por sus siglas en inglés: Volatility, Uncertainty, Complexity, Ambiguity</em>). Este término, inicialmente utilizado por el ejército de los Estados Unidos tras la Guerra Fría, ha sido adoptado por el mundo empresarial para describir las condiciones cambiantes e impredecibles del entorno global (Bennett &amp; Lemoine, 2014).</p><p>Elementos como la transformación digital, la globalización, la aparición de nuevas tecnologías (incluyendo inteligencia artificial IA), y la necesidad de alcanzar la sostenibilidad, impulsan a las empresas a revisar y evolucionar sus estructuras, procesos y tecnologías de manera constante.</p><p>La <strong>Arquitectura Empresarial (AE)</strong> emerge como una herramienta estratégica que permite tener una visión clara y articulada del funcionamiento interno de una organización, ayudando a alinear su tecnología y operación con los objetivos del negocio. A través de la AE, es posible modelar el estado actual de la empresa, diseñar el estado futuro deseado y trazar el camino de transformación necesario.</p><p>Este último párrafo, es un resumen muy contundente de lo que es Arquitectura Empresarial, un AS-IS o estado actual de la arquitectura, un TO-BE o estado futuro de la arquitectura y un RoadMap o mapa de ruta de transformación.</p><p>En este artículo repasaremos los fundamentos de la arquitectura empresarial, sus beneficios, componentes, marcos de referencia y aplicación concreta. Además, con un enfoque práctico a modo de ejemplos, facilitaremos la comprensión de este campo que es fundamental para el diseño de organizaciones eficientes, resilientes y orientadas al cambio.</p><h3>¿Qué es la Arquitectura Empresarial?</h3><p>Es una disciplina estratégica que permite describir y representar, mediante diversos artefactos (gráficos, modelos, catálogos y matrices), <strong>el funcionamiento interno de una organización</strong>, la forma en que se interrelacionan sus componentes y cómo estos pueden evolucionar hacia un estado futuro deseado.</p><p>Su propósito fundamental es alinear los objetivos y estrategias del negocio con las capacidades tecnológicas, los procesos operativos, la arquitectura de datos y las aplicaciones, brindando una <strong>visión integral, estructurada y coherente</strong> de la empresa o entidad.</p><p>Al ofrecer esta perspectiva unificada, la arquitectura empresarial se convierte en una herramienta clave para la toma de decisiones informadas, facilitando la innovación, la transformación digital, la mejora continua y la adaptabilidad frente a entornos cambiantes.</p><h4><strong>Componentes clave de AE:</strong></h4><ol><li><strong>Arquitectura de Negocio</strong>: Describe las capacidades y funciones del negocio, los principales componentes técnicos y procesos que las soportan, los objetivos estratégicos, los actores y la estructura organizacional.</li><li><strong>Arquitectura de Datos</strong>: Establece cómo se gestionan, integran y protegen los datos. Incluye la definición o estandarización del modelo de datos, flujos de información, gobernanza, entre otros.</li><li><strong>Arquitectura de Solución o Aplicaciones</strong>: Documenta las aplicaciones o soluciones utilizadas, sus funcionalidades y la forma en que apoyan los procesos del negocio. Además, plantea la situación actual del ciclo de vida de dichas aplicaciones.</li><li><strong>Arquitectura Técnica o Tecnológica</strong>: Muestra la infraestructura técnica utilizada por las diferentes soluciones o aplicaciones (servidores, redes, sistemas operativos, plataformas en la nube).</li></ol><p>Estos componentes permiten analizar la organización <strong>como un sistema interconectado</strong>, donde cualquier cambio en un área tiene impacto en las demás.</p><h3>Beneficios de implementar Arquitectura Empresarial</h3><p>Las organizaciones que implementan esta práctica múltiples beneficios. Algunos de los más relevantes son:</p><ul><li><strong>Visión integral del negocio y la tecnología</strong>: Elimina la desconexión entre equipos o áreas, permitiendo una mirada sistémica.</li><li><strong>Optimización de recursos</strong>: Identifica duplicidades, ineficiencias y oportunidades de mejora en varios niveles; por ejemplo, en aplicativos, licenciamiento y procedimientos.</li><li><strong>Facilita la transformación digital</strong>: Define una hoja de ruta clara o RoadMap para minimizar riesgos, realizar entregas de valor tempranas y asegurar una evolución alineada con la estrategia.</li><li><strong>Gestión del cambio organizacional</strong>: Brinda herramientas para planear, comunicar y ejecutar cambios en procesos o tecnologías, algunos, por ejemplo, asociados al ciclo de vida.</li><li><strong>Reducción de costos operativos</strong>: A través de la racionalización de aplicaciones, sistemas y procesos redundantes.</li></ul><p><strong>Ejemplo práctico</strong>: Un arquitecto que diseña el sistema de información para una pyme puede aplicar AE para mapear los procesos (ventas, compras, facturación), entender qué aplicaciones se usan (Excel, ERP, sistemas web) y proponer mejoras tecnológicas coherentes con los objetivos del negocio (migrar a una solución integrada en la nube). Como resultado, en su propuesta planteará los principales hitos y su orden de ejecución.</p><h3>Marcos de referencia (frameworks) más utilizados</h3><p>Los marcos de referencia ofrecen <strong>metodologías estandarizadas</strong> para aplicar arquitectura empresarial de forma sistemática, permitiendo modelar, analizar y planificar de manera estructurada.</p><p>Sin embargo, lo que ha dado la experiencia en múltiples implementaciones de la práctica de AE en diferentes mercados y organizaciones, es que seguir al pie de la letra un framework puede no ser la mejor opción, dado que cada organización tiene sus particularidades a nivel estructural, de procesos, cultura, entre otros, por tanto, lo más recomendado es <strong>elegir</strong> un framework y <strong>adaptarlo</strong> para obtener mayores beneficios.</p><h4><strong>Principales frameworks:</strong></h4><p><strong>➤ TOGAF (The Open Group Architecture Framework)</strong></p><ul><li>Proporciona una metodología de desarrollo arquitectónico conocida como ADM (Architecture Development Method).</li><li>TOGAF es flexible y adaptable a distintos sectores.</li><li>Utiliza conceptos como catálogos, diagramas y matrices para representar las arquitecturas.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/241/1*2BnelW_dRt6-cR-SDRU06w.png" /><figcaption>Imagen 1: Ciclo completo del método ADM de TOGAF</figcaption></figure><p><strong>➤ Zachman Framework</strong></p><ul><li>Enfocado en el análisis de la empresa desde múltiples perspectivas (estratégica, lógica, física).</li><li>Utiliza una matriz 6x5 que responde a las preguntas: qué, cómo, dónde, quién, cuándo y por qué, vistas desde distintos roles (planeador, dueño, diseñador, etc.).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/436/1*szO9Q65WmkHwAdg60f4oXw.png" /><figcaption>Imagen 2: Tabla usada para ejecutar el método de Zachman</figcaption></figure><p><strong>➤ ArchiMate</strong></p><ul><li>Es un lenguaje visual de modelado compatible con TOGAF.</li><li>Permite representar gráficamente los distintos componentes de una arquitectura empresarial.</li></ul><p><strong>➤ FEAF</strong></p><ul><li>Framework promovido por el gobierno de EE. UU., orientado a entidades públicas.</li></ul><h3>Desafíos comunes en la implementación</h3><p>A pesar de sus ventajas bien divulgadas, muchas organizaciones enfrentan dificultades al implementar arquitectura empresarial. Conocer estos desafíos es fundamental para anticiparse a ellos y no fracasar en el intento.</p><ul><li><strong>Resistencia al cambio</strong>: Muchas personas perciben la AE como un proceso técnico y tedioso ajeno a su trabajo diario.</li></ul><blockquote>Para abordar este desafío se puede plantear una estrategia de gestión del cambio organizacional y tener una buena comunicación de los beneficios que se pueden tener.</blockquote><ul><li><strong>Falta de patrocinio ejecutivo</strong>: Sin el apoyo y acompañamiento de los líderes, los proyectos de AE suelen quedarse en papel.</li></ul><blockquote>A este desafío, es importante integrar a los lideres desde el inicio y acordar con ellos la vinculación de la AE a las metas del negocio (KPIs).</blockquote><ul><li><strong>Escasez de talento</strong>: Se requieren perfiles con conocimientos en estrategia, TI, modelado, análisis empresarial, además de un buen entendimiento del negocio y habilidades blandas y comunicacionales.</li></ul><blockquote>Algo que contribuye con esto es implementar dentro del plan de carrera la formación a los equipos y fomentar las certificaciones.</blockquote><ul><li><strong>Desalineación entre negocio y TI</strong>: Si el área de tecnología no entiende al negocio, y viceversa, es difícil alinear objetivos y siempre buscarán fines diferentes.</li></ul><blockquote>Resolver este desafío es clave para el éxito, por lo tanto, se puede abordar utilizando modelos visuales que sean comprendidos por ambas partes y fomentar sesiones de cocreación.</blockquote><h3>Caso práctico: Aplicación en una institución educativa</h3><p>Una universidad busca mejorar su sistema de gestión académica. Actualmente, los docentes utilizan un sistema o aplicativo, los alumnos otro y el equipo administrativo otro. No hay integración entre ellos, lo cual genera desinformación, tiempos altos de atención, entre otros.</p><p><strong>Aplicación de AE</strong>:</p><ol><li><strong>Análisis actual</strong> (AS-IS): Se modelan los diferentes aplicativos y procedimientos actuales en la Universidad, detectando redundancias y puntos de fricción.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/307/1*lhEpPKwAFwjDyfaJrr4Vkg.png" /><figcaption>Artefacto (Gráfico) que muestra el estado actual de la situación</figcaption></figure><p><strong>2. Diseño futuro</strong> (TO-BE): Se propone una alternativa de solución que involucra un sistema integrado en la nube, con acceso unificado para todos y que le permita a los actores tener una buena experiencia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/322/1*Zczgf8pzPW1BIKxyw__Jpg.png" /><figcaption>Artefacto (Gráfico) que muestra el estado futuro deseado</figcaption></figure><p><strong>3. Transición</strong>: Se definen etapas de implementación (este punto también es conocido como hoja de transformación o RoadMap): migración de datos, capacitación, pruebas, puesta en marcha.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/457/1*gwREbyrVfyTlpzXNQYuzZg.png" /><figcaption>Artefacto que muestra las etapas de implementación</figcaption></figure><p>Este un ejemplo simple a un alto nivel de abstracción; sin embargo, permite entender y evidenciar el gran trabajo detrás de un planteamiento como estos llevado a la realidad.</p><p><strong>Resultado</strong>: implementando la arquitectura empresarial en un caso práctico como la Universidad, donde una de sus necesidades es la optimización de varios sistemas desconectados, procesos manuales, etc., se estima lograr una reducción del 30% en el tiempo invertido por el equipo administrativo y una mejora significativa en la satisfacción de estudiantes y docentes, al interactuar con las diferentes funcionalidades.</p><p>La reducción del 30% en el tiempo invertido por el equipo administrativo, esta alineado con experiencias y resultados de evidencia real reportados en otras industrias; por ejemplo, en la de servicios financieros donde un banco global, luego de implementar una arquitectura empresarial, reportó la reducción del 30% en su cartera de aplicaciones, eliminando sistemas redundantes, mejorando la eficiencia operativa y, por lo tanto, generando ahorros significativos.</p><h3>Tendencias actuales y futuro de la Arquitectura Empresarial</h3><p>La arquitectura empresarial está evolucionando para adaptarse a las realidades del entorno digital y las nuevas tecnologías. Algunas tendencias clave incluyen:</p><ul><li><strong>Arquitectura empresarial ágil</strong>: Busca compatibilidad con marcos ágiles como Scrum y SAFe, promoviendo ciclos iterativos de planificación y planteamiento de alternativas de solución que puedan ser implementadas de forma incremental.</li><li><strong>Modelado automatizado con IA</strong>: Herramientas inteligentes que generan modelos arquitectónicos, diseños y artefactos a partir de datos operativos.</li><li>Un análisis de Carsten Krause (CDO Times, 2025) señala que la IA ya no es experimental, sino un <strong>catalizador clave en la evolución de la Arquitectura Empresarial</strong>, especialmente mediante la automatización inteligente y la mejora de la gobernanza arquitectónica.</li><li><strong>Gobierno de datos</strong>: Integración de políticas de calidad, privacidad y seguridad de datos en la arquitectura, similares a los diferentes marcos regulatorios y buenas prácticas.</li><li><strong>Enterprise Architecture as a Service (EAaaS)</strong>: Servicios externos que ofrecen AE como solución flexible para organizaciones pequeñas o medianas.</li></ul><p>Además de estas tendencias y beneficios, la Arquitectura Empresarial está ayudando a mitigar la deuda técnica mediante una visión estructurada y de largo plazo, lo cual permite que las organizaciones puedan tener más tiempo para innovar y sean mucho más ágiles, dado que el tiempo invertido al soporte en general es alto y está relacionado con esta problemática.</p><p>La deuda técnica, si bien hay varias derivaciones de su definición inicial, la podemos resumir como el costo implícito del trabajo adicional a futuro, que resulta por elegir una solución <strong>rápida hoy,</strong> en lugar de una <strong>mejor a largo plazo</strong>.</p><p>Por esto, lo más recomendable es seguir los principios y referencias con criterio de arquitectura para la toma de decisiones, evitando hacerlo por la inmediatez.</p><p>Un ejemplo común ocurre en migraciones a la nube. Muchas aplicaciones de empresas son creadas para centros de datos propios y no están preparadas para la nube. Como resultado, no escalan horizontalmente y no utilizan tecnología que tenga paridad con los servicios gestionados en ese entorno. Aun así, por tiempos ajustados, las empresas suelen migrarlas sin rediseñarlas o refactorizarlas, lo que termina generando deuda técnica y encarece su corrección en el futuro.</p><h3>Conclusión</h3><p>La arquitectura empresarial y el rol del arquitecto van más allá del modelado: impulsan el cambio y promueven una forma de concebir organizaciones modernas, enfocadas en la eficiencia, la innovación y la adaptabilidad. Esta disciplina integra capacidades técnicas con visión estratégica y se convierte en un habilitador clave para el éxito de proyectos de transformación digital, consultoría y análisis organizacional.</p><p>Finalmente, se trata de diseñar soluciones que no solo sean robustas, sino también <strong>humanas y sostenibles</strong>, para asegurar que la estrategia corporativa se materialice, no como una imposición, sino como un <strong>esfuerzo colaborativo</strong> que genera valor para todos.</p><h4>Referencias para profundizar</h4><ul><li>Tanu McCabe. (2024). <em>Fundamentals of Enterprise Architecture</em></li><li>The Open Group. (2025). <em>TOGAF® Standard</em>. <a href="https://www.opengroup.org/togaf">https://www.opengroup.org/togaf</a></li><li>Zachman International. (2025). <em>Zachman Framework for Enterprise Architecture</em>. <a href="https://www.zachman.com/">https://www.zachman.com/</a></li><li>Lankhorst, M. (2017). <em>Enterprise Architecture at Work: Modelling, Communication and Analysis</em>. Springer.</li><li>Bernard, S. A. (2020). <em>An Introduction to Enterprise Architecture: Third Edition</em>. AuthorHouse.</li><li>ArchiMate®. (2024). <em>Open Group ArchiMate Standard</em>. <a href="https://www.opengroup.org/archimate-forum/archimate-overview">The ArchiMate® Enterprise Architecture Modeling Language | www.opengroup.org</a></li><li>Gartner. (2023). <em>Enterprise Architecture Trends 2023</em>. <a href="https://www.gartner.com/">https://www.gartner.com</a></li><li>Bennett, N., &amp; Lemoine, G. J. (2014). What VUCA really means for you. *Harvard Business Review*, 92(1/2), 27–42. <a href="https://hbr.org/2014/01/what-vuca-really-means-for-you">https://hbr.org/2014/01/what-vuca-really-means-for-you</a></li><li>Enterprise Arquitecture: Maximizing ROI <a href="https://fastercapital.com/content/Enterprise-Architecture--Maximizing-ROI--Enterprise-Architecture-for-Business-Optimization.html">Enterprise Architecture: Maximizing ROI: Enterprise Architecture for Business Optimization — FasterCapital</a></li><li><a href="https://www.infoq.com/articles/architecture-trends-2025/">InfoQ Software Architecture and Design Trends Report — 2025 — InfoQ</a></li><li><a href="https://cdotimes.com/2025/02/28/ai-automation-in-enterprise-architecture-the-future-of-digital-business-optimization/">AI Automation in Enterprise Architecture: The Future of Digital Business Optimization — The CDO TIMES</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=034c15114a1a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/arquitectura-empresarial-qu%C3%A9-es-y-por-qu%C3%A9-importa-m%C3%A1s-que-nunca-034c15114a1a">Arquitectura Empresarial: ¿Qué es y por qué importa más que nunca?</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[La Revolución Silenciosa del Empleado de Tecnología: ¿Es la Patineta Eléctrica el “Life Hack”…]]></title>
            <link>https://medium.com/bancolombia-tech/la-revoluci%C3%B3n-silenciosa-del-empleado-de-tecnolog%C3%ADa-es-la-patineta-el%C3%A9ctrica-el-life-hack-dfe4815469f6?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/dfe4815469f6</guid>
            <category><![CDATA[huella-de-carbono]]></category>
            <category><![CDATA[movilidad-urbana]]></category>
            <category><![CDATA[electric-vehicles]]></category>
            <dc:creator><![CDATA[Alejo]]></dc:creator>
            <pubDate>Fri, 22 May 2026 14:04:58 GMT</pubDate>
            <atom:updated>2026-05-22T14:04:57.593Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>La Revolución Silenciosa del Empleado de Tecnología: ¿Es la Patineta Eléctrica el “Life Hack” Definitivo?</strong></h3><p>En las grandes ciudades tecnológicas, el éxito de un desarrollador, analista, ingeniero de sistemas no solo se mide por sus líneas de código o sus entregas, sino por cómo gestiona su recurso más escaso: <strong>el tiempo</strong>. Mientras miles de profesionales quedan atrapados dentro del tráfico, en colombia especialmente en ciudades como Bogotá y Medellín, sobre todo Bogotá que ostenta el título de la urbe con mayor congestión en el mundo — , una nueva clase de trabajador está redescubriendo la ciudad sobre dos ruedas pequeñas impulsadas eléctricamente.</p><p>Pero, ¿es realmente una mejora integral o solo un juguete costoso? Analicemos el impacto de la movilidad eléctrica en el ecosistema del empleado actual.</p><p><strong>1. El Retorno de la Inversión (ROI) más allá del dinero</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS1yi00S0RksHi9ApDvqzg.png" /></figure><p>Para el empleado de tecnología, la patineta eléctrica no es un juguete, es una <strong>solución </strong>que optimiza la conexión entre el transporte masivo y la oficina.</p><ul><li><strong>Economía real: </strong>El costo operativo es disruptivo. El mantenimiento y el consumo eléctrico son notablemente bajos en comparación con un vehículo de combustión. La carga de la batería es similar a la de un computador portátil, lo que la hace uno de los vehículos más eficientes de la ciudad.</li><li><strong>Gestión del Tiempo:</strong> Usuarios reportan reducir trayectos de horas a solo 20 minutos constantes, ganando prever su agenda diaria.</li></ul><p><strong>2. Calidad de Vida: Del estrés a la dopamina</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VbhokKESOGw1QJqwWU4PHQ.png" /></figure><p>El impacto psicológico es quizás el beneficio más subestimado. Cambiar el encierro de una moto o carro por la agilidad de una patineta transforma los nervios iniciales en <strong>felicidad y tranquilidad</strong>. Esta sensación de libertad, sumada al fomento de una cultura activa y coordinación física, mejora el estado de ánimo antes de iniciar la jornada laboral y lo regula positivamente al finalizar.</p><p><strong>3. La “Vida Tech”: IoT, Firmware y Modding</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RUpQeRseR_1a1k0rB7FHQQ.png" /></figure><p>Aquí es donde el empleado tech se siente en casa. Las patinetas modernas son dispositivos del <strong>Internet de las Cosas (IoT)</strong> que se vinculan con apps para monitorear telemetría, nivel de batería y bloqueos remotos.</p><p>Para los entusiastas del rendimiento, existe un submundo de personalización:</p><ul><li><strong>Comunidades de Software: </strong>Grupos de usuarios y clubes comparten conocimientos sobre cómo flashear el firmware personalizado (usando herramientas como m365 DownG) para optimizar la aceleración o aumentar la velocidad máxima y ayudas de modelos estándar.</li><li><strong>Hardware Hacking: </strong>Desde instalar baterías externas para mayor autonomía hasta convertidores para elevar el voltaje, la patineta se convierte en un lienzo para la innovación técnica.</li></ul><p><strong>4. La cara B: </strong>Lo que los reviews no siempre te dicen</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X5v35tS_dBgg-kSJZKa1Yw.png" /></figure><p>No todo es color de rosa en el asfalto. La persona tech debe estar preparado para tres “bugs” principales:</p><ol><li><strong>El Clima (El enemigo #1): </strong>El agua es el mayor adversario de los circuitos eléctricos. En lluvias torrenciales, la recomendación experta es plegar el vehículo y optar por un transporte complementario.</li><li><strong>Infraestructura Hostil: </strong>Los huecos son críticos debido al tamaño de las ruedas, y la imprudencia de los conductores tradicionales sigue siendo un riesgo constante.</li><li><strong>Seguridad Física: </strong>Un descuido puede terminar en accidentes. El uso de casco y protecciones no es negociable, ya que, a diferencia de una bici, el margen de error ante un hueco invisible es menor.</li></ol><p><strong>Impacto Financiero y Ambiental</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tQEeI6oWNK9tAWKNVVitwQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gmaoyslF_uY4qUtUz4KKGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BN3LxdbLusQPq2d9LyKTKA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5wMmVU3IIPFzPtW2QH4CLA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wuVCaTLlshnExslGfoSCKg.png" /></figure><p><strong>Conclusiones para el profesional moderno</strong></p><p>Si buscas una alternativa que sea <strong>fácil, económica y amigable con el medio ambiente</strong>, la patineta eléctrica es la pieza de hardware que le falta a tu kit de productividad. Te da el control de tu tiempo, te integra a una comunidad vibrante y, sobre todo, te devuelve la alegría de moverse por la ciudad.</p><p><strong>Fuentes:</strong></p><ul><li><strong>Comunidades y Soporte:</strong><a href="https://www.reddit.com/r/ElectricScooters/"> Reddit — r/ElectricScooters</a> (Comunidad global para consultas técnicas y software).</li><li><strong>Guías de Compra:</strong><a href="https://www.bayport.com.co/"> Bayport Colombia</a> (Financiación y guías para movilidad eléctrica en Colombia).</li><li><strong>Respaldo Técnico:</strong><a href="https://www.ninebot.com.co/"><strong> </strong>Segway Ninebot Colombia</a> (Información sobre servicio técnico y repuestos oficiales).</li><li><strong>Información de Seguridad:</strong><a href="https://www.youtube.com/watch?v=Xz2hZ6A6C6E"> Club Electric Scooter</a> (Tutoriales y concientización vial)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dfe4815469f6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/la-revoluci%C3%B3n-silenciosa-del-empleado-de-tecnolog%C3%ADa-es-la-patineta-el%C3%A9ctrica-el-life-hack-dfe4815469f6">La Revolución Silenciosa del Empleado de Tecnología: ¿Es la Patineta Eléctrica el “Life Hack”…</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Diseñar librerías Flutter como producto: API, versionamiento y calidad]]></title>
            <link>https://medium.com/bancolombia-tech/dise%C3%B1ar-librer%C3%ADas-flutter-como-producto-api-versionamiento-y-calidad-8a94cc98bc6b?source=rss----6de4dfd7bc9a---4</link>
            <guid isPermaLink="false">https://medium.com/p/8a94cc98bc6b</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[español]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Juan Diego Campuzano]]></dc:creator>
            <pubDate>Mon, 11 May 2026 18:38:23 GMT</pubDate>
            <atom:updated>2026-05-11T18:38:22.053Z</atom:updated>
            <content:encoded><![CDATA[<p>Construir una librería va más allá de publicar un paquete y esperar que la comunidad lo adopte por sí solo. Una buena librería debe ser fácil de usar, confiable, extensible y, sobre todo, mantenible en el tiempo.</p><p>Este artículo está dirigido a quienes construyen o mantienen soluciones reutilizables para otros desarrolladores, y a quienes quieren empezar este proceso, ya sea que la librería sea de manejo interno, o abierta a la comunidad open source. Veremos buenas prácticas sobre estructura interna, versionamiento semántico, documentación y pruebas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n1bUlM6goEubxgMu" /><figcaption>Photo by <a href="https://unsplash.com/@halacious?utm_source=medium&amp;utm_medium=referral">Hal Gatewood</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Estructuración</h3><p>Para estructurar una librería, primero debemos definir si será principalmente visual (Flutter) o si será una herramienta de línea de comandos (Dart). En ambos casos la estructura base es similar, pero el contenido cambia bastante. Veamos un ejemplo de cómo podría verse:</p><pre>my_library/<br>|  lib/<br>|  |  src/<br>|  |  |  ...<br>|  my_library.dart </pre><p>Esto con el fin de que nuestro usuario final solo tenga que hacer lo siguiente:</p><pre>import &#39;package:my_library/my_library.dart&#39;;</pre><p>Ten en cuenta que los archivos que queden directamente dentro de lib/ (y no dentro de src/ ) serán públicos para los usuarios finales. En ese caso, se podría hacer lo siguiente:</p><pre>my_library/<br>|  lib/<br>|  |  src/<br>|  |  |  ...<br>|  my_library.dart // public file<br>|  my_custom_file.dart // ... also a public file</pre><pre>import &#39;package:my_library/my_library.dart&#39;;<br>import &#39;package:my_library/my_custom_file.dart&#39;;</pre><p>Pero entonces, ¿qué debería ir dentro de my_library.dart? Normalmente este archivo se usa como <a href="https://engineering.verygood.ventures/architecture/barrel_files/"><em>barrel file</em></a>, donde se exportan las funcionalidades que queremos exponer de la librería. Sin embargo, si la librería es muy simple, también podrías colocar allí el punto de entrada o incluso parte de la implementación.</p><p>En el caso de usar un <em>barrel file</em>, podríamos tener lo siguiente:</p><pre>my_library/<br>|  lib/<br>|  |  src/<br>|  |  |  models/<br>|  |  |  |  model_1.dart<br>|  |  |  |  model_2.dart<br>|  |  |  |  models.dart<br>|  my_library.dart</pre><pre>// models.dart<br>export &#39;model_1.dart&#39;;<br>export &#39;model_2.dart&#39;;<br><br>// my_library.dart<br>export &#39;src/models/models.dart&#39;;</pre><p>De esta forma, estaríamos cumpliendo con lo que se mencionó anteriormente.</p><p>En cuanto al contenido de la librería, la estructura puede variar de muchas formas dependiendo de la funcionalidad que queremos desarrollar. Algunos ejemplos de librerías pueden ser:</p><h4>Sistemas de diseño</h4><p>Vamos a analizar una librería de componentes muy popular que ha ido tomando fuerza, su nombre es <a href="https://pub.dev/packages/shadcn_ui"><em>shadcn_ui</em></a><em>.</em></p><p>Lo primero que podemos notar en su estructura de carpetas es que tiene un <em>barrel file </em>donde se exporta <strong>todo </strong>el contenido de la librería.</p><p><a href="https://github.com/nank1ro/flutter-shadcn-ui/blob/main/lib/shadcn_ui.dart">flutter-shadcn-ui/lib/shadcn_ui.dart at main · nank1ro/flutter-shadcn-ui</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hY2hLKZ-oXuKW4-rIPTKQg.png" /></figure><p>Lo siguiente que vemos es la estructura del proyecto, al ser una librería de componentes tiene una carpeta components/ en donde está todo el contenido principal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ANYH-NVL0jKYw32BbD3ZUw.png" /></figure><p>Esto puede ser un buen ejemplo si el objetivo es construir una librería basada en componentes visuales. También existen otras estrategias, como Atomic Design, sobre el cual ya tenemos un artículo.</p><p>Si quieres revisar más a profundidad la estructura de <em>shadcn_ui</em>, lo puedes hacer <a href="https://github.com/nank1ro/flutter-shadcn-ui">aquí</a>.</p><p><a href="https://medium.com/bancolombia-tech/c%C3%B3mo-crear-un-sistema-de-dise%C3%B1o-utilizando-atomic-design-en-flutter-6ae0962af4f3">¿Cómo crear un sistema de diseño utilizando Atomic Design en Flutter?</a></p><h4>Líneas de comando (CLI)</h4><p>Para los paquetes de líneas de comandos la estructura es diferente, ya que debemos tener un ejecutable que llame el contenido de nuestra librería.</p><pre>my_package/<br>|  bin/ &lt;- Carpeta donde va el ejecutable<br>|  |  my_package.dart<br>|  lib/<br>|  |  my_package.dart</pre><p>Para crear este tipo de paquetes se puede ejecutar el comando dart create --template=cli &lt;package_name&gt; y con esto tendremos una plantilla inicial para empezar a trabajar.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a10073fafbef4b489911f65874e40386/href">https://medium.com/media/a10073fafbef4b489911f65874e40386/href</a></iframe><h3>Buenas prácticas de código</h3><p>Cuando construimos una librería, conviene pensar en ella como si fuera un servicio remoto o una API: debe ser predecible, estable y fácil de consumir. Tus usuarios normalmente interactúan con clases y funciones que exponen parámetros para personalizar la experiencia.</p><p>El equipo de Dart mantiene una guía con buenas prácticas para diseñar librerías. Puedes revisarla <a href="https://dart.dev/effective-dart/design">aquí</a>. Veamos algunos ejemplos de lo que mencionan allí.</p><h4>API expuesta</h4><p>La forma en la que se escriben las clases, parámetros, funciones, etc… tiene un impacto en cómo los usuarios utilizan la librería en su día a día, si usamos nombres que comunican su función podemos facilitar mucho la implementación, un ejemplo:</p><pre>// Api pública<br>class TextWidget extends StatelessWidget{<br>  TextWidget({<br>    required this.text,<br>    this.isVisible = true,<br>  });<br>  <br>  final String text;<br>  final bool isVisible;<br>  <br>  // Build method<br>  ...<br>  <br>}<br><br><br>// Como lo utiliza un usuario<br>class SomeWidget extends StatelessWidget{<br>  @override<br>  Widget build(BuildContext context){<br>    return Scaffold(<br>      body: Column(<br>        children: [<br>          TextWidget(<br>            text: &#39;Hola a todos!&#39;,<br>          ),<br>        ]<br>      ),<br>    );<br>  }<br>}</pre><p>Teniendo esto en cuenta debemos entonces nombrar los parámetros de forma que para el usuario sea natural su interpretación sin necesidad de leer la documentación de la clase. Ahora veamos el ejemplo contrario:</p><pre>// Api pública<br>class TextWidget extends StatelessWidget{<br>  TextWidget({<br>    required this.text,<br>    this.textVisible,<br>  });<br>  <br>  final String text;<br>  final bool textVisible;<br>  <br>  // Build method<br>  ...<br>  <br>}<br><br><br>// Como lo utiliza un usuario<br>class SomeWidget extends StatelessWidget{<br>  @override<br>  Widget build(BuildContext context){<br>    return Scaffold(<br>      body: Column(<br>        children: [<br>          TextWidget(<br>            text: &#39;Hola a todos!&#39;,<br>            textVisible: true,<br>          ),<br>        ]<br>      ),<br>    );<br>  }<br>}</pre><p>De esta forma no es muy intuitivo para el usuario la función del parámetro textVisible ya que no expresa una intención o una acción, lo que hace que el usuario deba indagar lo que hace cada parámetro.</p><h4>Inversión de dependencias</h4><p>En el desarrollo de aplicaciones, solemos usar frameworks como GetIt o Riverpod para gestionar dependencias. Sin embargo, una librería no debe imponer su contenedor de dependencias al usuario. Hacerlo crea un acoplamiento rígido y posibles conflictos de versiones.</p><p>El enfoque correcto es utilizar <strong>Inversión de Dependencias</strong>. La librería debe definir contratos (clases abstractas) y recibir las implementaciones a través del constructor.</p><pre>// En la librería se define el contrato<br>abstract class AuthProvider {<br>  Future&lt;String?&gt; getToken();<br>}<br><br>// Clase principal de la librería<br>class MySDK {<br>  final AuthProvider authProvider;<br><br>  // El usuario puede pasar su propia implementación<br>  MySDK({required this.authProvider});<br>}</pre><p>Gracias a esto las librerías no quedarán acopladas a implementaciones concretas lo que expande su utilidad y transversabilidad a la hora de usarse. De no ser así, cada usuario debería buscar la forma de integrar su implementación en el código fuente de la librería.</p><h4>Documentación</h4><p>Escribir buena documentación en las clases y parámetros también ayuda que la implementación sea mas amigable, Dart ofrece una herramienta para generar documentación en HTML que luego podemos publicar, la herramienta es <a href="https://pub.dev/packages/dartdoc">dart_doc</a>. Un ejemplo de cómo documentar puede ser:</p><pre>/// Analiza cadenas con un formato específico y devuelve un mapa clave-valor.<br>///<br>/// [input] debe estar en el formato `key=value;key=value`.<br>/// Retorna un `Map&lt;String, String&gt;` con las parejas parseadas.<br>///<br>/// Lanza [FormatException] si la cadena es inválida.<br>///<br>/// ### Ejemplo<br>/// ```dart<br>/// final parser = Parser();<br>/// final data = parser.parse(&#39;user=juan;role=admin&#39;);<br>/// // data == {&#39;user&#39;: &#39;juan&#39;, &#39;role&#39;: &#39;admin&#39;}<br>/// ```<br>///<br>/// Desde: v2.4.0<br>class Parser {<br>  /// Si es `true`, activa el nuevo algoritmo de parsing.<br>  ///<br>  /// Valor por defecto: `false`. Será `true` por defecto desde v2.6<br>  /// y el algoritmo anterior se eliminará en v3.0.<br>  final bool enableNewParser;<br><br>  const Parser({this.enableNewParser = false});<br><br>  Map&lt;String, String&gt; parse(String input) {<br>    if (input.trim().isEmpty) {<br>      throw const FormatException(&#39;La cadena no puede estar vacía&#39;);<br>    }<br>    return enableNewParser ? _parseNew(input) : _parseLegacy(input);<br>  }<br><br>  Map&lt;String, String&gt; _parseLegacy(String input) { /* ... */ return {}; }<br>  Map&lt;String, String&gt; _parseNew(String input) { /* ... */ return {}; }<br>}<br><br>/// @deprecated Usa [Parser] con `enableNewParser`.<br>@Deprecated(&#39;Se eliminará en v3.0.0. Usa Parser(enableNewParser: true).&#39;)<br>Map&lt;String, String&gt; parseLegacy(String input) =&gt; {};</pre><h3>Calidad y pruebas automatizadas</h3><p>No se puede confiar mucho en una librería que no se prueba a sí misma. Es importante verificar constantemente su integridad, tanto si es una librería de componentes visuales como si contiene lógica.</p><p>En ambos casos puedes usar el framework de pruebas que viene con el SDK de Flutter: flutter_test. Este incluye utilidades para probar tanto la lógica como la parte visual de los componentes.</p><h4>Golden Tests</h4><p>Como ya hablamos en un artículo anterior, las golden tests son pruebas de regresión visual que le ayudan a los desarrolladores y dueños de producto estar verificando que la capa visual de una aplicación y/o componentes se mantenga en el tiempo, y que no se introduzcan cambios intencionados y rompan esa capa visual. Aquí te muestro un ejemplo de cómo se implementan este tipo de pruebas con la librería <a href="https://pub.dev/packages/bc_golden_plugin">bc_golden_plugin</a>.</p><pre>BcGoldenCapture.single(<br>    &#39;Single test&#39;,<br>    (tester) async {<br>      await bcWidgetMatchesImage(<br>        imageName: &#39;golden_single&#39;,<br>        widget: const HomePage(title: &#39;Flutter Demo Home Page&#39;),<br>        tester: tester,<br>        device: GoldenDeviceData.galaxyS25,<br>      );<br>    },<br>);</pre><p>Si quieres saber mas sobre este tipo de pruebas puedes leer el siguiente artículo:</p><p><a href="https://medium.com/bancolombia-tech/utilizando-golden-tests-como-herramienta-de-qa-visual-91ef96cb8ed0">Utilizando Golden Tests como herramienta de QA visual.</a></p><h4>Unit tests</h4><p>Unit tests validan la lógica de negocio de forma aislada: son rápidos, determinísticos y no dependen de UI, red, disco ni estado global.</p><ul><li><strong>Una buena regla:</strong> si la clase/función no necesita package:flutter/material.dart ni el motor de renderizado, es candidata a unit test. Si involucra widgets, layout o <em>paint</em>, entonces encaja mejor en widget tests (y para ver cambios visuales, en golden tests).</li></ul><p>En librerías, los unit tests son el corazón de la estabilidad del API, capturan el comportamiento público, permiten refactorizar con confianza y reducen el riesgo de <em>breaking changes</em>.</p><p>Algunas buenas prácticas:</p><ul><li>Nombra los tests por comportamiento: whenX_shouldY.</li><li>Estructura: <em>Arrange–Act–Assert</em> o <em>Given–When–Then</em>.</li><li>Cobertura: cubre los casos felices y <em>edge cases</em>. Apunta a +80% de cobertura del código.</li></ul><pre>import &#39;package:test/test.dart&#39;;<br><br>void main(){<br>  test(&#39;When String.trim(), should remove surrounding whitespace&#39;, () {<br>    var string = &#39;  foo &#39;;<br>    expect(string.trim(), equals(&#39;foo&#39;));<br>  });<br>}</pre><h4>Seguridad</h4><p>Una librería que no considera la seguridad como parte de su diseño puede convertirse en el eslabón débil de todas las apps que la consumen.</p><p>Los plugins que incluyen permisos en su AndroidManifest.xml o Info.plist los heredan todas las apps que los consumen. Revisa que tu librería no declare accesos innecesarios a cámara, ubicación o almacenamiento, y documenta explícitamente los que sí requiere.</p><p>Si la librería necesita tokens, URLs de entorno o claves de API, recíbelos como parámetros de inicialización o a través de String.fromEnvironment() con --dart-define en tiempo de build. Nunca los <em>hardcodees</em>.</p><pre>class MySDK {<br>  MySDK({required this.baseUrl, required this.apiKey});<br><br>  final String baseUrl;<br>  final String apiKey;<br>}</pre><p>Una librería no es el objetivo final, pero sí puede ser el vector. El <a href="https://owasp.org/www-project-mobile-top-10/">OWASP Mobile Top 10</a> documenta las vulnerabilidades más frecuentes en apps móviles, y categorías como <em>Insecure Data Storage</em>, <em>Improper Credential Usage</em> o <em>Insufficient Supply Chain Security</em> aplican directamente a decisiones de diseño que tomamos al construir librerías.</p><h3>Versionamiento</h3><p>Es importante definir cómo vamos a versionar nuestra librería incluso antes de empezar a desarrollarla. Existen varias estrategias de versionamiento entre ellas está <a href="https://calver.org/"><em>Calendar Versioning</em></a><em> </em>la cual es recomendada para sistemas y frameworks muy grandes, pero para el caso de librerías se recomienda el uso de <a href="https://semver.org/lang/es/"><em>Semantic Versioning</em></a><em>. </em>Este versionamiento también se puede automatizar con herramientas como</p><p><a href="https://github.com/semantic-release/semantic-release">GitHub - semantic-release/semantic-release: :package::rocket: Fully automated version management and package publishing</a></p><p>que se encargan de generar el CHANGELOG.md basandose en los commits que se integraron a la rama principal del repositorio.</p><p>Mantener un buen registro de los cambios también es importante ya que con esto los usuarios pueden planear si subir la versión de la librería y no les va a implicar alguna reproceso. Veamos un ejemplo de un <strong>mal</strong> CHANGELOG:</p><pre>### [1.0.0]<br>- fix: se hacen cambios # ¿qué cambios?<br>- feat: se agrega nueva funcionalidad # ¿qué funcionalidad?<br>- fix # 🤔</pre><p>Ahora veamos algo más elaborado:</p><pre>### [1.0.0] !12345 &lt;- número del pull request<br>- feat(button): nuevo parametro `color` para cambio de color<br>- fix(input): corrección del foco al iniciar pantalla</pre><p>Este es solo un pequeño ejemplo de cómo podría verse un buen CHANGELOG, lo importante es ser muy descriptivo y conciso de forma que el usuario sepa los cambios que trae una nueva versión. Aquí dejo el <a href="https://github.com/flutter/flutter/blob/master/CHANGELOG.md">CHANGELOG</a> de Flutter como ejemplo.</p><p>Ahora bien, en cuanto al manejo de ramas, hay muchas opciones. Además, dependiendo del equipo de trabajo y de qué tan seguido se vayan a lanzar versiones a producción, conviene usar una metodología u otra. He visto que se utiliza mucho <strong>Trunk-Based Development (TBD)</strong> con ramas release en el caso de librerías, entonces podríamos tener lo siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*Xz_k4xysKqi9LLGLtRJ70w.png" /><figcaption>Ejemplo Trunk-Based Development con Release Branches</figcaption></figure><p>En este ejemplo podemos ver que hay una rama principal llamada Trunk, y que de esta rama salen ramas Feature y Release , las ramas feature son para integrar funcionalidades nuevas, ya sea la evolución de algo existente o se está agregando algo completamente nuevo, incluso, la rama Trunk se considera como una rama inestable, ya que allí pueden haber cambios <strong>breaking </strong>que van a ser desplegados en una versión <em>major </em>posterior. Pero, en este ejemplo ¿cómo puedo evitar integrar un cambio breaking si ese cambio aún no está listo para que los usuarios lo consuman? Esto es muy importante tenerlo en cuenta ya sea para librerías externas o internas, ya que puede generar fricciones entre los desarrolladores, impactando el <strong>Time-To-Market</strong> y la experiencia del desarrollador.</p><p><a href="https://medium.com/bancolombia-tech/feature-flags-de-la-teor%C3%ADa-a-la-pr%C3%A1ctica-a5321db1b513"><em>Feature Flags</em></a> es una técnica que permite activar o desactivar funcionalidades sin necesidad de publicar una nueva versión de la aplicación. En librerías de Flutter, usar banderas de forma simple y localizada es especialmente útil para el versionado: te permite introducir nuevos comportamientos como <a href="https://dictionary.cambridge.org/dictionary/english/opt-in#:~:text=the%20fact%20of%20choosing%20to%20take%20part%20in%20an%20activity%2C%20arrangement%2C%20etc.%20rather%20than%20being%20forced%20to%20take%20part%3A"><em>opt‑in</em></a>, evitar <em>breaking changes</em> y ofrecer una ruta de migración gradual. No se necesita una plataforma compleja de <em>feature flags</em>; basta con exponer <strong>t</strong>oggles claros en la API pública, documentar sus valores por defecto y el plan de retiro. Algunas formas de implementarlo pueden ser:</p><ul><li>Utilizar el decorador @Deprecated que ofrece Dart.</li></ul><pre>@Deprecated(&quot;Este componente se encuentra deprecado.&quot;)<br>class Button extends StatelessWidget{<br>  final String text;<br>  final VoidCallback onPressed;<br>  <br>  Button({required this.text, required this.onPressed});<br>}</pre><ul><li>Realizar cambios con compatibilidad hacia atrás<em>, </em>para darle tiempo a los usuarios de actualizar su implementación.</li></ul><pre>class Button extends StatelessWidget{<br>  @Deprecated(&quot;Parámetro deprecado, usar `content`&quot;)<br>  final String text;<br>  final Widget? content;<br>  final VoidCallback onPressed;<br>  <br>  Button({required this.text, required this.onPressed, this.content});<br><br>  @override<br>  Widget build(BuildContext context){<br>    return ElevatedButton(<br>      child: content != null ? content : Text(text),<br>      onPressed: onPressed<br>    );<br>  }<br>}</pre><ul><li>Si un componente aún no está listo para salir a producción, se puede poner como privado o simplemente no exportarlo en los <em>barrel files, </em>para que los usuarios no lo puedan ver y/o utilizar.</li></ul><h3>Automatizaciones con IA</h3><p>Ya que estamos en el auge de la inteligencia artificial, aquí también dejo algunos tips o consejos que pueden ayudar a mejorar la experiencia del desarrollador cuando se usan ayudas de agentes inteligentes.</p><h4>Copilot instructions o <a href="https://agents.md/">AGENTS.md</a></h4><p>Esto puede servir a la hora de desarrollar librerías o aplicaciones, el objetivo de estos archivos es declarar una serie de reglas que el agente va a inyectar en su ventana de contexto cada que se envíe un prompt, por eso es muy importante no extenderse mucho con estas reglas. En la <a href="https://docs.flutter.dev/ai/ai-rules#device-editor-specific-limits">documentación de Flutter</a> especifican los límites que tiene cada IDE.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*ogRoUUilAjX5t6PmY-3l_w.png" /></figure><p>Un ejemplo de cómo podría verse un archivo de instrucciones curado a 1000 tokens sería:</p><pre># Flutter AI Rules<br>**Role:** Expert Dev. Premium, beautiful code.<br>**Tools:** `dart_format`, `dart_fix`, `analyze_files`.<br>**Stack:**<br>* **Nav:** `go_router` (Type-safe).<br>* **State:** `ValueNotifier`. NO Riverpod/GetX.<br>* **Data:** `json_serializable` (snake_case).<br>* **UI:** Material 3, `ColorScheme.fromSeed`, Dark Mode.<br>**Code:**<br>* **SOLID**.<br>* **Layers:** Pres/Domain/Data.<br>* **Naming:** PascalTypes, camelMembers, snake_files.<br>* **Async:** `async/await`, try-catch.<br>* **Log:** `dart:developer` ONLY.<br>* **Null:** Sound safety. No `!`.<br>**Perf:**<br>* `const` everywhere.<br>* `ListView.builder`.<br>* `compute()` for heavy tasks.<br>**Testing:** `flutter test`, `integration_test`.<br>**A11y:** 4.5:1 contrast, Semantics.<br>**Design:** &quot;Wow&quot; factor. Glassmorphism, shadows.<br>**Docs:** Public API `///`. Explain &quot;Why&quot;.</pre><h4><a href="https://agentskills.io/home">Skills</a></h4><p>A diferencia de los <em>instructions</em>, una <em>skill</em> no es solo una función, sino un conjunto de instrucciones, mejores prácticas y flujos de trabajo que le enseñan al agente <em>cómo</em> usar las herramientas para resolver un problema complejo. Por ejemplo una skill para crear un componente dentro de una aplicación:</p><pre>---<br>name: generate-feature<br>description: Genera un nuevo feature (componente) dentro del proyecto Flutter, creando la estructura de carpetas, archivos de páginas, widgets, modelos y rutas siguiendo las convenciones existentes del proyecto. Usar cuando el usuario pida crear un feature, módulo, pantalla o componente nuevo, o cuando mencione agregar una nueva sección a la app.<br>---<br><br># Generar Feature en &lt;Proyecto&gt;<br><br>## Arquitectura del proyecto<br><br>El proyecto usa una arquitectura **feature-first** con las siguientes capas opcionales por feature:<br><br>```<br>lib/features/&lt;feature_name&gt;/<br>├── &lt;feature_name&gt;_route.dart          # Rutas go_router del feature (siempre)<br>├── presentation/<br>│   ├── &lt;feature_name&gt;_page.dart       # Página principal (siempre)<br>│   ├── &lt;otra&gt;_page.dart               # Páginas secundarias (opcional)<br>│   └── widgets/                       # Widgets locales (opcional)<br>│       └── &lt;widget_name&gt;.dart<br>└── domain/                            # Solo si hay modelos<br>    └── models/<br>        └── &lt;model_name&gt;.dart<br>```<br><br>**No existe** capa `data/` en ningún feature. No hay repositorios ni datasources implementados.<br><br>## Convenciones<br><br>### Nomenclatura de archivos<br>- Archivos: `snake_case`<br>- Páginas: sufijo `_page.dart` → clase `PascalCasePage` como `StatelessWidget` o `StatefulWidget`<br>- Rutas: sufijo `_route.dart` → variable `camelCaseRoutes` de tipo `List&lt;RouteBase&gt;`<br>- Widgets: nombre descriptivo `snake_case.dart` → clase `PascalCase`<br>- Modelos: nombre singular `snake_case.dart` → clase `PascalCase`<br><br>### Estado<br>No se usa gestión de estado externa (no Bloc, no Riverpod, no Provider). Solo `StatefulWidget` + `setState()`.<br><br>### Navegación<br>- `go_router` exclusivamente<br>- Navegación con `context.go()` (reemplazo) y `context.push()` (apilado)<br>- Rutas como strings planos: `/&lt;feature&gt;`, `/&lt;feature&gt;/&lt;sub_page&gt;`<br><br>### Dependencias principales<br>- `go_router` para navegación<br>- `google_fonts` para tipografía<br>- No hay barrel files ni exports centralizados<br><br>## Proceso paso a paso<br><br>### 1. Crear la estructura de carpetas<br><br>Crear el directorio del feature y sus subcarpetas:<br><br>```<br>lib/features/&lt;feature_name&gt;/<br>lib/features/&lt;feature_name&gt;/presentation/<br>```<br><br>Si el feature necesita widgets locales:<br>```<br>lib/features/&lt;feature_name&gt;/presentation/widgets/<br>```<br><br>Si el feature necesita modelos:<br>```<br>lib/features/&lt;feature_name&gt;/domain/models/<br>```<br><br>## Checklist final<br><br>- [ ] Carpetas creadas con la estructura correcta<br>- [ ] Página principal del feature creada con `StatelessWidget` o `StatefulWidget`<br>- [ ] Páginas secundarias creadas (si aplica)<br>- [ ] Widgets locales creados en `presentation/widgets/` (si aplica)<br>- [ ] Modelos creados en `domain/models/` (si aplica)<br>- [ ] Archivo `_route.dart` creado con las rutas del feature<br>- [ ] Import agregado en `lib/core/config/routes.dart`<br>- [ ] Spread de rutas agregado en la posición correcta (dentro o fuera de `ShellRoute`)</pre><h4><a href="https://arxiv.org/pdf/2602.00180">Spec-Driven Development</a></h4><p>Es una nueva metodología que ha ido tomando fuerza, en dónde la “fuente de la verdad” no es el código si no uno o varios documentos de especificaciones formales. Con esto entonces se busca que el agente se encargue del código y el desarrollador solo debe definir los requerimientos, diseño y tareas que debe realizar el LLM.</p><p>Esto se puede aplicar en el desarrollo de librerías y/o aplicaciones, ya sea que queramos agregar una funcionalidad nueva, o evolucionar una existente. En el siguiente <a href="https://medium.com/@juan-campuzano/m%C3%A1s-all%C3%A1-del-prompt-spec-driven-development-25bac20edd6a">artículo</a> hablo mas sobre este tema.</p><h3>Conclusiones</h3><p>Construir una librería es, en el fondo, un ejercicio de empatía con el desarrollador que la va a consumir, que muchas veces eres tú mismo en seis meses. Una API predecible, un historial de cambios honesto, pruebas que respalden cada versión y decisiones de seguridad tomadas desde el diseño son lo que separa un paquete útil de uno que genera más preguntas que respuestas. Si este artículo te dio puntos de partida concretos, el siguiente paso es aplicarlos en la próxima librería que construyas o mantengas.</p><p>Si quieres ver más artículos de Bancolombia Tech aquí está el enlace del sitio.</p><p><a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a></p><h3>Referencias</h3><ul><li><a href="https://martinfowler.com/articles/branching-patterns.html">Patterns for Managing Source Code Branches</a></li><li><a href="https://dart.dev/effective-dart">Effective Dart</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a94cc98bc6b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bancolombia-tech/dise%C3%B1ar-librer%C3%ADas-flutter-como-producto-api-versionamiento-y-calidad-8a94cc98bc6b">Diseñar librerías Flutter como producto: API, versionamiento y calidad</a> was originally published in <a href="https://medium.com/bancolombia-tech">Bancolombia Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>