<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ricardo Carrasco P on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Carrasco P on Medium]]></description>
        <link>https://medium.com/@ricardo.carrasco.p?source=rss-70d70efefc8e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WsGfhY1C2p9WPCYaXYTlfA.jpeg</url>
            <title>Stories by Ricardo Carrasco P on Medium</title>
            <link>https://medium.com/@ricardo.carrasco.p?source=rss-70d70efefc8e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:25:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ricardo.carrasco.p/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[El dilema del desarrollador: la deuda técnica y la hipoteca del sistema]]></title>
            <link>https://medium.com/@ricardo.carrasco.p/el-dilema-del-desarrollador-la-deuda-t%C3%A9cnica-y-la-hipoteca-del-sistema-08c9858c4860?source=rss-70d70efefc8e------2</link>
            <guid isPermaLink="false">https://medium.com/p/08c9858c4860</guid>
            <dc:creator><![CDATA[Ricardo Carrasco P]]></dc:creator>
            <pubDate>Thu, 02 Apr 2026 19:32:33 GMT</pubDate>
            <atom:updated>2026-04-02T20:52:41.083Z</atom:updated>
            <content:encoded><![CDATA[<p>En el desarrollo de software, la velocidad no es gratis. Cada vez que “tomamos un atajo” para cumplir con una fecha, no estamos siendo más eficientes; estamos pidiendo un préstamo. Al firmar esta <strong>hipoteca técnica</strong> que nos da liquidez hoy — funcionalidad entregada, nuevos negocios, usuarios contentos — a cambio de un compromiso de pago futuro que, si no se gestiona, termina en un embargo operativo.</p><p>A mi juicio el problema surge cuando este mecanismo se vuelve invisible para quienes toman las decisiones de negocio. Para un cliente o un stakeholder, el software es solo lo que puede usar. Todo lo que ocurre “tras bambalinas” se percibe como un costo oculto que no aporta valor. Sin embargo, ignorar estos elementos es equivalente a construir un edificio ahorrando en la calidad de los materiales o reduciendo el espesor de los muros de carga en una zona de alto riesgo sísmico. El ahorro inicial es una ilusión peligrosa: la pérdida total de la inversión es real y ocurrirá ante el primer evento de estrés del sistema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uD8zyitcoVOTXcLY3eyrJA.png" /></figure><h4>El dilema del desarrollador</h4><p>Aquí radica el verdadero dilema: una tensión constante entre la responsabilidad ética de no descuidar la integridad técnica y la necesidad vital de entregar funcionalidad que mantenga al negocio competitivo.</p><p>Este conflicto trasciende al software. Es el mismo que enfrenta un ingeniero de manufactura al decidir entre detener la línea para mantenimiento o cumplir la cuota del día; o un financiero entre liquidez inmediata y solvencia a largo plazo.</p><p>Otro ejemplo más “visual” de esta dinámica la veo en la Fórmula 1 (sí, me declaro culpable, soy fan), El equipo que gana es el que logra una sincronía perfecta entre una ingeniería potente y refinada, y la ejecución precisa del piloto. Durante la temporada, el vehículo se evoluciona constantemente para asegurar que la máquina responda exactamente cuando se le exige el máximo rendimiento. Si el equipo ignora un fallo estructural por priorizar la velocidad inmediata, esa deuda técnica terminará fatigando el sistema. En el software, como en la pista, la falta de refinamiento te quita capacidad de respuesta: puedes ser el más rápido en la recta inicial, pero pierdes la carrera en las curvas porque tu base técnica, descuidada por la prisa, ya no le permite al piloto maniobrar ni reaccionar cuando la competencia exige un cambio de ritmo.</p><p>En nuestra industria, la diferencia es que la degradación es invisible: no hay piezas oxidadas ni humo, solo desarrolladores que cada día caminan más lento sobre un pantano de código. No se trata de elegir un bando, sino de gestionar una contradicción: si priorizamos solo la velocidad, quebramos por deuda; si priorizamos solo la perfección, nos volvemos irrelevantes. El desafío profesional no es evitar el préstamo, sino saber exactamente cuánto podemos pedir antes de perder el control del sistema.</p><h4>Velocidad e Interés compuesto</h4><p>Muchos equipos caen en la trampa de creer que pueden mantener un ritmo frenético de entregas indefinidamente. Es lo que se conoce en la industria como el <strong>Teorema de la Velocidad </strong>(popularizado por el mítico Uncle Bob): al inicio de un proyecto, la velocidad es máxima porque el terreno está limpio y no hay fricciones. A medida que acumulamos deuda técnica, empezamos a generar intereses que se pagan con el recurso más escaso de una empresa: el tiempo de sus desarrolladores.</p><p>Cada nueva funcionalidad requiere ahora navegar por código eventualmente muy acoplado, corregir efectos colaterales inesperados y lidiar con parches que nadie se atreve a tocar por miedo a romper el frágil equilibrio del sistema. Con el tiempo, el interés compuesto de la deuda es tan alto que el equipo podría entrar en una parálisis operativa: el 90% del esfuerzo se destina a mantener el sistema con respirador artificial y solo un 10% a entregar funcionalidad e innovación. En este punto, el sistema ha quebrado técnicamente.</p><h4><strong>El cuadrante de Fowler</strong></h4><p>Para gestionar el riesgo, primero hay que dejar de tratar la deuda como un error y empezar a tratarla como una decisión. <strong>Martin Fowler</strong>, referente mundial en arquitectura de software y diseño de sistemas, propone una matriz que nos permite diagnosticar la salud estructural del proyecto cruzando dos ejes: <strong>Intención</strong> (Deliberada vs. Inadvertida) y <strong>Actitud</strong> (Prudente vs. Imprudente).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kbEUeOBTTo9GvTQASQw9_g.png" /></figure><ul><li><strong>Prudente y Deliberada:</strong> esta situación representa una <strong>decisión de negocio ejecutiva</strong> donde se acepta conscientemente un diseño sub-óptimo a cambio de una <strong>ventaja competitiva inmediata</strong>. Por ejemplo, cuando se lanza una integración con una pasarela de pagos para cumplir con un evento de alta demanda como el CyberDay, aunque el código no sea elegante. El riesgo es manejable siempre que se establezca una <strong>fecha de caducidad</strong>; si el parche sobrevive a la urgencia inicial sin ser refactorizado, la agilidad ganada se convierte en una hipoteca que asfixia el desarrollo futuro.</li><li><strong>Imprudente y Deliberada:</strong> aquí el <strong>equipo</strong> es plenamente <strong>consciente</strong> de que está <strong>comprometiendo la integridad del sistema</strong>, pero lo hace por una falsa sensación de urgencia o presión externa. Al ignorar principios de seguridad o saltarse pruebas unitarias para entregar algo que solo “parece” terminado, <strong>se generan intereses altísimos</strong>. Lo que se ahorra hoy en tiempo de desarrollo se pagará con creces en soporte técnico, corrección de errores en producción y una degradación acelerada de la reputación del equipo, reflejando una disfunción en la cultura de ingeniería donde el desarrollador pierde su rol de garante estructural.</li><li><strong>Prudente e Inadvertida:</strong> este escenario es el <strong>costo inevitable</strong> del <strong>aprendizaje</strong> y el descubrimiento del producto. Ocurre cuando diseñamos una arquitectura que era la mejor opción posible con la información disponible hace seis meses, pero el éxito del negocio o un cambio en el volumen de datos revela que el diseño original ha quedado pequeño. No se trata de un error de ejecución, sino de la evolución natural del software; requiere la <strong>humildad técnica</strong> de reconocer que lo construido ayer con orgullo hoy debe ser reemplazado para soportar la nueva realidad del dominio.</li><li><strong>Imprudente e Inadvertida:</strong> es la forma más <strong>peligrosa</strong> de deuda porque se acumula de manera silenciosa por falta de estándares o procesos de revisión de pares. Ocurre cuando se construye sobre supuestos técnicos erróneos por <strong>falta de experiencia</strong>, contaminando el núcleo del sistema sin que nadie lo note hasta que es demasiado tarde. Siguiendo la analogía de la construcción, es la deuda que genera las grietas estructurales imposibles de ignorar: no sabes que debes dinero hasta que el edificio empieza a desgastarse o el <strong>sistema colapsa</strong> ante un evento sísmico de estrés.</li></ul><h4>Por qué lo invisible se ignora</h4><p>Si sabemos que la deuda es peligrosa, ¿por qué la mayoría de los proyectos medianos y pequeños terminan sobre-endeudados? La respuesta podría estar no en la falta de capacidad técnica, sino en una serie de sesgos cognitivos que actúan como una capa de invisibilidad sobre el riesgo real. Estos sesgos distorsionan nuestra percepción del valor y nos empujan a tomar decisiones que, aunque parecen lógicas en el momento, son suicidas a largo plazo:</p><ul><li><strong>Sesgo de presente:</strong> este sesgo nos inclina a valorar de forma desproporcionada las recompensas inmediatas frente a los beneficios futuros. En el desarrollo, se manifiesta cuando la gratificación de ver una funcionalidad “en producción” hoy eclipsa la estabilidad del sistema en seis meses. El negocio siempre sentirá la urgencia del ingreso inmediato, y este sesgo nubla el juicio profesional: aceptamos omitir validaciones críticas o ignorar estándares de diseño para cerrar una entrega. Es la preferencia por un “flujo de caja” de funcionalidades rápido, a costa de comprometer la solvencia estructural que debería permitir al software adaptarse a los cambios del próximo año sin colapsar.</li><li><strong>La falacia del costo hundido:</strong> es la resistencia emocional a abandonar una inversión que ya no es rentable. En software, esto ocurre cuando nos aferramos a módulos o arquitecturas mal diseñadas simplemente porque “ya invertimos tres meses en ellas”. En lugar de aceptar que esa pieza es un error y debe ser reconstruida desde los cimientos para evitar que contamine el resto del sistema, el equipo prefiere seguir parchando la estructura herida. Se gasta más tiempo intentando que lo malo funcione que lo que tomaría admitir la pérdida y diseñar una solución sólida. El orgullo del desarrollador y el miedo al “desperdicio” de horas hombre terminan multiplicando el costo final por diez.</li><li><strong>Ceguera de taller y normalización del desvío:</strong> este es quizás el sesgo más insidioso en equipos establecidos. Cuando un sistema presenta errores “pequeños” o advertencias en los logs todos los días, el equipo desarrolla una tolerancia peligrosa. Lo que inicialmente era una alerta roja se convierte en parte del día a día; los cables sueltos y los parches temporales se aceptan como el estándar operativo. Esta normalización hace que el riesgo estructural sea invisible: el equipo deja de sentir el peligro de la deuda acumulada porque se ha acostumbrado a trabajar entre escombros técnicos. El riesgo de un colapso no desaparece porque dejes de mirarlo; simplemente se ignora hasta que una carga de tráfico inusual o un cambio crítico revela que la estructura ya no tiene capacidad de soporte.</li></ul><h4>¿Y que dicen los gigantes tecnológicos?</h4><p>Este no es un problema de “equipos pequeños”. Google, por ejemplo, tiene documentado su enfoque de Site Reliability Engineering (SRE), donde utilizan el concepto de “Presupuesto de Error”. Si el equipo de desarrollo consume su presupuesto de estabilidad cometiendo errores o acumulando deuda, el negocio detiene automáticamente las nuevas funcionalidades hasta que la salud del sistema se restaura. Empresas como Amazon o Netflix no evitan la deuda; la gestionan como un activo financiero, entendiendo que la “deuda inadvertida” es el enemigo silencioso que ha causado caídas de servicios globales y pérdidas millonarias en minutos.</p><h4>OK, …seamos sinceros</h4><p>¿Si aceptamos que el error es inevitable, la deuda técnica también lo es? Para evitar el colapso y la frustración que quema a los mejores, necesitamos iniciativas reales que generen una resistencia cultural contra la degradación técnica:</p><ul><li><strong>Visibilidad:</strong> dejemos de hablar de “código limpio”. Hablemos de “riesgo de pérdida total”. Si el cliente entiende que el ahorro en materiales pone en peligro toda su inversión, la prioridad cambia de color.</li><li><strong>El Impuesto:</strong> quizás podríamos establecer un porcentaje no negociable (ej. 20%) de la capacidad del equipo para pagar capital técnico. No es opcional; es el costo de mantener la oficina abierta y operativa.</li><li><strong>ADRs (Architecture Decision Records):</strong> si vamos a tomar un atajo, que quede por escrito. Quién tomó la decisión, por qué y cuál es el riesgo asumido. La deuda deliberada debe ser rastreable.</li><li><strong>El rigor del DoD (Definición de Terminado):</strong> no se entrega nada que no cumpla con un mínimo de integridad. Si no hay tests unitarios básicos o la cobertura es nula, la tarea simplemente no está hecha.</li><li><strong>Pareto (80/20):</strong> no busquemos la perfección en todo. Identifiquemos los módulos por donde pasa el 80% del tráfico y asegúrate de que esos, al menos, sean de acero reforzado.</li><li><strong>Métricas:</strong> midamos cuánto tiempo toma hoy desarrollar una historia de usuario promedio versus cuánto tomaba hace seis meses. Si la curva sube, los intereses han subido demasiado.</li><li><strong>Responsabilidad profesional:</strong> a mi juicio el más importante, el desarrollador debe dejar de ser un “tomador de requerimientos”. Es nuestra responsabilidad técnica advertir y documentar las consecuencias de un atajo. Si permites que se ignore la calidad sin protestar, estás aceptando la culpa del fallo futuro. Hay que exigir que el stakeholder acepte el riesgo formalmente para que, cuando el sistema falle, no se busquen culpables en el equipo de ejecución por algo que fue una decisión de negocio.</li><li><strong>Revisiones:</strong> el <em>Code Review</em> no es un trámite administrativo ni una charla de café. Es el punto de control donde se <strong>exige</strong> el cumplimiento del estándar de ingeniería de la empresa. Si el código no respeta la arquitectura definida o los criterios de calidad acordados, no se aprueba. El revisor es el último filtro de seguridad antes de comprometer la integridad del sistema.</li><li><strong>Re-calibrar:</strong> lo sé, es dificil, pero cada cierto tiempo, la entrega de funcionalidades debe detenerse para reforzar los cimientos. Es el mantenimiento preventivo necesario para no tener que cerrar por reparaciones mayores (y más caras) después.</li><li><strong>Liderazgo protector:</strong> se necesita un líder que sepa cuándo negociar y cuándo defender la calidad del sistema con su vida. Alguien que entienda que su labor no es solo entregar, sino proteger la integridad del activo más valioso de la empresa: su software.</li></ul><p>Entender la deuda técnica no significa caer en el dogmatismo. Como ingenieros, nuestra labor no es escribir código perfecto en un vacío, sino gestionar un activo financiero tecnológico. Si nos atrincheramos en el purismo técnico, nos convertimos en un bloqueo para la supervivencia de la empresa. La verdadera maestría está en el <strong>pragmatismo negociado</strong>: saber cuándo pedir un préstamo para ganar una oportunidad de mercado y cuándo es imperativo pagar la deuda para evitar el embargo.</p><p>Proteger la integridad del activo más valioso de la empresa: su software. Pero esta protección no puede ser un bloqueo; debe entender también lo que el negocio necesita para sobrevivir</p><h4>Lo que necesita el negocio</h4><p>Un desarrollador que bloquea un release necesario por una “perfección técnica” es tan peligroso para la empresa como la deuda misma. La ingeniería es el arte de los compromisos, y para negociar con éxito, debemos entender qué mueve la aguja del producto:</p><ul><li><strong>Costo de oportunidad:</strong> a veces, el costo de no estar en el mercado hoy es infinitamente mayor que el costo de refactorizar mañana. Si una funcionalidad nos permite capturar un contrato crítico o validar una hipótesis de negocio, la deuda técnica es una inversión necesaria. No entregar es el riesgo más alto de todos.</li><li><strong>Validación temprana:</strong> no tiene sentido construir una catedral de código para una funcionalidad que no sabemos si el usuario usará. El pragmatismo nos dicta construir el “Mínimo Producto Viable” técnicamente aceptable para recoger datos reales antes de invertir en una arquitectura de alta disponibilidad.</li><li><strong>Ventaja competitiva:</strong> en empresas medianas, la agilidad es la única arma contra los gigantes. Si el rigor técnico nos vuelve lentos y burocráticos, perdemos nuestra principal ventaja. El código perfecto en una empresa en quiebra no sirve a nadie.</li><li><strong>Rentabilidad:</strong> existe un punto de retornos decrecientes en la calidad. Pasar de un 80% a un 99% de cobertura de tests puede duplicar el tiempo de desarrollo sin reducir significativamente el riesgo de negocio. Debemos saber cuándo el software es lo suficientemente sólido para cumplir su misión.</li><li><strong>El valor:</strong> no todo el código tiene la misma importancia. La energía del equipo debe estar en el núcleo del producto que genera ingresos. Ser excesivamente purista en módulos administrativos o internos que nadie ve es un desperdicio de recursos financieros.</li></ul><h4>¿Es que acaso nadie va a hablar de la IA?</h4><p>En el escenario actual, la Inteligencia Artificial ha introducido una nueva variable en la ecuación. Herramientas de generación de código nos permiten producir volumen a una velocidad sin precedentes, pero aquí acecha una trampa: <strong>la IA es excelente generando funcionalidad, pero es ciega ante la deuda técnica estructural.</strong></p><p>Si usamos la IA solo para “escribir más rápido”, lo que estamos haciendo es acelerar la acumulación de intereses. Un código generado por IA que no pasa por el filtro de la autoridad técnica del desarrollador es, por definición, <strong>deuda inadvertida</strong>. El rol del ingeniero hoy no es competir en velocidad con la máquina, sino actuar como el arquitecto que asegura que ese volumen de código no degrade la solvencia del sistema. La IA puede darnos la liquidez que el negocio exige, pero solo el criterio humano puede evitar que esa liquidez se convierta en un colapso sistémico.</p><h4>Palabras al cierre</h4><p>Tras más de una década produciendo software y estos últimos años liderando equipos de desarrollo, mi conclusión es que el verdadero desafío no es la deuda técnica en sí, sino la capacidad ética y estratégica para gestionar este <strong>dilema</strong>. Este conflicto no se resuelve con dogmatismos, sino encontrando el punto exacto donde la agilidad que el negocio exige para sobrevivir no termine por canibalizar la solvencia técnica que el sistema necesita para perdurar.</p><p>Nuestra profesión nos exige la lucidez para navegar esta tensión cada día: entender que una ingeniería perfecta en un producto que llega tarde al mercado es irrelevante, pero que un producto exitoso sobre una base tecnológica quebrada es una bomba de tiempo financiera. La responsabilidad del profesional moderno es actuar como un gestor de activos, garantizando que el software siga siendo un motor de innovación y no una herencia de problemas.</p><p>¿Estamos ejerciendo nuestra <strong>autoridad técnica</strong> para proteger el estándar de calidad, o solo somos espectadores esperando que el colapso del sistema no nos toque a nosotros? ¿Y estamos, como desarrolladores, entendiendo que <strong>el negocio</strong> necesita <strong>agilidad</strong> y <strong>velocidad</strong> para ser <strong>competitivo</strong>, o estamos olvidando que sin un <strong>producto rentable</strong> en el mercado nuestra ingeniería simplemente no tiene razón de existir?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08c9858c4860" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[La paradoja del error de los 2 minutos]]></title>
            <link>https://medium.com/@ricardo.carrasco.p/la-paradoja-del-error-de-los-2-minutos-a0dd395af79f?source=rss-70d70efefc8e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0dd395af79f</guid>
            <dc:creator><![CDATA[Ricardo Carrasco P]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 12:01:01 GMT</pubDate>
            <atom:updated>2026-02-09T12:01:01.914Z</atom:updated>
            <content:encoded><![CDATA[<p>Hoy, en una instancia de retrospectiva, llegamos a un punto que he visto pasar una y otra vez a lo largo de mi carrera. Esa pregunta que flota en el aire después de un probar un desarrollo y encontrar errores: <em>“¿Por qué, si planificamos, tenemos estándares, revisamos el código entre varios y tenemos una arquitectura sólida, el usuario sigue encontrando un error a los dos minutos (o antes) de usar el producto?”</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*em_8GNBIKkgbBMMxAOgD9Q.png" /></figure><p>A modo de broma dije: “<strong>yo sería millonario si me pagaran por cada vez que alguien se me acerca a explicarme este mismo dolor”</strong>. Es una frustración que me ha perseguido a lo largo de mi de carrera y que parece no tener una solución definitiva. Lo que más duele no es el error en sí, sino el impacto en la confianza: cuando un stakeholder o cliente encuentra un fallo en dos minutos, se empieza a cuestionar la minuciosidad y la capacidad técnica del equipo. Pero yo, que veo el trabajo tras bambalinas, sé que la intención de excelencia está ahí. El problema es más profundo.</p><p>Para intentar desmenuzar esta realidad, he seleccionado algunos puntos que me parecen fundamentales para reflexionar. No pretenden ser la solución definitiva, sino un análisis de los factores psicológicos, operativos y técnicos que intervienen en ese problema y cómo podemos gestionarlos mejor.</p><h3>1. El factor humano: Sesgos y la ceguera de taller</h3><p>Para profundizar en esto, tuve una conversación larga con Gemini, contrastando mi experiencia con conceptos que validan este fenómeno. No es falta de capacidad, es un tema de sesgos cognitivos inevitables:</p><ul><li><strong>Ceguera de taller y el sesgo de confirmación:</strong> El desarrollador prueba que el código funcione según la lógica que él mismo escribió. <strong>Ejemplo práctico:</strong> en un login de usuairo, el dev se asegura de que el correo y la clave correcta den acceso (la lógica). El usuario, en cambio, intentará entrar dejando la clave en blanco, o apretando “Enter” diez veces seguidas mientras carga, o refrescando la página en mitad del proceso. El dev prueba la <em>lógica</em>; el usuario prueba la <em>resistencia</em>.</li><li><strong>La Paradoja del Pesticida:</strong> Si aplicas los mismos tests siempre, dejas de ver los errores nuevos. Los ojos se acostumbran al código y “saltan” por encima del fallo de forma inconsciente.</li></ul><p>Incluso empresas con recursos infinitos fallan por esto. <strong>Apple</strong> y el “Antennagate” del iPhone 4 es el ejemplo perfecto: ingenieros brillantes probaron el teléfono en laboratorios, pero no contaron con que un humano real lo agarraría de una forma que bloqueaba la señal. O el caso de <strong>Healthcare.gov</strong> en EE.UU., que colapsó el primer día no por falta de código, sino por no entender cómo miles de personas reales interactuarían con el flujo al mismo tiempo.</p><h3>2. El límite de la inversión: Tiempo y Dinero</h3><p>Aquí entra el dilema del <strong>Triángulo de Hierro</strong>: Alcance, Tiempo y Costo. Conseguir ese 0.1% de perfección restante requiere una inversión exponencial de recursos. Para eliminar cada sesgo humano, necesitaríamos más gente revisando, más automatización y más tiempo de entrega.</p><p><strong>¿Dónde está el límite?</strong> Si nos obsesionamos con salir con “cero errores”, corremos el riesgo de salir fuera de tiempo, perdiendo la oportunidad de negocio. Pero si salimos rápido con fallos críticos, el daño reputacional es enorme. Por eso, el éxito de la entrega no depende solo del código, sino de la gestión de expectativas desde el inicio: <strong>es vital negociar tiempos de prueba realistas, validar exhaustivamente en ambientes de pre-producción y setear qué es “aceptable” para salir</strong>. Se trata de que si algo falla, todos en la mesa sepamos de antemano por qué ocurrió y cuál es el plan de acción, evitando que el error sea una sorpresa que destruya la confianza.</p><h3>3. El compromiso de la “segunda mirada”</h3><p>A veces aplico una estrategia que no me enorgullece, pero que, obliga a romper la inercia del “ya terminé”. Cuando alguien me dice “está listo”, le pregunto: <em>“¿Lo revisaste bien? ¿Estás seguro?”</em>. Los obligo a una segunda mirada. A veces voy más allá y hago la pregunta de responsabilidad definitiva: <strong>“¿Darías tu vida a que esto funciona bien?”</strong>.</p><p>No es una amenaza, es un ejercicio de <strong>accountability</strong>. Esa presión psicológica fuerza una revisión consciente donde suelen aparecer esos detalles que el sesgo había ocultado. Es nuestra última línea de defensa humana antes de que el código llegue a ojos del cliente.</p><h3>4. Resiliencia técnica: El diseño como palanca de emergencia</h3><p>Aquí es donde la arquitectura cobra sentido. Seamos honestos: una arquitectura sólida (como la Clean Architecture) no es un escudo mágico que evita que el “error” aparezca, pero es lo que nos permite entrar, corregir y salir rápidamente sin romper el resto del ecosistema.</p><p><strong>La arquitectura no es para la perfección, es facilitar el mantenimiento.</strong></p><p>Es normal que las primeras fases de una nueva funcionalidad sean complejas y generen estrés; es el periodo de estabilización. Pero el desarrollador debe entender que ese estado de “cero errores” llegará si <strong>no claudicamos</strong>. Debemos actuar con la mentalidad de quien enfrenta un portón eléctrico bloqueado: si el sistema falla, no nos quedamos mirando el motor esperando un milagro, buscamos la palanca manual. Siempre hay una solución, o un punto cercano a ella, y lo más vital para mantener la confianza del cliente es <strong>encontrar esa salida e informar a tiempo</strong>.</p><h3>5. Minimizando el impacto: menos aislamiento, más validación</h3><p>Es fundamental entender que el Stakeholder o el PO <strong>no están para hacer QA</strong>. La responsabilidad de la calidad es 100% del equipo de desarrollo. Para proteger esa responsabilidad, decidimos probar algunas ideas:</p><ul><li><strong>Refinamiento de expectativas:</strong> reunimos a PO y a equipo de desarrollo a “romper” la idea en papel antes de programar. <em>“¿Qué pasa si el usuario borra lo que acaba de guardar?”</em>. Cerramos brechas de interpretación antes de la primera línea de código.</li><li><strong>Trailers:</strong> al igual que las películas, crear un trailer del desarrollo compartiendo la pantalla de forma informal antes del demo oficial. Es un filtro de expectativas rápido, barato y que baja la ansiedad de ambas partes.</li><li><strong>Desk Checks:</strong> mostrar avances en el ambiente local del dev. Es la mejor forma de detectar el sesgo antes de que el error escale a producción.</li></ul><p>Al final, reflexionar sobre este ciclo sin solución definitiva me ha llevado a condensar estas ideas. Las comparto, sobre todo, porque estoy convencido de que nos enfrentamos a esto con mucha más frecuencia de la que nos gustaría reconocer y, a veces, simplemente saber que no te pasa solo a ti ayuda a ver el problema con más claridad:</p><h3>Lecciones sinceras</h3><ol><li><strong>Acepta tu humanidad:</strong> no te castigues por el error. <strong>Tienes sesgos porque eres humano; </strong>la clave no es ser perfecto, sino tener herramientas para gestionarlos.</li><li><strong>La excelencia no es perfección:</strong> diseña tu arquitectura para que sea fácil de corregir. La resiliencia ante el cambio es más valiosa que un código que “nunca falla” (porque no existe).</li><li><strong>Gestiona la realidad, no solo el código:</strong> Setear expectativas claras, validar en ambientes de prueba y acordar qué es “aceptable” para salir, nos permite que, si el error aparece, no sea una sorpresa que destruya la confianza, sino un riesgo conocido con un plan de acción claro para todos.</li><li><strong>La comunicación es el mejor test:</strong> El 90% de los errores son de expectativa. Hablar antes de codificar ahorra más horas que cualquier debugger.</li><li><strong>Transparencia total:</strong> el error más grave es el que se oculta. Informar a tiempo salva la confianza del cliente más que un arreglo silencioso.</li><li><strong>No claudiques en el lanzamiento:</strong> el periodo de estabilización es duro, pero es temporal. El estado de “cero errores” se alcanza con persistencia y aprendiendo de cada caída.</li></ol><h3>Una invitación al debate</h3><p>Estas son ideas que han rondado en mi mente, no son verdades absolutas, sino un camino de ruta. ¿Cómo enfrentan ustedes este “sesgo del desarrollador”? ¿Creen que la IA puede ser nuestra mejor aliada para actuar como ese “usuario impredecible” y generarnos casos de borde antes de entregar?</p><p>Al final del día, el éxito no es la ausencia de errores, sino la capacidad de encontrar siempre la forma de que la solución llegue al usuario.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0dd395af79f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Theory: Building a Testing Standard for the Frontlines]]></title>
            <link>https://medium.com/enviame-engineering/beyond-theory-building-a-testing-standard-for-the-frontlines-ba7eaa2214ac?source=rss-70d70efefc8e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba7eaa2214ac</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[unit-testing]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[e2e-testing]]></category>
            <dc:creator><![CDATA[Ricardo Carrasco P]]></dc:creator>
            <pubDate>Wed, 24 Dec 2025 13:31:33 GMT</pubDate>
            <atom:updated>2025-12-24T13:44:31.173Z</atom:updated>
            <content:encoded><![CDATA[<p>At Envíame, we weren’t just facing a simple code problem; we were facing a challenge of scale. With more than 500 repositories (and that’s a conservative estimate) coexisting in a microservices ecosystem, the absence of a declared quality standard wasn’t just technical debt — it was a direct risk to our operational continuity.</p><p>Our reality was a fragmented frontline: elite units operating with cutting-edge tech stacks living alongside battalions holding the line in trenches dug years ago, defending legacy code that still powers critical business processes. The symptom was inconsistency. The challenge was to standardize without bureaucratizing, giving every developer the tools to survive in their own trench without suffocating the speed of the business.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XV05CtGzfvZ-l-exE_Vj-w.png" /></figure><h3>Strategic definition</h3><p>At Envíame, as we previously described in <a href="https://medium.com/enviame-engineering/why-dont-we-have-a-qa-department-at-enviame-a72b07025a14"><strong>Why don’t we have a QA department at Enviame?</strong></a>) we do not have a dedicated QA department. Over time, we moved from virtual “watercooler” chats to closed-door leadership discussions. We knew quality shouldn’t be optional, but it couldn’t be a rigid imposition either. We couldn’t just demand a test coverage percentage and call it a day. We defined quality as multidimensional: a unit test, on its own, can be a mirage if context is ignored. Code can pass its logical tests and still be inefficient, vulnerable, or so tightly coupled that it’s impossible to maintain.</p><p>We established three technical pillars:</p><ul><li><strong>Static Analysis:</strong> we implemented tools like <strong>Ruff</strong> (Python) and <strong>ESLint</strong> (JS) to standardize style and eliminate noise during peer reviews.</li><li><strong>Code Health:</strong> while already in use, we turned <strong>SonarQube</strong> into a pillar for monitoring code smells, vulnerabilities, and duplication, in addition to reflecting metrics like code coverage shared through our CI/CD pipelines.</li><li><strong>Architecture:</strong> although it has been part of our best practices for years, we determined that <strong>Clean Architecture</strong> was our greatest enabler. If code follows the Dependency Inversion Principle (DIP), it is testable by design; therefore, without solid architecture, testing is just a band-aid.</li></ul><h3>Validation in the field: listening to the trenches</h3><p>Once the framework was defined, we took it to the battlefield. We gathered feedback from the teams and identified two key pain points: the difficulty of dealing with highly cohesive (coupled) architectures and the constant pressure of deadlines. We understood the standard had to be flexible to be realistic.</p><p>This is how our <strong>Critical Flow</strong> was born. Instead of chasing a global 80% coverage — a figure that often incentivizes “garbage” tests — we asked each team to identify the most vital use cases in their README.md. These are the flows that, if they fail, compromise the operation, generate a disastrous economic impact, or halt the business. A 10,000-line repository can be reliable with 30% coverage if that percentage protects the heart of the business.</p><p>For legacy systems where decoupling was unfeasible, we decided to move up the <strong>testing pyramid</strong>. We proposed using tools like <strong>Robot Framework </strong>(as <a href="https://medium.com/u/fb712dae2279">Matias Angeli</a> covers in detail in <a href="https://medium.com/enviame-engineering/engineering-quality-without-qa-our-playbook-at-enviame-a2d434d32337"><strong>Engineering quality without QA: Our playbook at Envíame</strong></a>) to perform E2E testing. This provided an extra safety net: if we can’t test the internal logic without breaking the monolith, we at least ensure the system’s output remains correct and the flow remains functional.</p><h3>Culture over “Story Points”</h3><p>Another recurring debate was the impact of adding tests on our time-to-market and development velocity: Should we increase <strong>Story Points</strong> to account for testing? After many discussions, our conclusion was a hard “No.” Testing is not an “extra” you pay for separately; it must be an intrinsic part of our <strong>Definition of Done (DoD)</strong>. That time is an investment we recover by avoiding hours of debugging buried bugs or side effects in seemingly unrelated features.</p><p>To sustain this vision, we had to pave the way. You cannot demand quality without facilitating it. We have dedicated — and continue to dedicate — a massive effort to hardening our <strong>pipeline infrastructure</strong>. It’s not a one-time task; given the sheer number of repositories, standardizing technical baselines and configuring automated security and quality steps for every merge is a constant grind. It is a living process that requires permanent vigilance to ensure tests run correctly, removing friction so the developer can focus on what really matters: the business logic.</p><h3>The Ambassadors: The human factor</h3><p>How do you make this vision breathe across all fronts without becoming “code police”? The solution was profoundly human: the creation of <strong>Testing Ambassadors</strong>.</p><p>We didn’t look for supervisors; we looked for advocates. We identified developers in each team with a natural interest in technical quality and empowered them to be the bridge between the standard and the trenches. These ambassadors, chosen for their expertise and enthusiasm, evangelize by example. They are the ones currently preparing to maintain the standard, support their peers, and ensure that testing is a real requirement in daily operations.</p><p>This structure is not static. By staying connected, ambassadors share learnings, allowing the standard to be a living organism. Today, this group is already exploring how to automate the definition of Critical Flows and how <strong>AI</strong> can help us generate edge cases and test boilerplate. Although we still live with historical technical debt, thanks to this network, quality stopped being an external imposition and became a shared goal.</p><h3>Reflections and continuous improvement</h3><p>After this journey of definitions and rollout, these are the lessons that stand out:</p><ol><li><strong>Quality is an agreement:</strong> a standard that isn’t socialized is doomed to be forgotten.</li><li><strong>Pareto’s Law:</strong> prioritize the critical flow. Ten vital tests are worth more than a thousand syntax tests.</li><li><strong>Architecture is the foundation:</strong> if it’s hard to test, check the coupling. Clean Architecture, Hexagonal, or DDD are long-term investments.</li><li><strong>Make the right path the easiest path:</strong> automate your pipelines. Developers should spend energy creating, not configuring.</li><li><strong>Create advocates, not auditors:</strong> quality is contagious through admiration and support, not sanctions.</li></ol><p>We haven’t reached the summit yet; we are just starting the climb, and there is a long road ahead. Implementing a standard in an organization that changes every day is an exercise in continuous improvement. Today, we have a more constant monitoring system where we review metrics and progress, and most importantly, we keep our pulse on our Ambassadors. If a team falls behind, we don’t look for culprits — we look for blockers: Data issues? Delivery pressure? Architecture?</p><p>This standard is our compass. We continue to work on environment standardization and AI tools to make the developer’s life easier. At the end of the day, success isn’t a 100% coverage report; success happens when, in every Pull Request, quality stops being a burden and becomes a visible, measurable, and, above all, shared commitment by the entire team. We keep iterating because, at scale, the only constant is change.</p><h4>Acknowledging Our Testing Ambassadors</h4><p>Special thanks to our first group of ambassadors for leading this change:</p><ul><li><a href="https://medium.com/u/09f4f2dfe034">Bryan Gomez</a></li><li>Rodrigo Echeverría</li><li><a href="https://medium.com/u/d1ab1904eb44">Jose Espinosa</a></li><li><a href="https://medium.com/u/11547717d90c">Carlos De la Cruz</a></li><li><a href="https://medium.com/u/cf412967c8ab">Juan Garcia</a></li><li>Pablo Herrera</li><li>Juan De Giorgi</li><li>Gonzalo Rojas</li></ul><p><strong>Recommended reading to dive deeper into testing:</strong></p><ul><li><a href="https://medium.com/enviame-engineering/elevate-your-code-with-automation-pipelines-in-bitbucket-and-sonarqube-analysis-for-node-js-d0aa6b75cfcc"><em>Elevate Your Code with Automation: Pipelines in Bitbucket and SonarQube Analysis for Node.js</em></a><em> </em><a href="https://medium.com/u/09f4f2dfe034"><em>Bryan Gomez</em></a></li><li><a href="https://medium.com/enviame-engineering/mastering-code-quality-76b41886f045"><em>Mastering code quality</em></a><em> </em><a href="https://medium.com/u/d1ab1904eb44"><em>Jose Espinosa</em></a></li><li><a href="https://medium.com/enviame-engineering/level-up-your-frontend-with-unit-testing-6ec137b6a72d"><em>Level up your frontend with unit testing</em></a><em> </em><a href="https://medium.com/u/ac47d6b79c7c"><em>Erikagonza25</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba7eaa2214ac" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/beyond-theory-building-a-testing-standard-for-the-frontlines-ba7eaa2214ac">Beyond Theory: Building a Testing Standard for the Frontlines</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why don’t we have a QA department at Enviame?]]></title>
            <link>https://medium.com/enviame-engineering/why-dont-we-have-a-qa-department-at-enviame-a72b07025a14?source=rss-70d70efefc8e------2</link>
            <guid isPermaLink="false">https://medium.com/p/a72b07025a14</guid>
            <category><![CDATA[cicd]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Ricardo Carrasco P]]></dc:creator>
            <pubDate>Mon, 25 Nov 2024 14:54:24 GMT</pubDate>
            <atom:updated>2025-01-14T15:07:30.301Z</atom:updated>
            <content:encoded><![CDATA[<p>It is commonly agreed in the software development industry that maintaining quality is a fundamental priority. Traditionally, many companies have opted to have dedicated QA departments for this task. However, at Enviame, we have chosen a different approach: we do not have a QA department or personnel specifically dedicated to this function. Instead, we are betting heavily on the use of automated testing, integrating it as an essential part of our continuous integration and delivery (CI/CD) cycle.</p><p>When evaluating the need to incorporate QA experts, we also considered how we could scale our testing practices with a more agile and automated approach. In this article, we will explore the advantages and disadvantages of each approach and argue how our decision to not have a QA department can be sustainable, without closing the door to possible changes in the future.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*WRGMVp7x7rPpzQaUPq8fWA.png" /><figcaption>The image reflects how automation replaces manual QA in logistics. Labeled boxes on a conveyor with scanners illustrate efficient, system-driven quality control — paralleling the article’s focus on automated testing replacing a QA department.</figcaption></figure><h3>Basic differences between QA and automated testing</h3><p>Ensuring product quality is usually a challenge for any development area. Among the existing strategies is to delegate this task to the QA department and/or consider automatic testing processes as part of the software development and production cycle.</p><h4>Quality Assurance (QA)</h4><p>This consists of a dedicated team responsible for ensuring that the software meets the quality requirements and standards before a feature is released. This includes, among many other things, performing manual tests, exploratory tests, and constant review of development processes.</p><p>One of the main advantages is having the human perspective. The intervention of a human can help detect subtle problems that an automated test might overlook. For example, performing exploratory tests can uncover hidden errors and adapt to unforeseen situations. Additionally, QA teams can provide constant and detailed feedback to the development team, improving future iterations.</p><p>On the other hand, the disadvantages include that manual processes are slower and can become costly, especially considering that there will be an additional step in the development cycle that adds a new level of dependency on the QA team. It also requires additional effort in coordination and communication between QA and development as the workload increases. Furthermore, based on the premise that to err is human, even the most meticulous tester is prone to mistakes or falling into their own review bias, adding another factor that needs to be controlled within the QA department.</p><h4>Automated Testing</h4><p>Automated tests focus on creating scripts that will automatically run to verify functionality, performance, and identify potential errors introduced after making changes to the code. They are often executed as part of the continuous deployment or CI/CD process.</p><p>Automated tests can run quickly and at any time, and they integrate perfectly into the CI/CD, providing continuous and fast feedback when errors occur. If the project grows, the tests can scale easily. While it’s true that writing tests requires a high initial time investment, over time, the cost usually decreases. Among the negative aspects, it is often difficult to cover all possible testing scenarios, scripts being code require constant maintenance, and often tests can create a false sense of security within the team.</p><h3>Is not having a QA team a sustainable approach?</h3><p>Every so often, the question arises of whether it is sustainable to maintain software development without a dedicated QA team, a practice that has been accepted by the industry over the years.</p><p>The answer to this question is something that remains under discussion. For now, we can present our arguments, in which we trust, that support the idea of betting on automated testing as part of our continuous delivery process.</p><p>Here are some of our arguments and bets:</p><ul><li><strong>Commitment</strong>: We believe that software quality is the responsibility of everyone involved, not exclusively of a specific group of people or job title.</li><li><strong>Automation</strong>: Over the past few years, more and more tools have been added, and recently, with the advent of AI, it is much easier to write tests and automate their execution.</li><li><strong>Speed</strong>: Our startup spirit prioritizes quick deliveries, and we take advantage of the benefit of maintaining an automated process over a manual one.</li><li><strong>Quick reaction</strong>: We are aware that our automated tests are not infallible and that occasionally errors can reach production. For this reason, we have an excellent <strong>Support Team</strong> that detects and reports any issues to the development team, allowing us to solve them quickly and efficiently. Throughout the culture at Envíame, there is a closeness and empathy with our customers and product users that drives us to move quickly in delivering extraordinary experiences</li><li><strong>Microservices infrastructure</strong>: Having a microservices-oriented architecture means there is less coupling in our developments, reducing the risk that a change will negatively affect the entire ecosystem.</li><li><strong>Robust architecture</strong>: We use a Clean Architecture approach in our code. Our code organization is oriented to keep internal layers decoupled, facilitating test writing.</li><li><strong>Explorer spirit</strong>: Our developers are always looking for new tools and strategies to improve both the code and the testing process. Additionally, we are constantly exploring new ways of working, such as pair programming or TDD.</li></ul><p>We have found in our strengths the path to maintaining the quality of our deliveries. This path has not been without challenges, which we will describe below.</p><h3>Challenges faced and areas for improvement</h3><p>Undoubtedly, not having a QA team has forced us to manage certain challenges, and not everything has gone as well as we initially thought. We have encountered these five main problems and challenges along the way:</p><ul><li><strong>Standardization</strong>: Over time, each team has developed its own testing strategy. Some have initially explored static tests or laid the foundations for unit testing. Other teams have opted to tackle certain types of unit or integration tests, producing a diverse state of the art depending on the team being reviewed. This has forced us to work on defining standards so that teams maintain a consistent line and framework.</li><li><strong>Maintenance</strong>: This has been one of the main problems we have faced. Building tests requires maintenance, just like our code, and must be refactored. This often discourages test writing. Part of the solution to this problem is having clear rules defined in the standard, best practices when planning and writing tests, and improving our software architecture to be more test-friendly.</li><li><strong>Training</strong>: Writing tests means our developers need to be trained in the appropriate tools and libraries to write them. While this is not a disadvantage, as it increases their tech stack and knowledge, it often requires significant time investment for a junior person or someone not used to writing tests.</li><li><strong>Time</strong>: Writing tests adds this process to every new feature that is added to the system, which will make our development process slower but also safer. The time to write or maintain tests must be included in estimates. In this article “<a href="https://medium.com/enviame-engineering/surviving-story-points-in-scrum-how-to-improve-your-estimation-38b8b1ba3263">Surviving Story Points in Scrum: How to improve your estimation</a>”, we delve deeper into how this type of task influences correctly estimating the difficulty of a requirement.</li><li><strong>Culture</strong>: We have had to emphasize maintaining a critical view of how we do things so that our culture adapts and evolves with the proposed approach while maintaining team motivation to ensure code quality without a dedicated QA team.</li></ul><h3>Final reflections</h3><p>The decision not to have a QA department and depend on automated tests has been guided by the need for efficiency, consistency, and scalability. While this approach has its advantages and disadvantages, we believe it fits better with our development culture and explorer spirit. It has not been an easy task, but we believe it is the right path for now as we work to successfully overcome our challenges. However, we remain flexible in our future strategy, as our priority will always be to maintain the quality of our product.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a72b07025a14" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/why-dont-we-have-a-qa-department-at-enviame-a72b07025a14">Why don’t we have a QA department at Enviame?</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Surviving Story Points in Scrum: How to improve your estimation]]></title>
            <link>https://medium.com/enviame-engineering/surviving-story-points-in-scrum-how-to-improve-your-estimation-38b8b1ba3263?source=rss-70d70efefc8e------2</link>
            <guid isPermaLink="false">https://medium.com/p/38b8b1ba3263</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[story-points]]></category>
            <category><![CDATA[story-points-estimation]]></category>
            <category><![CDATA[scrum]]></category>
            <dc:creator><![CDATA[Ricardo Carrasco P]]></dc:creator>
            <pubDate>Tue, 15 Oct 2024 17:54:12 GMT</pubDate>
            <atom:updated>2025-01-14T15:27:51.612Z</atom:updated>
            <content:encoded><![CDATA[<p>You’ve heard phrases like “That user story can be done in one workday” or “Why were so many points assigned if the task only took a few hours of work?”. It seems to be quite complex to differentiate between estimating effort and the time needed to develop a user story. This is a commonly debated topic, which is often attributed to poor implementation of the agile framework. Is it really so? In this article, we will reflect on the causes that could lead Scrum teams to estimate time instead of complexity, and we will also explore how to reduce the uncertainty of estimates. We will seek to guide estimations in the right direction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jd3tbNCzYEORBwGF3PYBXQ.jpeg" /><figcaption>The truck with boxes of various sizes symbolizes how Story Points vary in complexity and are organized in an agile project.</figcaption></figure><h3>Let’s review the problem</h3><p>By definition, story points are a relative unit of measure used in agile methodologies and Scrum. They are used to estimate the size and complexity of user stories. Unlike hours or days, which are absolute time units, story points are based on a relative scale that is defined and agreed upon by the team.</p><p>However, for the dev team, it can be tricky not to equate story points with a time estimates. After shipping multiple Sprints over the years, some scenarios highlighted in forums, stand-ups, and blogs or videos discussing the topic stand out:</p><ul><li>Analyzing a user story based on a time frame such as a morning and using that as an estimation comparison.</li><li>Calculating an average of points per person considering holidays, vacations, or absences, and using this data to estimate the capacity for the next Sprint.</li><li>Using story points as a measure of performance comparison between team members.</li><li>Quoting story points, generating reports with the total points completed by teams in a time period, and calculating the man-hours ratio to obtain a dollar price per story point.</li><li>Assigning a high score to a user story due to uncertainty about its complexity or lack of clear definitions.</li></ul><p>Next, we’ll review what the methodology says to try to discover why there might be a tendency towards this type of behavior, and in turn, diagnose if we are facing a situation of lack of clarity when estimating requirements.</p><h3>The Agile Framework</h3><p>Let’s first analyze the characteristics that the framework proposes regarding story points.</p><h4>Relevant characteristics</h4><ul><li><strong>Relativity</strong>: story points are all about relativity; they don’t map to specific time units. They gauge the effort and complexity perceived by the team in comparison to other stories in the backlog.</li><li><strong>Shared scale</strong>: the squad defines and buys into a common scale for assigning story points to user stories. Factors like tech complexity, scope of work, uncertainty, and external dependencies come into play.</li><li><strong>Collaboration</strong>: point assignment is a collaborative activity that involves the entire team.</li></ul><h4>Benefits</h4><ul><li><strong>Prioritization</strong>: facilitates planning and prioritization based on the size and complexity of user stories.</li><li><strong>Tracking</strong>: allows for Sprint progress tracking to anticipate risks and bottlenecks.</li><li><strong>Communication</strong>: promotes communication and understanding among team members about the scope and effort required.</li><li><strong>Adaptability</strong>: as development progresses, more information and context are obtained that will allow adjusting estimates to make them more accurate.</li></ul><h4>Principles</h4><p>If we analyze how this practice aligns with the<a href="https://agilemanifesto.org/iso/es/principles.html"> 12 principles of the agile manifesto</a>, we can find some interesting relationships:</p><ul><li><strong>Valuing individuals and interactions over processes and tools</strong>: story point estimation is a collaborative activity. Each member contributes their perspective and experience to achieve a more accurate and complete estimate.</li><li><strong>Delivering working software more frequently over comprehensive documentation</strong>: having scored user stories facilitates the prioritization of stories that involve, for example, low effort and generate high impact. This allows the team to focus on delivering value to the customer continuously and frequently, ensuring that the most valuable and urgent items are addressed first.</li><li><strong>Responding to change over following a rigid plan</strong>: the team will be prepared to evaluate estimates if the need arises. Flexibility in estimation allows the team to adapt quickly to changes in requirements or the project environment, ensuring that they are always working on what brings the most value to the customer at any given time.</li></ul><p>It can be concluded that the proposal made by the framework focuses on the use of story points mainly to evaluate effort and complexity, in favor of prioritizing and delivering value. The importance of making adjustments to these score references periodically is also highlighted. The framework does not mention at any point that story points are a tool for measuring the performance of the team or its members, or delivery times.</p><p>However, despite all of the above, it happens. Personally, I believe the explanation is simple. We develop a Sprint in a time frame, we work in a defined time window, we work a certain number of hours per month. Companies often measure efforts in man-hours, so it becomes extremely logical to make this association. For the same reason, all efforts should be focused on reinforcing an estimation based on complexity and avoiding any reference to the time it takes. The solution is rather about organizing and educating the team on the use and objective of story points, if the diagnosis warrants it.</p><p>Let’s assume we have already covered this point and our team has been properly educated on what should be estimated in terms of effort and not the time it would take to implement a certain requirement. How can we improve the estimation to make it more accurate?</p><h3>Estimating is difficult</h3><p>I think we can all agree that nailing down time and complexity estimates in software dev is notoriously tough.</p><h4>How do you put a number on the unknown?</h4><p>There are multiple reasons that explain the difficulty in estimating a requirement:</p><ul><li><strong>Project uniqueness</strong>: no two projects are exactly the same. Estimates based on previous experiences are difficult to make, as each project has its own particularities and unique contexts. Even similar projects can have significant differences in terms of requirements, technologies, and teams involved.</li><li><strong>Unclear requirements</strong>: if what is needed is not well defined from the beginning, uncertainty will increase. Lack of clarity in requirements can lead to misunderstandings and incorrect assumptions, which in turn affects the accuracy of estimates. It is crucial to involve stakeholders and clarify requirements as much as possible before making estimates.</li><li><strong>Technical uncertainty</strong>: there may be unknown technologies and their implementation may take longer than expected. The adoption of new technologies or integration with existing systems can present unforeseen challenges that are difficult to anticipate during the estimation phase.</li><li><strong>System dependencies</strong>: generally, systems work in conjunction with other systems or components. It is difficult to predict the impact that a change may have on other parts of the system. External dependencies can introduce delays and additional complications that are not always evident at the beginning of the project.</li><li><strong>Team productivity:</strong> we work with people. Team productivity significantly depends on the state of its members. Experience, team morale, technologies used, and other factors can influence the pace of progress.</li><li><strong>Complexity</strong>: aspects such as code quality, architecture, design patterns can influence code quality. These factors directly influence the estimation of a task’s complexity, beyond the business requirement.</li><li><strong>Expectations</strong>: the team may act optimistically about tight deadlines, or inflate estimates to protect against uncertainty of possible delays. External or internal pressure can lead to unrealistic estimates, either due to excessive optimism or a conservative approach.</li><li><strong>Unforeseen events</strong>: unexpected problems can always arise that may be overlooked in planning, complex errors to debug, performance issues, technical challenges, or even personal problems of team members.</li></ul><p>Everything points to the fact that we must reduce uncertainty to the maximum to improve our estimation, and working on this should be a priority. Some strategies to address these difficulties include task decomposition, continuous review of requirements, adoption of collaborative estimation techniques, and incorporation of contingency margins in estimates. No less important is conducting a regular assessment of the team’s mood and commitment, as well as consideration of personal situations that may affect productivity.</p><h3>Diagnosis</h3><p>After all this analysis, I think we can outline a diagnosis. We can identify two major symptoms:</p><ul><li>Story point estimates based on time unit and not on complexity</li><li>Complexity estimates far from reality.</li></ul><p>The big question is, should we consider time to estimate complexity? The answer could be a big “It Depends” and I’ll explain why by presenting two examples:</p><h4>Case 1: low complexity, high time</h4><p>Let’s imagine a task that, although simple to implement, will require a considerable amount of time: manually completing more than 10,000 records in a database table, without using a mass loading script and reviewing the records one by one.</p><p>Although the task itself does not present great technical complexity, as it only involves data insertion, the process of implementing this task can be lengthy. The task will probably be divided into blocks of insertions, which will then be executed in the database.</p><p>Considering possible interruptions, reviews, and meetings, this task could occupy a large amount of time in a Sprint.</p><h4>Case 2: high complexity, low time</h4><p>Another example could be a task that requires inserting a limited change of a few lines of code in a fundamental logic of a system. It’s a high complexity task due to the impact that inserting a bug within this change could have, although it’s probably a very quick task to perform at the code level.</p><p>Although the task of manually inserting records is simple, the time estimate should consider the magnitude of the work and additional factors that may influence the total effort. On the other hand, an extremely complex task at a technical level could be executed quickly, but it surely involves great efforts in reviews and monitoring.</p><h3>Back to the beginning?</h3><p>These examples once again challenge how we should consider the probable time to complete a task to estimate its complexity.</p><p>There are four relevant aspects to consider in effort estimation and these are implicitly related to the time needed to complete a task:</p><ul><li><strong>Complexity</strong>: refers to the technical complexity of the task. Its complexity will directly influence the time needed to complete it.</li><li><strong>Effort</strong>: considers the physical and mental effort needed to complete the task. Tasks that require a high level of concentration and mental effort could take more time.</li><li><strong>Risk and Uncertainty</strong>: evaluates any risk or uncertainty associated with the task. High-risk and uncertain tasks may need more time due to the need to manage and mitigate these risks.</li><li><strong>Work volume</strong>: takes into account the amount of work, especially in repetitive tasks of large volume, the greater the volume, the more time is required to complete the task.</li></ul><h3>Conclusions</h3><p>Time is an underlying measure in each of the aspects to be evaluated in the estimation. Although it is not explicitly measured in story points, complexity, effort, risk, and work volume are factors that influence the amount of time needed to complete a task. Development teams can debug their estimation process and ultimately <strong>ship better results</strong>.</p><p>Below I have gathered a series of tips, based on existing literature and experience, that could help to have better estimates:</p><ol><li><strong>Do not use story points as time predictions</strong>. Avoid converting story points into estimated hours or days, as it can generate unrealistic expectations and pressure on the team.</li><li><strong>User stories should be limited to reduce uncertainty</strong>. Stories with greater uncertainty will have a higher number of points.</li><li>The <strong>main objective</strong> of the Sprint <strong>should not be to focus on team velocity</strong>, as it can lead to bad practices such as rushing work or reducing quality.</li><li>Avoid using story points to <strong>compare</strong> teams or their members. This can generate a <strong>negative work environment</strong> and demotivate collaboration.</li><li>Consider <strong>the score</strong> of stories as a <strong>reference</strong> for Sprint Planning.</li><li>The point scale should be refined <strong>periodically</strong> as the team progresses in the project and gains experience. An obsolete scale will make planning difficult and generate inaccurate estimates.</li><li>Estimates should be made by the <strong>entire work team</strong>. They should not be based on the opinion of a single team member, as this can cause biases and distortions. Discussion and consensus among the team should be encouraged.</li><li>Do not influence or apply pressure to complete a certain number of story points per Sprint. <strong>The team should focus on delivering value and protecting product quality</strong>, not on meeting an arbitrary number of story points.</li><li>Estimates are <strong>just estimates</strong>, <strong>not absolute commitments</strong>.</li><li>Adapt to changes. If a user story turns out to be more complex than anticipated, or a new priority arises, the team should be prepared to adjust their plan and re-prioritize stories. Instead of trying to complete all user stories in a Sprint, the team can <strong>focus on creating an MVP</strong> that delivers basic functionalities and greater value to the customer <strong>as soon as possible</strong>.</li></ol><p>From my perspective, the symptoms described in this article suggest that there may be issues in the current implementation of the Agile framework. It is crucial to revisit the Agile principles and re-evaluate practices that might be leading us astray. Instead of blaming the framework, we should assess whether our implementation aligns with the core principles of Agile. If discrepancies are found, we should correct our course and steer back towards true agility.</p><p>Finally, I leave you with some questions to discuss with your teams so you can identify if your organization suffers from any of the symptoms:</p><ol><li>How often do you estimate your stories based on time instead of complexity?</li><li>Are the requirements clear and precise before estimation?</li><li>Does the entire team participate in the estimation of story points?</li><li>How often do you adjust and refine the story point scale?</li><li>Do you use story points to compare performance between team members?</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38b8b1ba3263" width="1" height="1" alt=""><hr><p><a href="https://medium.com/enviame-engineering/surviving-story-points-in-scrum-how-to-improve-your-estimation-38b8b1ba3263">Surviving Story Points in Scrum: How to improve your estimation</a> was originally published in <a href="https://medium.com/enviame-engineering">Envíame Engineering Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>