Showing posts with label basal cost. Show all posts
Showing posts with label basal cost. Show all posts

Sunday, August 02, 2026

Nadie va al cirujano a pedirle que le abra un poco más

 Hace unos días hice una charla con preguntas abiertas del público, organizada por las comunidades Agile Sur y FullStack Sevilla. En algún momento alguien preguntó algo que me hacen mucho: cómo explicar el coste basal del software a una persona de negocio, de esas que escuchan «mantenimiento» y desconectan.

Respondí lo que suelo responder, pero mientras lo decía me salió otra cosa que no llevaba preparada, y creo que es la parte importante: el problema no es que no lo entiendan. El problema es que la metáfora con la que todos pensamos el software está rota, y ellos la usan igual que la usamos nosotros.

Heredamos la metáfora de la construcción

Decimos que construimos software. Levantamos arquitecturas, ponemos cimientos, montamos features. Todo el vocabulario viene de la construcción de edificios, y con él viene una idea de fondo que casi nunca hacemos explícita: que el grueso del coste está en la obra inicial y que el mantenimiento posterior es un porcentaje pequeño y previsible.

Bajo esa metáfora, construir más siempre es mejor. Más metros por el mismo presupuesto. Más entregado por el mismo equipo.

Con software el reparto es justo el contrario. Cada cosa que existe cuesta capacidad cada día, se toque o no. Hay que entenderla cuando alguien la lee, mantenerla compatible cuando llega lo siguiente, explicarla a quien entra nuevo en el equipo, actualizarla porque cambia el mundo alrededor aunque nadie la cambie por dentro. Y el mundo alrededor cambia mucho más rápido que hace veinte años.

A ese gasto continuo por el mero hecho de existir lo llamo coste basal, por analogía con el metabolismo basal: lo que consume un organismo solo por seguir vivo. No es deuda técnica. La deuda técnica es una decisión que tomaste y que puedes pagar. El coste basal lo pagas siempre, también con el código bueno.

Para negocio, es inventario

Cuando lo explico fuera de tecnología, lo que mejor funciona es hablar de inventario.

La imagen mental que tiene mucha gente de negocio es secuencial: hacemos una funcionalidad, la entregamos, pasamos a la siguiente. Como si lo anterior desapareciera del coste al terminarlo. Pero no desaparece: se queda en el almacén, y el almacén hay que sostenerlo. Cada cosa que dejas ahí resta un poco de la capacidad con la que vas a construir lo siguiente.

En las fases de expansión fuerte esto no se nota, y por eso engaña tanto. Si el equipo se satura, creas otro equipo. Divides, contratas, sigues creciendo y todo el mundo contento. Pero en cuanto dejas de crecer, aquello se hace bola: cada trimestre el equipo va un poco más lento, y nadie sabe señalar qué ha pasado porque no ha pasado nada en concreto. Solo se ha acumulado.

La prueba de la cirugía

La forma más rápida que conozco de enseñar que la metáfora está rota es cambiarla por otra donde el absurdo se ve solo.

Nadie va al cirujano y le pide que le abra un poco más. Nadie dice «hazme más puntos, que para eso te pago y además eres muy bueno». En cirugía todos entendemos, sin que haga falta explicarlo, que la intervención es el coste y que lo que importa es el resultado. Cuanta menos cirugía haga falta para conseguirlo, mejor cirujano.

En software hacemos justo lo contrario. Presumimos de cuánto hemos construido, medimos equipos por lo que entregan, celebramos el volumen. Enseñamos la cicatriz como si fuera el resultado.

La metáfora que sí ayuda

La que a mí me sirve es la de cultivar algo: sembrar, regar, podar, limpiar, de forma continua. Y tiene dos consecuencias que me parecen mucho más útiles que la del edificio.

La primera es que no hay que esperar señales de alarma. Si tienes un jardín y no vas nunca a cuidarlo, no necesitas un indicador que te avise: puedes dar por seguro que en unos meses estará despendolado. Es entropía, va en la naturaleza del sistema. Nuestro trabajo no es reaccionar cuando la complejidad ya duele, es gestionarla todo el rato para que no llegue ahí.

