Новая функция работает, а после обновления поплыли отчёты и интеграции. Разбираем, откуда берутся такие побочные эффекты, при чём здесь архитектура и когда пора заказывать технический аудит.
Представим компанию, которой нужно отслеживать частичные отгрузки. Для этого в обработку заказов добавляют ещё один статус. Задача выглядит простой: разработчики вносят правки, проверяют новый статус и выпускают обновление.
Через несколько дней бухгалтерия находит расхождения в отчётах, а на складе часть заказов перестаёт обрабатываться. Сам статус работает именно так, как задумывали. Просто изменение задело то, что команда трогать не собиралась.
Для бизнеса это означает лишние расходы, сорванные сроки следующих релизов и разработку, которую невозможно спрогнозировать. А чем дольше живёт система, тем сложнее понять, почему мелкая правка потянула за собой столько последствий.
Почему одна правка задевает сразу несколько процессов
В корпоративном ПО функции почти никогда не существуют сами по себе. Возьмём систему управления заказами. Статус заказа нужен не только менеджерам, от него зависят:
● расчёт выручки и финансовая отчётность;
● резервирование и списание товаров;
● закрывающие документы;
● данные в CRM;
● обмен с внешними сервисами.
Пока статусов три, все эти модули работают по одним и тем же правилам. Когда появляется четвёртый, каждый из них нужно научить с ним обращаться. Если модули сами разбирают значения статусов, то менять придётся много мест, и в одном из них легко промахнуться. Например, разработчики обновят интерфейс и основную логику, но не заметят проверку в старом модуле отчётности. Новая функция заработает, а остальная система продолжит жить по прежним правилам.
Такие связи называют скрытыми зависимостями: их не видно, пока не начнёшь менять код. Особенно много их накапливается в системах, которые развиваются годами, переходят от одной команды к другой и обрастают интеграциями.
Как архитектура влияет на стоимость изменений
Архитектура определяет, на какие части разделена система, где лежит бизнес-логика и как модули обмениваются данными. Звучит как тема для технических специалистов, но именно от неё сильно зависит, во сколько обойдётся следующая доработка.
Сравним два устройства одной и той же системы.
Логика собрана в одном месте. Правила обработки заказов лежат в отдельном компоненте, остальные модули обращаются к нему через понятные интерфейсы. Если порядок обработки статусов меняется, команда правит общую логику и проверяет связанные сценарии.
Одни и те же правила продублированы. Проверки статусов разбросаны по складскому модулю, отчётности, интеграции с CRM и другим компонентам. При изменении процесса разработчикам нужно найти все копии старых правил, обновить их и убедиться, что всё продолжает работать вместе.
Поэтому одна и та же доработка в двух системах с одинаковым набором функций может отличаться по трудозатратам в разы. Дело не только в качестве кода, но и в том, как компоненты связаны друг с другом и можно ли менять их по отдельности.
Сложная архитектура сама по себе не беда: большой системе с множеством процессов простое устройство не подойдёт. Важно, чтобы сложность была оправдана и чтобы команда могла оценить последствия изменения ещё до начала работы.
Откуда берётся технический долг
Одна из причин дорогого сопровождения — технический долг. Он возникает, когда ради скорости выбирают решение, которое потом усложнит развитие системы.
Допустим, функцию нужно запустить срочно. Разработчики понимают, что правильнее было бы сначала переработать общий механизм обработки данных, но времени нет, и в существующий модуль просто добавляют ещё одно условие. На момент запуска это нормально: бизнес получил, что хотел, и не стал откладывать важный процесс.
Проблемы начинаются, когда таких временных решений становится много. Через год оказывается, что одинаковые правила живут в разных частях программы, документация расходится с реальностью, а прежде чем взяться за новую задачу, приходится разбираться с десятками старых условий.
Технический долг не равен ошибкам. Программа может стабильно решать свои задачи и при этом стоить дорого в сопровождении. Скажем, стоимость заказа считается верно, но алгоритм расчёта скопирован в несколько модулей. Любое изменение правил придётся вносить в каждую копию. Вот эта цена будущих изменений и есть долг.
При этом гасить весь долг подряд не нужно. Если компонент редко меняется, надёжно работает и не мешает развитию продукта, переделывать его может быть невыгодно. Сначала стоит выяснить, какие решения реально увеличивают расходы или создают риски.
Почему тестирование не всегда ловит такие ошибки
После неудачного обновления обычно спрашивают: как это пропустили при проверке? Дело в том, что проверить новую функцию и проверить, не сломала ли она старую систему, — разные задачи.
В примере со статусом команда убедится, что новое значение появляется в интерфейсе, сохраняется в базе и выбирается пользователем. Все проверки пройдут. Но формирование финансового отчёта и передачу данных в складскую программу эти тесты могут не затрагивать. В итоге новое работает, а старое сломано.
Такие ошибки называют регрессионными, а повторную проверку уже существующих функций после изменений — регрессионным тестированием. Прогонять все сценарии крупной системы после каждой мелкой правки обычно слишком дорого. Автотесты тоже требуют ухода: их приходится обновлять вместе с логикой, а нестабильные тесты нередко дают ложные срабатывания.
Поэтому дело не в том, чтобы просто написать больше тестов. Нужно понимать, с чем связана изменяемая функция, какие процессы могут пострадать и что проверять в первую очередь. Без знания архитектуры даже большой набор тестов не гарантирует, что проблему найдут.
Когда дело уже не в отдельной ошибке
Один неудачный релиз не говорит о том, что системе нужна серьёзная модернизация. Причиной может быть нечёткое требование, ошибка в настройках, недоступный внешний сервис или обычный дефект. Но если проблемы повторяются, стоит посмотреть на устройство системы. На что обратить внимание:
1. После обновлений регулярно ломаются старые функции. Команда чинит одно, а вскоре находит новую поломку в другом модуле. Это признак скрытых зависимостей и слабого контроля над последствиями изменений.
2. Простые задачи занимают всё больше времени. Добавить поле или поменять расчёт — это недели, потому что приходится трогать множество компонентов.
3. Сроки трудно назвать заранее. До начала работы непонятно, какие части системы придётся менять и что может сломаться.
4. Одни и те же проблемы возвращаются. Исправляют проявления, а не причину.
5. Интеграции работают нестабильно. Данные приходят с задержкой, теряются или требуют ручной сверки.
6. Обновления приходится откатывать. Каждый релиз превращается в рискованную операцию с дополнительными проверками и ручной работой.
По отдельности у каждого признака могут быть разные причины. Но если несколько повторяются одновременно, пора думать о техническом аудите.
Что должен дать технический аудит
Технический аудит — это обследование архитектуры, кода, инфраструктуры, интеграций и процессов разработки. Список замечаний бизнесу сам по себе мало что даёт. Полезнее получить ответы на конкретные вопросы:
● какие компоненты создают основные риски;
● почему небольшие изменения требуют так много работы;
● где находятся критичные зависимости;
● что можно исправить локально, а что требует перестройки архитектуры;
● какие доработки дадут наибольший эффект при разумных затратах.
Итогом должен быть понятный план с приоритетами, оценкой трудоёмкости и рисков.
Аудит не обязательно заканчивается решением всё переделать. Иногда хватает оптимизировать несколько запросов к базе, изменить обработку ошибок или убрать дублирование важной логики. В других случаях нужна постепенная модернизация отдельных компонентов. Решение стоит принимать по фактическому состоянию продукта, а не из убеждения, что старый код надо заменить новым.
Чинить ошибки или переписывать систему
Когда проблем становится много, возникает соблазн заменить ПО целиком. Кажется, что новая система избавит от накопленных ограничений и позволит начать с чистого листа. Но у этого пути свои риски.
За годы работы программа обрастает бизнес-правилами: нестандартными расчётами, исключениями, особенностями интеграций, привычными пользовательскими сценариями. Часть этих правил существует только в коде. При создании новой системы их нужно найти, описать и реализовать заново. Иначе современное с технической точки зрения решение окажется для бизнеса менее функциональным, чем старое.
Обычно выбирают из трёх подходов.
Локальное исправление. Подходит, когда причина в конкретном компоненте и общую архитектуру менять не нужно.
Поэтапная модернизация. Проблемные части системы перерабатывают постепенно, а рабочие компоненты и действующие процессы остаются.
Полная переработка. Оправдана, когда платформа принципиально не отвечает требованиям, а её дальнейшее развитие экономически бессмысленно.
Что выбрать, зависит от состояния продукта, стоимости сопровождения, планов развития и рисков перехода. Готового ответа на все случаи нет.
Как АЙТИФОКС модернизировала инвестиционную платформу без полной переработки
С похожими ограничениями команда АЙТИФОКС столкнулась на проекте инвестиционной онлайн-платформы. Заказчик пришёл после двух предыдущих команд разработки. Платформа работала, но развитию мешали низкая производительность, нестабильные интеграции и отсутствие технической документации.
Страницы реестра загружались от 20 до 60 секунд. Часть данных из внешних источников не поступала, а некоторые операции приходилось выполнять вручную. Систему нужно было подготовить к отраслевому мероприятию за полтора месяца. Полная переработка в такие сроки не укладывалась и добавляла рисков, поэтому команда начала не с нового кода, а с обследования.
За первые две недели специалисты изучили архитектуру, запросы к базе данных, интеграции и инфраструктуру. Выяснилось, что система грузит слишком много лишних данных: при открытии карточки компании запрашивалось значительно больше, чем нужно пользователю. Дополнительную нагрузку создавал механизм поиска. В интеграциях не хватало надёжной обработки ошибок и прозрачного контроля обмена данными.
Сначала разработчики внедрили кэширование, чтобы ускорить ключевые страницы к мероприятию. Затем последовательно оптимизировали запросы, доработали API, изменили механизм поиска и внедрили Kafka для более управляемого обмена данными. Параллельно настроили тестовую среду, мониторинг ошибок и автоматическое развёртывание.
Время загрузки ключевых страниц сократилось с 20–60 секунд до 200–500 миллисекунд. Платформа получила основу для дальнейшего развития, и заменять её целиком не пришлось.
Этот проект не пример регрессионной ошибки после добавления функции. Но он показывает, что даже серьёзные ограничения действующего ПО не всегда означают, что продукт нужно делать заново. Часто достаточно сначала разобраться в архитектуре, затем устранить самые критичные проблемы и дальше модернизировать систему по частям.
Как сделать доработки предсказуемее
Исключить ошибки в развитии сложных систем нельзя, но можно снизить вероятность серьёзных сбоев и смягчить их последствия.
1. Оценивайте влияние изменений до начала разработки. Если добавляется новый статус заказа, заранее выясните, какие компоненты используют эти данные. Проверять нужно не только интерфейс, но и отчётность, документы, складские операции и интеграции.
2. Выделите критичные сценарии для регрессионного тестирования.
3. Продумайте безопасный выпуск и откат. В крупных системах новую функцию иногда разумнее сначала включить для ограниченной группы пользователей.
4. Следите за результатами после релиза. Смотрите не только на технические ошибки, но и на расхождения в данных, неуспешные операции и отклонения в ключевых бизнес-процессах.
5. Считайте, на что уходит время команды. Если доля работ по исправлению последствий прошлых изменений растёт, пора искать причины.
Итог
Если небольшие доработки занимают непропорционально много времени, а новые функции регулярно ломают старые, причина может быть не в сложности самих задач. Нередко её нужно искать в архитектуре, накопленных зависимостях и техническом долге. Увеличение команды или числа тестов тут не всегда помогает, но и полная переделка не обязательно будет правильным решением.
Разумнее сначала обследовать систему, найти источники проблем и сопоставить возможные изменения с затратами и рисками. Цель хорошей архитектуры не в идеальном коде, а в том, чтобы ПО можно было развивать без постоянного роста расходов и неожиданных последствий.
АЙТИФОКС занимается техническим аудитом, доработкой и модернизацией действующего программного обеспечения. Мы исследуем существующие системы, выявляем ограничения и помогаем развивать продукты с учётом бизнес-процессов, сроков и стоимости сопровождения.