Как технический долг незаметно начинает стоить бизнесу денег
Технический долг редко появляется как большая проблема. Обычно всё начинается с вполне рациональной фразы: Сейчас сделаем быстро, а нормально переделаем потом. Команде нужно выпустить функцию к пятнице. Правильная реа…
Технический долг редко появляется как большая проблема. Обычно всё начинается с вполне рациональной фразы: Сейчас сделаем быстро, а нормально переделаем потом. Команде нужно выпустить функцию к пятнице. Правильная реализация займёт 16 часов. Временное решение — 8. Бизнес экономит один рабочий день. На первый взгляд решение разумное. Проблема начинается, если это «потом» не наступает. Через несколько месяцев временное решение становится частью архитектуры. Через год уже никто не хочет его трогать. А каждая новая функция требует учитывать старый костыль.
И 8 часов, которые когда-то удалось сэкономить, начинают возвращаться в каждом следующем изменении. Это и есть technical debt — технический долг . Что такое технический долг Технический долг — это будущая стоимость решений, которые сегодня позволяют двигаться быстрее, но делают дальнейшее развитие системы сложнее. Сам термин полезно воспринимать буквально. Как финансовый долг. Вы берёте ресурс сейчас. А позже платите: основную сумму и проценты . В разработке основной суммой будет стоимость исправления первоначального решения.
А проценты проявляются постоянно:
- функции делаются дольше;
- тестирование занимает больше времени;
- появляется больше дефектов;
- разработчики дольше разбираются в системе;
- deployment становится рискованнее.
Поэтому технический долг не обязательно плох сам по себе. Иногда взять его вполне рационально. Плохо — не знать, сколько долга накоплено и сколько процентов бизнес уже платит. Пример: быстрый костыль экономит 8 часов Допустим, нужно добавить новый тариф.
Вариант A
Разработчик делает нормальную модель тарифов. Стоимость: 16 часов.
Вариант B
Чтобы успеть к рекламной кампании, новый тариф просто добавляют дополнительным условием в существующий код. Стоимость: 8 часов. Компания экономит: 8 часов. На этом этапе решение может быть оправданным. Но через несколько месяцев появляются ещё четыре тарифа. Теперь каждое изменение требует учитывать:
- первое условие;
- второе;
- исключения;
- старые данные;
- новую логику.
Следующая функция, которая могла занимать 8 часов, занимает уже 12. Потом 16. Потом 24. Первоначальная экономия давно исчезла. Но в финансовом отчёте нет строки: Проценты по техническому долгу. Они растворены в стоимости обычной разработки. Именно поэтому долг сложно заметить Технический долг редко приходит отдельным счётом. Бизнес видит другое: Почему эта простая функция занимает неделю? Почему после каждого изменения что-то ломается? Почему новый разработчик месяц разбирается в проекте? Почему релиз нужно готовить вручную несколько часов?
Ответ часто находится в накопленной сложности системы. 1. Legacy-код Legacy-код — это не просто старый код. Возраст сам по себе не проблема. Система десятилетней давности может быть отлично спроектирована. Проблема начинается, когда код:
- трудно понять;
- страшно менять;
- невозможно нормально протестировать;
- зависит от устаревших решений;
- плохо документирован.
Типичная ситуация: разработчику нужно изменить расчёт цены. Но функция расчёта одновременно влияет на:
- каталог;
- заказ;
- invoice;
- CRM;
- email.
Никто точно не знает почему. Поэтому перед маленьким изменением приходится изучать большой кусок системы. Бизнес оплачивает не новую функцию. Он оплачивает осторожность вокруг старого кода. 2. Отсутствие тестов Представим два одинаковых изменения. Нужно поменять правило расчёта скидки.
Проект A
Есть:
- unit tests;
- API tests;
- integration tests;
- E2E критического сценария.
Разработчик меняет код. Запускает tests. Система показывает, какие сценарии пострадали.
Проект B
Автоматических тестов нет. Разработчик меняет код. После этого команда должна вручную проверить:
- каталог;
- корзину;
- заказ;
- CRM;
- email;
- mobile.
Причём нет гарантии, что кто-то вспомнил обо всех сценариях. В результате стоимость каждой функции включает дополнительный regression. Это технический долг. Он платится снова при каждом релизе. «Нет тестов» сначала действительно быстрее В первые дни проекта тесты требуют дополнительного времени. Поэтому легко сделать вывод: Без них разработка быстрее. На первых нескольких функциях это может быть правдой. Но затем система растёт. В ней появляется: 10 функций. И каждый раз нужно убеждаться, что новая функция не сломала старые. Если автоматизации нет, стоимость проверки растёт вместе с продуктом.
Тогда время, сэкономленное в первый месяц, начинает расходоваться на каждой следующей задаче. 3. Сложные зависимости Один из признаков technical debt: Изменение одного компонента неожиданно требует менять пять других. Например, чтобы добавить поле в профиль клиента, нужно обновить:
- database;
- backend;
- CRM;
- export;
- reporting;
- frontend;
- notification.
Само по себе наличие нескольких компонентов нормально. Проблема — когда зависимости между ними не управляются. Например:
- модули знают слишком много друг о друге;
- общая логика дублируется;
- несколько систем работают напрямую с одной таблицей.
Тогда даже небольшие изменения получают большой blast radius. Стоимость разработки растёт не из-за сложности самой функции. А из-за сложности её окружения. 4. Ручной deployment Ещё один долг часто скрывается в операционных процессах. Представим релиз. Разработчик вручную:
- подключается к серверу;
- останавливает приложение;
- копирует файлы;
- обновляет зависимости;
- запускает migration;
- перезапускает сервис;
- проверяет несколько страниц.
Каждый deployment занимает час. Команда делает 15 релизов в месяц. Получаем: 15 часов ежемесячно. За год: 180 часов. И это без учёта ошибок. Если однажды разработчик забывает выполнить шаг, появляется production incident. CI/CD требует времени на настройку. Но ручной deployment тоже имеет стоимость. Просто она распределена по всем будущим релизам. 5. Отсутствие документации Проект отлично знает один разработчик. Все остальные иногда спрашивают: А почему здесь так? Пока этот человек работает в команде, проблема кажется несущественной.
Потом он уходит. Новый разработчик начинает исследовать:
- как запустить проект;
- где конфигурация;
- как работает CRM;
- почему нельзя обновлять конкретную библиотеку;
- как выполняется production deployment.
Несколько недель работы уходят не на развитие. А на восстановление потерянных знаний. Это тоже technical debt. Только долг находится не в коде, а в знаниях о системе. 6. Устаревшие зависимости Проект несколько лет не обновлял:
- framework;
- CMS;
- plugins;
- libraries.
Почему? Всё же работает. Потом появляется необходимость обновить одну библиотеку. Но новая версия требует новую версию framework. Framework требует изменить код. Некоторые plugins уже не поддерживаются. Обычная задача: Обновить зависимость. превращается в: Провести миграцию платформы. Регулярные небольшие обновления стоят денег. Но многолетнее отсутствие обновлений тоже стоит денег — позже и обычно намного заметнее. 7. Дублирование логики Представим расчёт стоимости заказа. Он реализован:
- во frontend;
- в backend;
- в CRM integration.
Три реализации. Меняется правило. Разработчик исправляет backend. Но забывает frontend. В итоге пользователь видит одну цену, а CRM — другую. Теперь нужно:
- искать проблему;
- исправлять;
- проверять данные.
Правильнее иметь один источник бизнес-логики. Дублирование сначала ускоряет разработку: Скопируем сюда — быстрее. Но затем каждое изменение приходится повторять в нескольких местах. Это классический процент по техническому долгу. 8. Слишком тесно связанная архитектура В хорошей системе модули имеют понятные границы. Например:
- content;
- leads;
- payments;
- users.
В плохой системе всё постепенно начинает зависеть от всего. Content напрямую работает с CRM. CRM знает детали frontend. Payments меняет данные пользователей напрямую. Теперь удалить или заменить один компонент почти невозможно. И бизнес оказывается привязан к текущей реализации. Стоимость миграции растёт. Как technical debt превращается в деньги Связь можно представить простой цепочкой: Technical debt ↓ Больше времени на изменение ↓ Выше стоимость разработки ↓ Меньше функций за тот же бюджет Но есть и другие последствия. Медленнее выходят функции
Если конкурент запускает новую возможность за две недели, а ваша команда — за два месяца, проблема уже не только техническая. Это скорость бизнеса. Technical debt увеличивает time-to-market. Особенно опасно это для продуктов, которые должны постоянно экспериментировать. Дольше исправляются ошибки Когда архитектура непонятна, разработчик сначала ищет источник проблемы. Потом пытается понять: Что ещё может сломаться после исправления? MTTR растёт. Сайт дольше работает неправильно. Бизнес может терять:
- заявки;
- заказы;
- пользователей.
Команда меньше экспериментирует Есть ещё один менее очевидный эффект. Разработчики начинают избегать изменений. Появляются фразы: Это лучше не трогать. Здесь всё очень хрупко. Если поменяем — может сломаться оплата. Система начинает диктовать бизнесу: Какие идеи слишком опасно реализовывать. В здоровом продукте должно быть наоборот. Технология должна помогать бизнесу экспериментировать. Новые разработчики становятся дороже В хорошем проекте новый человек:
- читает документацию;
- запускает систему;
- смотрит tests;
- понимает модули.
В сильно задолжавшем проекте ему приходится учиться через археологию. Каждый новый сотрудник снова оплачивает часть старого technical debt своим временем. Как выглядит рост стоимости функции Условный пример. Похожая функция в начале проекта: 8 часов. Через год: 14 часов. Через два: 22 часа. Почему? Не обязательно потому, что разработчик стал медленнее. Теперь ему дополнительно нужно:
- разобраться в legacy;
- проверить зависимости;
- сделать ручной regression;
- аккуратно выполнить deployment;
- исправить связанные дефекты.
Бизнес видит рост оценки. Но причина находится не в новой функции. Она накопилась раньше. Стоимость изменения — одна из лучших метрик долга Technical debt сложно измерить одной цифрой. Но можно следить за динамикой. Например: Сколько в среднем занимает похожий тип изменения? Если небольшие задачи систематически становятся всё дороже, стоит искать архитектурные причины. Другие сигналы:
- количество production defects;
- duration regression;
- deployment time;
- MTTR;
- время onboarding разработчиков;
- доля задач на поддержку против новых функций.
Не каждый костыль нужно немедленно переписывать Важно не впадать в противоположную крайность. Не каждый imperfect code требует немедленного рефакторинга. Например, есть старый модуль. Он:
- работает стабильно;
- почти не меняется;
- не мешает новым функциям.
Переписывать его только ради чистоты кода может быть экономически бессмысленно. Technical debt нужно оценивать по процентной ставке . Если долг не мешает бизнесу, ставка низкая. Если из-за него каждая неделя разработки дорожает, ставка высокая. Когда технический долг оправдан Иногда сознательно сделать временное решение — правильно. Например: компания проверяет гипотезу. Неизвестно, будет ли функция нужна через месяц. Инвестировать неделю в идеальную архитектуру может быть неразумно. Можно сделать более простое решение. Но важно:
- осознанно признать долг;
- зафиксировать его;
- определить условия возврата.
Например: Если функция подтверждает спрос и остаётся после MVP, до следующего расширения рефакторим модуль. Тогда это управляемый долг. А не забытый костыль. Управляемый и неуправляемый technical debt
Управляемый
Команда знает:
- где находится компромисс;
- почему он был принят;
- какой риск создаёт;
- когда его нужно исправить.
Неуправляемый
Через два года кто-то спрашивает: Почему система работает именно так? Ответ: Не знаю. Так было всегда. Второй вариант намного опаснее. Как определить приоритет рефакторинга Не нужно переписывать весь проект. Можно оценивать долг по двум параметрам: Насколько часто меняется этот компонент? и Насколько сильно текущая реализация мешает изменениям? Например:
Компонент A
Плохой код. Но не менялся два года. Приоритет низкий.
Компонент B
CRM integration. Каждый месяц появляется новая задача. Любое изменение занимает в три раза больше нормы. Приоритет высокий. Так рефакторинг начинает конкурировать за бюджет не на основании: Разработчикам не нравится код. А: Этот участок регулярно увеличивает стоимость бизнеса. Рефакторинг — это не переписывание всего продукта Ещё одно важное различие. Technical debt не обязательно решается большим rebuild. Часто достаточно постепенно:
- добавить tests;
- автоматизировать deployment;
- отделить один модуль;
- обновить dependencies;
- убрать дублирование;
- документировать критические flows.
Это снижает проценты по долгу без опасной полной переработки системы. Пример постепенного погашения долга Представим проект с проблемами:
- нет automated tests;
- deployment ручной;
- CRM integration хрупкая;
- документации почти нет.
Необязательно останавливать roadmap на три месяца. Можно действовать поэтапно.
Спринт 1
Добавить smoke tests для критического flow.
Спринт 2
Автоматизировать deployment.
Спринт 3
Покрыть CRM integration API-тестами.
Спринт 4
Документировать архитектуру. Продукт продолжает развиваться. Но стоимость будущих изменений постепенно снижается. Когда долг становится критическим Есть несколько тревожных сигналов:
- небольшие задачи регулярно получают большие оценки;
- каждое изменение вызывает новые дефекты;
- релизы откладываются из-за страха сломать production;
- зависимости нельзя обновить;
- один разработчик знает критические части системы;
- regression занимает дни;
- deployment выполняется вручную;
- команда чаще исправляет старое, чем создаёт новое.
В этот момент technical debt уже перестал быть внутренней инженерной темой. Он стал проблемой экономики продукта. Technical debt влияет на TCO Совокупная стоимость владения системой — это не только: hosting + support + licenses. В неё входит стоимость изменений. Если один сайт позволяет добавить новую функцию за: 40 часов а другой требует: 120 часов при одинаковой бизнес-задаче, второй продукт дороже в эксплуатации. Даже если изначальная разработка стоила дешевле. Поэтому technical debt напрямую влияет на Total Cost of Ownership .
Как бизнесу говорить о technical debt с разработкой Не обязательно обсуждать:
- паттерны;
- классы;
- архитектурные абстракции.
Полезнее задавать бизнес-вопросы: Почему похожие функции стали занимать больше времени? Какой участок системы чаще всего вызывает дефекты? Что сегодня сильнее всего замедляет release? Где отсутствие автоматизации создаёт постоянную ручную работу? Какие технические улучшения снизят стоимость следующих пяти задач? Последний вопрос особенно важен. Потому что задача технического улучшения — не сделать код красивее. А снизить стоимость и риск дальнейшего развития. Подход VERB В VERB technical debt полезно рассматривать как часть экономики продукта.
Мы смотрим не только: Есть ли старый код? А: Сколько бизнес платит за его существование? Например:
- сколько времени занимает regression;
- сколько стоит deployment;
- насколько часто появляются defects;
- как быстро выпускается новая функция;
- сколько времени уходит на debugging;
- насколько система зависит от отдельных людей.
После этого debt можно разделить. Оставить Не создаёт заметной стоимости. Наблюдать Пока не мешает, но риск растёт. Рефакторить Регулярно увеличивает стоимость изменений. Заменить Поддержка уже дороже нового решения. Так технические решения получают понятный бизнес-приоритет. Главный тезис Технический долг опасен не потому, что код становится некрасивым. А потому, что система постепенно начинает брать налог с каждого будущего изменения. Сначала костыль экономит: 8 часов. Потом он добавляет: +2 часа к одной функции. +4 к другой. +8 к третьей.
Через год первоначальная экономия превращается в постоянный расход. Поэтому главный вопрос не: Есть ли у нас technical debt? Он есть почти у любого живого продукта. Правильный вопрос: Сколько процентов мы уже платим и какой долг стоит погасить первым?
Каждая новая функция становится дороже предыдущей?
VERB может провести аудит технического долга и определить:
- какие участки legacy-кода замедляют разработку;
- где не хватает automated tests;
- какие зависимости создают лишнюю связанность;
- сколько ручной работы остаётся в deployment;
- где отсутствует критическая документация;
- что можно рефакторить постепенно без полного rebuild.
На выходе — не список пожеланий разработчиков, а приоритетная карта: какой technical debt действительно стоит бизнесу денег и какие изменения сильнее всего снизят стоимость дальнейшего развития. Пришлите продукт на аудит — найдём места, где бизнес уже платит проценты по техническому долгу.