La segunda es que cambia la conversación sobre añadir. Quien sabe lo que cuesta mantener un terreno productivo durante todo el año no mete más plantas porque sí. Le pone un precio al año entero, no al día que siembra. Con software casi nunca hacemos esa cuenta: valoramos lo que cuesta construir algo, no lo que va a costar sostenerlo mientras siga vivo.

Ninguna metáfora es perfecta, y esta tampoco. El software no crece solo, y podar código es bastante más incómodo que podar un seto. Pero al menos pone el foco donde está el dinero: en lo continuo.

Qué cambia cuando cambias la metáfora

En los equipos donde este cambio ha calado, lo que he visto cambiar es esto:

  • Decidir no construir algo deja de parecer una rareza defensiva y pasa a ser parte del trabajo.
  • Antes de decir que sí, aparece la pregunta por el coste de sostenerlo, no solo por el de hacerlo.
  • Eliminar deja de leerse como destruir valor. Quitar una funcionalidad muerta es recuperar capacidad, igual que podar.
  • El trabajo de gestión de la complejidad se hace visible, y se puede defender en una priorización.

Y hay una implicación que se ha vuelto urgente. Si construir se abarata mucho, como está pasando con la IA, la parte cara no baja igual: entender, integrar, operar y sostener siguen costando lo mismo o más, porque ahora hay más cosas vivas. Abaratar la construcción sin cambiar la metáfora no resuelve el problema. Lo acelera.

La conversación completa

Todo esto salió en una charla de casi dos horas, en formato entrevista y con preguntas del público en directo. Además de las metáforas se habló de cómo explicar el coste basal a dirección, de por qué existe la tendencia a construir de más, de qué hacer cuando en tu empresa «esto es imposible», y de juniors, universidad e IA.

Y si quieres tirar del hilo, el libro es Menos software, más impacto, y en menos-software.eferro.net están los recursos por capítulo, gratis y abiertos.

Sunday, September 29, 2024

The Building Fallacy: A Misleading Metaphor in the Age of Continuous Evolution

The "building fallacy" in software development refers to the flawed comparison between creating software and constructing a physical building. While this analogy may seem intuitive at first glance, it breaks down when we consider the nature of software and the realities of today's technology landscape. This misconception leads to inefficient processes, increased costs, and diminished capacity for innovation.


Here's why this metaphor is misleading and why it's more critical than ever to abandon it:

Why the Building Metaphor Doesn’t Hold Up

Software is Evolutionary, Buildings are Static

Buildings are designed with a fixed endpoint in mind. Once constructed, they primarily require maintenance to address wear and tear. Software, however, exists in a state of constant change. To remain relevant, it requires ongoing adaptation in response to evolving user needs, market demands, and technological advancements. Software development is more like tending a garden than erecting a structure—it requires continuous nurturing, pruning, and adjustment to thrive.

Overemphasis on Upfront Design

The building analogy often leads teams to prioritize extensive upfront planning and design, mirroring the blueprints used in construction. However, in software development, excessive upfront design can stifle innovation and lead to the dreaded "waterfall" model, where changes become costly and time-consuming. A more iterative approach allows teams to learn and adapt based on real feedback, making decisions at the last responsible moment and incorporating the latest insights.

Ignoring the Long Tail of Costs

The building fallacy promotes the misconception that most of the effort lies in the initial "construction" phase. In reality, maintaining, evolving, and supporting software systems far outweighs initial development costs.

A crucial concept that challenges the building analogy is Basal Cost—the recurring expense of maintaining features or code regardless of usage. This includes updates, security patches, and the cognitive load of supporting the code. Ignoring these costs leads to an incomplete understanding of the true financial and resource implications of software development. See more at Basal Cost of software.

Why the Building Fallacy is More Problematic Than Ever

In today's rapidly evolving tech landscape, clinging to the building fallacy is more detrimental than ever. Here's why:

The Pace of Change is Relentless

Technology, user needs, and market dynamics are shifting at an unprecedented pace. Software must evolve quickly to stay relevant. A rigid, building-centric mindset makes it hard to adapt to new challenges or opportunities.

Increased Reliance on External Systems

Modern software heavily depends on external APIs, cloud services, and open-source libraries, all of which evolve constantly. The building analogy fails to account for the complexity of managing these dependencies and ensuring seamless integration over time.

The Rise of Continuous Delivery

Continuous delivery and DevOps practices emphasize frequent releases, rapid iteration, and tight feedback loops, clashing with the notion of a fixed endpoint or grand unveiling. These practices underscore the need for flexibility, not rigidity.

Shifting to an Evolutionary Mindset

To succeed in today's environment, teams must abandon the building fallacy and embrace software as a living, evolving system. This shift involves:

Prioritizing Learning and Adaptation

Software development should be seen as a continuous process of experimentation. This means adopting agile methodologies, prioritizing validated learning over feature delivery, and delaying decisions to incorporate the latest insights.

Designing for Change

Architectures should be modular, flexible, and loosely coupled, making it easier to adapt to new requirements, integrate evolving external systems, and experiment with new technologies.

Managing Basal Costs

Teams must actively manage Basal Costs throughout the software lifecycle by:

  • Regular Maintenance: Keeping dependencies updated, applying security patches, and fixing bugs.
  • Cognitive Load Management: Simplifying the codebase and documentation to reduce the mental effort for developers.
  • Eliminating Unused Features: Removing unnecessary features to lower maintenance costs.
  • Investing in Code Quality: Refactoring, code reviews, and automated testing to improve maintainability and manage Basal Costs over time.

Lean Software Development and Extreme Programming (XP) practices are particularly effective in keeping Basal Costs low. Lean principles focus on eliminating waste, such as unnecessary code or features that add no value, which reduces maintenance burdens. XP practices, like Test-Driven Development (TDD), continuous integration, and pair programming, promote clean, maintainable code and help prevent technical debt.

By adopting these practices and embracing a mindset of continuous evolution, teams can break free from the outdated building fallacy and create software that thrives in today's dynamic technology environment.


Related content:

Tuesday, July 16, 2024

El coste basal del software

Traduccion del articulo original Basal Cost of Software
Traduccion realizada por https://x.com/simonvlc y publicada originalmente en su genial newsletter Estrategia de Producto: El Coste Basal del Software
---

En mi opinión, el coste de desarrollo de cada funcionalidad en un producto puede dividirse de la siguiente manera:

  1. El coste directo de desarrollo o coste inicial.
  2. Un coste semanal o mensual únicamente asociado con su existencia en el sistema. Haciendo una comparación con la Tasa Metabólica Basal del cuerpo humano, podríamos llamar a este segundo coste la Tasa Metabólica Basal o Coste Basal.

El Coste Basal se compone de dos partes diferenciadas:

  • El impacto directo en la capacidad del equipo debido a la complejidad añadida (nuevas dependencias, más código para entender, más posibilidades de bugs ocultos, etc.).
  • El impacto en el coste de desarrollo o evolución de otras funcionalidades debido a posibles incompatibilidades, acoplamiento, etc.

El coste inicial

Es el coste incurrido por el equipo durante el desarrollo inicial de la funcionalidad. Incluye el coste desde que el equipo comienza a trabajar en la funcionalidad hasta que el cliente la tiene disponible y comienza a usarla. Por supuesto, este proceso debería consistir en múltiples despliegues y lanzamientos parciales para obtener feedback y hacer los ajustes necesarios...

El Coste Basal

Tras el coste inicial de desarrollo, afrontamos también un coste continuo que reduce la capacidad del equipo para el desarrollo de nuevas funcionalidades (innovación).

Este coste, que continúa con el tiempo y solo termina con la eliminación de la funcionalidad o el fin de vida del producto, es el coste que paga el equipo por la existencia de ese código en el producto.

Es importante tener en cuenta que este no se refiere al coste de hacer modificaciones o corregir errores; se refiere al coste de simplemente tener el código allí...

¿Por qué se da este coste? ¿Por qué una funcionalidad que no evoluciona supone un coste? 

  • El equipo tiene que conocer ese código (dónde está, qué dependencias tiene, qué interactúa con él, cómo está diseñado...).
  • El conocimiento y las técnicas del equipo están en constante evolución. Cuando mejora en cualquiera de estos aspectos, deberá actualizar el código.
  • Cuando el equipo diseña una nueva funcionalidad, el código debe ser diseñado de manera que sea compatible con todas las anteriores y no genere problemas o regresiones. Y, por supuesto, este coste es proporcional a todas las que ya teníamos en el sistema.
  • Algo similar ocurre cuando un nuevo miembro se une al equipo. Este nuevo integrante debe aprender sobre todas las funcionalidades, por lo que el coste es proporcional a su número..

Y lo peor de todo, este sobrecoste es continuo hasta la "muerte" de la funcionalidad. Por ejemplo, hasta el fin de la vida del producto, hasta que ningún usuario la use, o hasta el fin del mundo (lo que ocurra primero).

Evolución del coste de una funcionalidad

Como hemos visto, el Coste Basal de una funcionalidad es más o menos constante durante su vida. Pero cada lenguaje, dependencia o tecnología que hayamos usado en su desarrollo, puede alcanzar un punto en el que ya no es utilizable por cualquier razón (dependencias obsoletas, problemas de seguridad, evolución normal que deprecia la versión del lenguaje que usamos, etc.). Desde este momento, el coste puede dispararse porque estamos obligados a actualizarlo, incluso aunque no queramos evolucionar la funcionalidad.

En resumen, el coste real puede ser representado por el siguiente gráfico:

El problema

Un error común es negar el Coste Basal y considerar que si no se hacen cambios, el coste de mantenimiento de una funcionalidad es cero. Supongo que esto proviene de utilizar metáforas de otras profesiones como la construcción, que no son aplicables al desarrollo de software.


La capacidad no es infinita

A pesar de que la capacidad de un equipo cambia (positiva o negativamente) con el paso del tiempo debido a distintos factores (conocimiento del negocio, técnicas, estrés…), esta es finita.

El Coste Basal acumulado de todas las funcionalidades de las que el equipo es responsable reduce la capacidad disponible para desarrollar nuevas funcionalidades (innovar).

Con el tiempo, podemos observar como la capacidad del equipo para innovar decae rápidamente:

Hasta el punto de que cuando la capacidad se agota, el equipo se encuentra en una situación en la que le es imposible innovar porque pasa todo su tiempo “manteniendo” las funcionalidades de las que es responsable.


O bien reduce su velocidad al desarrollar nuevas funcionalidades, acumulando coste basal, pero a menor ritmo.

Conclusiones

Las secciones anteriores destacan varios principios que debemos considerar para mejorar la eficiencia de nuestros equipos de producto.

  • Debemos minimizar el Coste Basal tanto como sea posible, logrando el impacto deseado con la menor cantidad de código posible.
    • Cuando sea posible, incluso sin añadirlo.
    • Iterando la funcionalidad, partiendo de una solución mínima, para adaptarla lo más posible a las necesidades del usuario.
    • Haciendo el software/diseño lo más simple posible. Debe ser fácil de evolucionar sin sobreingeniería (YAGNI).
  • Debemos eliminar cualquier funcionalidad del producto que no tenga el impacto deseado, eliminando así su Coste Basal.
  • Debemos monitorizar continuamente el código del equipo para detectar la obsolescencia de dependencias, lenguajes y tecnologías para evitar que el Coste Basal se dispare.

Veamos un ejemplo teórico sencillo para ayudar a transmitir el mensaje. Supongamos que un equipo acumula un 1% de Coste Basal por semana, lo que significa que, por cada 100 unidades de producto (código, características, mejoras), añade 1 unidad de Coste Basal. A medida que este se acumula, en 52 semanas (aproximadamente 1 año), el equipo solo podrá dedicar el 60% de su capacidad a nuevas funcionalidades/mejoras (innovación). En dos años, será apenas el 35%. Por supuesto, este ejemplo es una simplificación, pero destaca que negar este coste no es una opción viable.


Recordad: La Simplicidad — el arte de maximizar el trabajo no hecho — es esencial.

Relacionado y referencias

Otros artículos interesantes


Sunday, May 16, 2021

How big is the backpack your organisation is holding

Author: Jorge Jardines https://www.gardenunez.net/

Every experiment, invalidated product feature or unused line of code you haven't deleted is adding weight to your backpack.

Every morning when you wake up and need to walk the next X miles you feel the weight in your back and you feel slower than yesterday. It is like adding an extra bottle of water on your backpack, water you aren't gonna drink but still needs to hold on your back.

Your team or organisation is holding this huge backpacks all the time. Do you ever wonder why adding a new experiment gets more and more slower and costly for your teams, do ever check how much code isn't being used, how many features are not being used I your product, how many "brilliant" ideas were transform into code that nobody used. Do you ever wonder how big is the backpack your organisation is holding.

References:

Saturday, May 01, 2021

It's not only a waste; it's a burden

Talking about software systems, let's stop to talk about waste when we refer to something not necessary or created without a clear understanding of the problem to solve. Let's call it a burden (since you are going to have it holding you back forever)...

If you implement it to experiment, learn and later throw it away, perfect... If you are keeping it, you are fooling yourself. 

This code is a burden, worse than the sunk cost, and it will generate a recurrent cost forever.


There are two types of complexity, the inherent and the accidental/incidental.


The inherent complexity can't be avoided because it is intrinsic to the problem we want to solve. But the accidental/incidental is all the complexity we introduce by not fully understanding the problem, not knowing how to solve it, or by our lack of mastery on the subject, etc.
 

This accidental/incidental complexity is also a burden. The inherent one is not. :)

Do yourself a favor, reduce the burden. reduce the basal cost. improve your life and the life of your team.

Develop product in an agile way:
  1. Work in small steps
  2. Try to really understand the real problem and the meaningful impact you want to make
  3. Validate each increment and its impact
  4. Always work with quality-in and with attention to technical excellence
  5. Refactor continuously (to reduce the accidental/incidental complexity)
  6. And for God's sake, delete everything that is not necessary. Ruthlessly remove; code, dependencies, features, complexity… Minimize basal cost and make the evolution of the system easier.
And follow the principles:
  • Continuous attention to technical excellence and good design enhances agility.
  • Simplicity --the art of maximizing the amount of work not done-- is essential.

References:

Monday, February 01, 2021

Basal Cost of software

Last update: 2024/04/05

In my opinion, the development cost of each feature in a product can be divided as follows:

  • The direct development cost of the feature or initial cost.
  • A weekly or monthly cost only associated with the existence of this feature in our system. Making a comparison with the Basal Metabolic Rate of a human body, we can call this second cost the Basal Metabolic Rate of a feature or Basal Cost of a feature.


The Basal Cost of a feature is composed of two different parts:

  • The direct impact in the team capacity of the added complexity of this feature (new dependencies, more code to understand, more possibilities for bugs to hide, etc).
  • The impact on the cost of the development or evolution of other features due to potential incompatibilities, coupling, etc.


The Initial cost of a feature

This is the cost/expense incurred by the team during the initial development of the functionality. It includes the cost since the team starts working on the feature until the customer has it available and starts using it. Of course, this process should consist of multiple deployments and partial releases to obtain feedback and make the necessary adjustments…

The Basal Cost of a feature

After the initial development cost, we had this continuous cost that reduces the team capacity for new features development (innovation).
This cost, which continues over time and only ends with the removal of the feature or the end of life of the product, is the cost incurred by the team for the existence of that code and that feature in the product.
It is important to keep in mind that this cost does not refer to the cost of making modifications to the feature or fixing bugs, it refers to the cost of simply having the code there...

Why does this cost happen? Why is there an ongoing cost for a feature that is not evolving?

  • The team has to know that code (where it is, what dependencies it has, who interacts with it, how it is designed...).
  • The team's knowledge and techniques are continuously evolving. When the team improves in any of these aspects, the team should update the feature's code.
  • When the team designs a new feature, the code should be design in a way that is compatible with all the previous features and doesn't generate problems or regressions. And of course, this cost is proportional to all the features we had in the system.
  • Something similar happens when the team has a new member. This member should learn about all the features, so the cost is proportional to the number of features.


And worst of all, this overhead is continuous until the "death" of the feature, i.e., the end of life of the product, until no user uses it, or until the end of the world (whichever comes first).


Evolution of the Cost of a feature

As we saw, the Basal Cost is more or less constant during the life of the feature. But each language, dependency, or technology can reach a point that is no longer usable for whatever reason (obsolete dependencies, security problems, normal evolution that deprecate the language version we used, etc).  From this moment, the cost can skyrocket because we are forced to update it even if we don't want to evolve the feature.


So in summary, the real cost of a feature can be represented by the following graph:





The problem

A common mistake is to neglect the Basal Cost and consider that if no changes are made to a feature, the feature's ongoing cost is zero.
I guess this comes from using metaphors from other professions such as construction that are not suitable for software development.




Non-infinite capacity

Although the capacity changes (positively or negatively) over time due to different factors (knowledge of the business, techniques, stress...), the team capacity is finite.
The accumulated Basal Cost of all the features that the teams own reduces the capacity available to develop new features (innovation).

Over time we can see how the team capacity for innovation shrinks very fast.


To a point where capacity is exhausted, the team finds itself in a situation where it is impossible to innovate and spends all its time "maintaining" the functionalities it already owns (See Fig 1).


Fig 1

Or the team begins to move increasingly slower in developing any new functionality, accumulating basal cost, but at a slower pace (See Fig 2).

Fig 2


Conclusions

The above sections highlight several principles that we must consider to improve our product teams' efficiency.

  • We should minimize the Basal Cost as much as possible, achieving the desired impact with as little code as possible.
    • If possible, even achieving the impact without the need to develop code.
    • Iterating the functionality to adapt it as much as possible to the user's needs and making the solution minimal.
    • Make the software/design as simple as possible. It should be easy to evolve without overengineering (YAGNI).
  • Eliminate or remove any feature from the product that does not have the desired impact, thus eliminating its corresponding Basal Cost.
  • Monitor the team’s code continuously to detect the obsolescence of dependencies, languages, and technologies and avoid the Basal Cost skyrocketing.

Let's look at a straightforward theoretical example to help convey the message. Let's assume that a team generates a 1% cumulative Basal Cost per week, meaning that every 100 units of product increase (code, features, improvements) leaves a residue of 1 unit of Basal Cost. As this cost accumulates, in 52 weeks (approximately 1 year), the team can only dedicate 60% of its capacity to new features/improvements (innovation). In two years, it will be barely 35%. Of course, this example is an oversimplification, but it highlights that denying this cost is not a viable option.



Capacity evolution for a team generating 1% cumulative Basal Cost



Remember: “Simplicity --the art of maximizing the amount of work not done-- is essential.

Related & References


Other interesting articles

Updates

  • 2024/04/05 Included Alex Fernández's feedback 
  • 2024/04/05 Added a simplified example in the conclusions section

Thanks

The post has been improved based on feedback from:

    Sunday, September 06, 2015

    Coste basal del software vs capacidad infinita


    En mi opinión, el coste de desarrollo por cada grupo de funcionalidades se puede dividir de la siguiente forma:
    • Coste inicial de desarrollo
    • Coste de existencia (coste basal):
      • Coste de existencia / complejidad añadida
      • Coste de existencia para otras funcionalidades


    Coste inicial de desarrollo

    Este es el coste/gasto en el que incurre el equipo durante el desarrollo inicial de la funcionalidad. Incluye desde que el equipo comienza a trabajar en la funcionalidad o grupo de funcionalidades hasta que el cliente la tiene disponible y comienza a usarla. Por supuesto este proceso debería incluir múltiples puestas en producción para ir obteniendo feedback y realizando los ajustes necesarios...

    A partir de este momento, comienzan a producirse de forma continua y hasta el final de la vida de la funcionalidad o del producto, un coste de existencia o coste basal.

    Coste de existencia o Coste basal

    Este coste, continuado en el tiempo y que solo termina con la retirada de la funcionalidad o el fin de la vida del producto, es el coste en el que incurre el equipo por la existencia de ese código y esa funcionalidad en el producto.
    Es importante tener en cuenta que este coste no se refiere al coste de realizar modificaciones a la funcionalidad o corregir errores, se refiere al coste que conlleva simplemente que el código esté ahí...

    ¿Por qué se produce este coste?
    • El equipo tiene que conocer ese código (dónde está, qué dependencias tiene, con quien interactua, cómo está escrito...)
    • El conocimiento y técnicas del equipo están en continua evolución. Cuando el equipo mejora en alguno de estos aspectos tiene que decidir si actualiza el código de la funcionalidad, si lo hace es un coste, si no lo hace, también puesto que será diferente que el resto de código de que dispone.
    • Cuando aparezcan nuevas funcionalidades se debe ver dónde impactan y no es lo mismo tener que identificar esos impacto en una aplicación de un tamaño X que en una de un tamaño X más el tamaño de la funcionalidad.
    • Lo mismo pasa cuando entra un nuevo miembro del equipo y tiene que conocer la base de código que existe.
    Y lo peor de todo es que este gastos es continuo hasta la "muerte" de la funcionalidad, es decir el fin de vida del producto, hasta que no la use ningún usuario o hasta el fin del mundo (lo que sea que ocurra antes).

    Además, si se sobrepasa el punto de obsolescencia tecnológica (versión de lenguaje obsoleto, dependencias que desaparecen, etc) antes de la "muerte" de la funcionalidad el coste de mantenimiento se dispara y podemos entrar en una situación en que la capacidad del equipo quede ocupada al completo intentando mantener bajo control funcionalidades que ya han pasado el punto de obsolescencia tecnológica.

    En mi experiencia, siempre me he encontrado que este coste se obvia y tanto los desarrolladores como los clientes y managers simulan que no existe, tomando decisiones (sin sentido) que no lo tienen en cuenta.

    Capacidad no infinita

    El problema es que la capacidad de un equipo de desarrollo no es infinita y aunque cambia (en positivo o negativo) con el tiempo debido a distintos factores (el conocimiento del negocio, de las técnicas...), existe una tendencia clara a que la capacidad usada en el coste basal de las funcionalidades ya hechas vaya mermando la capacidad disponible para nuevas funcionalidades.

    Coste acumulado
    Por tanto de forma general, independientemente de la calidad del software desarrollado, poco a poco la capacidad disponible de un equipo para nuevas funcionalidades disminuye con el tiempo.
    Si el equipo desarrolla sin usar buenas prácticas y sin alta calidad, este colapso es prácticamente inmediato en el caso de tener muchos bugs o en unos pocos meses cuando aún no teniendo muchos bugs la calidad interna del software es baja.

    Si el equipo es bastante bueno y se preocupa por la calidad esta tendencia será muchísimo menos pronunciada y se podría tener una capacidad "razonable" para nuevas funcionalidades durante años, pero por supuesto poco a poco iría disminuyendo y a la larga desaparecería.

    A lo largo de los años las estrategias que he visto para lidiar con este problema son:
    • Ignorarlo y esperar al colapso.
    • Hacer crecer de forma constante tu equipo para mantener una capacidad para nuevas funcionalidades constante (este enfoque es el que parecen tener empresas de tecnología puntera que crecen en ingenieros de forma constante; google, amazon, netflix, spotify ...)
    • Crear equipos de mantenimiento a los que pasar el producto despues del desarrollo inicial (por supuesto esto es similar al punto anterior).
    Claramente este problema sólo afecta a los departamentos de desarrollo interno o a los equipos de desarrollo dedicados a producto. Para el caso de consultoras o equipos que trabajan en proyectos este tipo de problema no les afecta puesto que pasado el desarrollo inicial se suele entregar el proyecto y el mantenimiento es problema del cliente.

    La solución

    Y ahora viene cuando planteo la solución que he encontrado....
    Pues no, no tengo ni idea de cómo solventarlo, como mucho se retrasar las consecuencias del problema, minimizarlo, pero no solventarlo.



    Me encantaría opiniones sobre como tratar a medio largo plazo este problema. Lo único que se me ocurre es el crecimiento continuo de equipo o tener una política de "end of life" de los productos muy agresiva.

    Se aceptan sugerencias, experimentos, opiniones, cualquier comentario será bienvenido.