Перейти к содержимому
TelegramGitHub

Crafting Engineering Strategy, глава 22: Стратегия Stripe: разработчики, API, поглощения

Главная мысль: Stripe пошёл против моды 2010-х. Он почти не выводил API из использования, не разбивал монолит на сервисы и быстро встроил купленную компанию. Автор считает, что это сработало из-за внимания к деталям и из-за того, что стратегии держались десять лет.

Предыдущая глава разбирала стратегию product engineering в Calm. Эта глава последняя из кейсов. В ней четыре документа о Stripe:

  • как не выводить API из использования (deprecation);
  • модель systems modeling, которая проверяет, стоит ли это усилий;
  • почему Stripe написал проверщик типов Sorbet и не стал дробить монолит на Ruby;
  • как встроить поглощение Index за шесть месяцев.

Автор оговаривается: он не уверен, что эти подходы сработают в другой компании. Стратегию Sorbet придумала команда Product Infrastructure. Сам автор сначала хотел перейти на Java или Go, но его убедили результаты. Документы читают по шаблону главы 11: политика сверху, а логику ищут снизу вверх.

Документ 22.1: как Stripe выводит API из использования

Заголовок раздела «Документ 22.1: как Stripe выводит API из использования»

Автор считает это самой тонкой и недооценённой стратегией Stripe. Снаружи её почти не видно, но для бизнеса на API стабильность входит в фундамент.

  • Проектируйте API на долгую жизнь. Постройте тестовое приложение без этого API, перенесите его на новый и сами почувствуйте трение. Потом проверьте API на нескольких ранних клиентах.
  • Все новые и изменённые API одобряет API Review. В заявке нужно письменное предложение. Большинство одобряют асинхронно, сложные обсуждают вживую.
  • Не выводим API из использования без крайней необходимости, даже если поддержка дорогая. Deprecation здесь значит любое изменение, из-за которого клиент правит интеграцию. Исключение одобряют API Review и CEO. Пример: отказ от TLS 1.2 из-за требований PCI.
  • Новая функциональность получает новый API. Для подписок создали /v1/subscriptions, а /v1/charges не расширяли.
  • Технический долг берёт на себя слой преобразования версий. Внутри живёт одна реализация, последняя версия. Поверх неё цепочка преобразований поддерживает прежние версии. Каждое изменение API обязано обновить эту цепочку.
  • Позже SDK смягчат правило. Новые клиенты берут SDK, и часть сложности миграций можно спрятать в них. Но сегодня так ещё нельзя.

Клиент на старой версии API проходит через цепочку преобразований к единственной реализации; клиент на последней версии идёт напрямую

Старый запрос идёт через цепочку до последней версии. Новый запрос идёт сразу в реализацию.

  • Стартапу из инженеров сменить платёжный API просто. Малому бизнесу без инженеров или крупной компании с десятками стейкхолдеров очень тяжело.
  • Нестабильный API порождает отток клиентов (churn). Стабильный API ещё и удерживает: без принуждения к переписыванию быстрорастущие клиенты редко меняют провайдера.
  • Мало кто даёт долгую стабильность, особенно в платежах. Авторы других API не глупее: они просто не готовы вечно нести технический долг внутри.
  • Новые требования к безопасности (как TLS 1.3 для PCI) могут снова заставить менять API. Предсказать их трудно.

Это документ о systems modeling (глава 14). Внутренние данные уже связывали deprecation с оттоком. Модель нужна, чтобы понять, причина это или совпадение.

Модель состоит из пяти stocks и шести flows. Основной путь: потенциальные клиенты становятся вовлечёнными, потом интегрированными. К нему добавляются три потока:

  • базовый отток: интегрированный клиент уходит по любой причине, например компания закрылась;
  • deprecation: у клиента ломается используемый API, и он попадает в группу «задетых»;
  • повторная интеграция: задетый клиент обновляет интеграцию и возвращается. Иначе это уже отток, вызванный deprecation.

Шесть блоков модели: потенциальные, вовлечённые, интегрированные, задетые deprecation, повторная интеграция, ушедшие, и стрелки потоков между ними

Диаграмма читается слева направо по верхней строке, потом вниз и обратно через повторную интеграцию. Ушедшие клиенты собирают два оттока.

Базовый отток платёжного API трудно снизить: многие клиенты просто закрываются, а у остальных причина чаще в цене. Инженерные решения, наоборот, сильно влияют на число deprecation и на лёгкость повторной интеграции. Работа, которая упрощает повторную интеграцию, упрощает и первую, поэтому вложения туда выглядят самыми перспективными.

Автор задаёт модель на DSL пакета systems:

[PotentialCustomers] > EngagedCustomers @ 100
EngagedCustomers > IntegratedCustomers @ Leak(0.5)
IntegratedCustomers > ChurnedCustomers @ Leak(0.1)
IntegratedCustomers > DeprecationImpactedCustomers @ Leak(0.5)
DeprecationImpactedCustomers > IntegratedCustomers @ Leak(0.9)
DeprecationImpactedCustomers > ChurnedCustomers @ Leak(0.1)

@ 100 значит «100 клиентов за раунд». Leak(0.5) значит, что за раунд переходит 50% запаса. Значения нарочно жёсткие. Для платёжного API 50% deprecation очень много, но у некоторых провайдеров так бывает: Facebook Ads API в 2012–2014 годах раз в квартал убирал важное поле.

Мы повторили четыре сценария (файл scripts/crafting-engineering-strategy-code/ch22_api_deprecation_model.py, запуск в venv с systems==0.1.0). В таблице интегрированные клиенты на 40-м и 100-м раунде и задетые deprecation на 100-м:

Сценарий раунд 40 раунд 100 затронуты
1. deprecation 50%, обычный уход 10% 899 959 527
2. deprecation 10%, обычный уход 10% 972 999 109
3. deprecation 50%, обычного ухода нет 1386 1780 977
4. deprecation 10%, обычного ухода нет 2907 5731 625
  • Исходная модель стабилизируется примерно на 1000 интегрированных клиентов за 40 раундов.
  • Если снизить deprecation с 50% до 10%, задетых станет намного меньше, но интегрированных вырастет всего на 4–5%. Значит, число интегрированных клиентов в основном определяет другой поток: базовый отток.
  • Без базового оттока и при 50% deprecation клиентов около 1750 (у нас 1780). При 10% их около 6000 (у нас 5731), и линия не выходит на плато.

Главный вывод: одно снижение deprecation почти ничего не даёт, пока высок базовый отток, и наоборот. Каждое снижение усиливает другое, поэтому отток надо уменьшать как систему, а не набором разрозненных улучшений.

Сетка из четырёх сценариев: слева 50% deprecation, справа 10%, сверху базовый отток 10%, снизу его нет; число клиентов растёт от 960 до 5700

Стрелки показывают два шага улучшения. Эффект больше всего растёт, когда сделаны оба.

Команда Product Infrastructure отвечает за developer productivity. Раз в полгода она выбирает три главные области и отдаёт им почти всю энергию. Приоритеты пересматривают после опроса разработчиков и показывают на Quarterly Business Review. Три приоритета этого полугодия:

  1. Статическая типизация самых ценных частей Ruby-кода. Проверщик типов (type checker) работает локально и на тестовых машинах и быстро находит ошибки. Это нетипичное решение, и оно займёт 12–24 месяца значительной части времени команды. Зато проверщик (его назовут Sorbet) оставит всех в текущей кодовой базе. Product-инженеры продолжат делать функции, а не переносить старый код на другие сервисы или языки. Разработку и первый rollout команда возьмёт на себя.
  2. Выборочный запуск тестов (selective test execution). Разработчик быстро запускает локально подходящие тесты и не ждёт сервер сборки. Без типов трудно точно вычислить, какие тесты нужны. Но покрытие высокое, а полный прогон всё равно будет перед выпуском. Поэтому можно статистически угадывать, какие тесты упадут после правки файла.
  3. Измерение падений тестов. Самый низкий приоритет. Цель — данные для будущих приоритетов. В этом полугодии размечают только падения, причина которых точно известна: инфраструктура или сам тест.

Риск ограничен. Сложные места команда типизирует вручную, простые переписывает скриптами по абстрактному синтаксическому дереву (AST). Если подход провалится, цена известна: около шести месяцев работы половины команды. Основа для оптимизма — опыт проекта Hack в Facebook: проверщик будет намного быстрее тестов, проверка всей кодовой базы займёт меньше 30 секунд. Всю базу не нужно типизировать сразу: начинают с самых ценных мест. Чтобы типы было проще добавлять постепенно, product-инженерам советуют паттерн CQRS (разделение команд и запросов).

В 2017 году в Stripe около 1000 человек, из них 400 разработчиков. Рост планируют около 70% в год. Продакшен стал стабильнее, теперь фокус на developer productivity.

  • Команда Product Infrastructure для Ruby — это около 10 человек на 250 product-инженеров. Она будет расти заметно медленнее самой разработки.
  • Сигналы идут из метрик (деплой, покрытие, время и нестабильность тестов) и из опроса два раза в год.
  • Покрытие выше 99% строк, но локально тесты медленные. Быстрыми они стали только на большом парке серверов. Поэтому разработчики гоняют слишком узкий набор тестов или ждут сервер. Цикл слияния, сборки и тестов занимает 20–30 минут, и люди теряют фокус иногда на несколько часов.
  • Данных, откуда берётся нестабильность тестов (инфраструктура или сами тесты), нет.
  • Опрос добавляет тревожную деталь: давние сотрудники продуктивны, а недавно нанятые опытные инженеры нет. Им трудно понять, как безопасно менять код.
  • Продукт живёт в одном Ruby-монолите. Исключение: узкий Go-сервис токенизации платежей. Инфраструктура данных написана на Scala. Эта группа небольшая и сама управляет сборкой и деплоем.
  • Ruby не самый быстрый язык, но основные расходы идут на хранилища и пакетные вычисления, а не на процессор. Только ради скорости менять основной язык не стали бы.
  • Команды Go и Scala просят поддержки, но 240 человек на Ruby весят больше, чем 10 на Go и 40 data-инженеров на Scala. Каждый новый язык усложнил бы выбор приоритетов.

При поглощениях обычно обсуждают проверку технологий и решение о покупке. Автор считает, что интеграция после сделки бывает сложнее: необратимых решений мало, но ранние решения удивительно живучи. Команда интеграции, как обычно, узнала о проекте уже после закрытия сделки. Поэтому первые недели нужны, чтобы отделить оптимистичные даты от реальности через strategy testing (глава 13).

Общего контекста мало, на запуск совместного продукта шесть месяцев. Поэтому политика сочетает общий пересмотр и временные архитектурные правила:

  • Встречаться минимум раз в неделю до первого релиза. Встречу ведут вместе глава Traffic Engineering в Stripe и глава разработки в Index.
  • Минимизировать изменения в среде токенизации (tokenization environment). Терминал работает с данными карт, поэтому API для него живёт в защищённой среде. Больше туда ничего не добавляют.
  • Всё остальное работает в стандартных средах, особенно ПО с частыми изменениями или сложными внешними зависимостями.
  • Решение о Java откладываем. Java противоречит текущей стратегии, но стейкхолдеры не договорились, а спор мешал бы сроку. К нему вернутся после релиза.
  • Эскалации идут сразу к обоим главам, потому что общего контекста мало.
  • Ревью безопасности обязательно для изменений в среде токенизации. Скорость не оправдывает компромиссов с безопасностью.

Терминал обращается к API в среде токенизации, API отдаёт токен остальным сервисам в стандартных средах, ревью безопасности подписывает изменения

Автор выделяет четыре вида поглощений: ради таланта, ради бизнеса (выручка и продукт), ради технологии и ради скорости выхода на рынок (time-to-market acquisition). Здесь главное последнее.

  • Крупные клиенты просят кассовый терминал, интегрированный с платёжной экосистемой. Минимум один намекал, что без срока уйдёт к конкуренту.
  • Опыта с железом нет. Свой терминал занял бы около года.
  • Конкурент Square выбрал вертикальную интеграцию. Его API слабее, но он остаётся вариантом для уходящих клиентов.
  • Минимум один корпоративный клиент уйдёт, если срок будет 12 месяцев. Поэтому решили купить небольшую компанию и пообещать шесть месяцев.
  • Деталей почти нет. Index в основном на Java в AWS, Stripe на Ruby с частью Go. Терминал знает данные карт, а по требованиям соответствия их можно держать только в изолированной среде токенизации. Она превращает данные в токен, и остальные среды работают с токеном без тех же обязательств.

Прошлые поглощения Stripe были малыми и без продукта для встраивания, поэтому плана не было. Команда собрала опыт по прошлым работам и разговорам с коллегами (глава 6). Повторяются такие закономерности:

  1. Команда сделки и купленная команда часто дали обещания, которые трудно выполнить. Если люди ведут себя странно, причина может быть в таком непонимании. Разберитесь с ним напрямую.
  2. Нужен спонсор поглощения среди руководителей высшего звена (executive sponsor). Если его нет или он не вовлечён, найдите нового.
  3. Закрывайте разрыв в культуре быстро там, где мало трения, и осторожно там, где мало доверия. Лучше всего работает перемещение людей между командами, а не давление.
  4. Новый стек дорого поддерживать, и он противоречит стратегии с минимумом языков. Здесь уступать нельзя: каждая новая функция на новом стеке уводит дальше от цели.
  5. Снизьте риск ухода ключевых людей. Один простой шаг: сразу объединить инфраструктуру, даже если продукт подождёт.

Автор признаёт, что исследование вышло неободряющим: абстрактным и с противоречивыми мнениями. Возможно, как и запуск стартапа, поглощения не имеют верного способа.

  • Три стратегии Stripe шли против моды: почти нет deprecation API, нет декомпозиции монолита, интеграция Index за шесть месяцев.
  • Автор считает главным фактором успеха внимание к деталям и десять лет последовательного применения.
  • Stripe выводит API из использования только по неизбежной причине. Долг от этого несёт слой преобразования версий с одной реализацией внутри.
  • Модель показала, что deprecation и базовый отток усиливают друг друга, поэтому отток надо снижать целиком.
  • Вместо декомпозиции Product Infrastructure построила Sorbet, и product-инженеры остались в Ruby.
  • Приоритеты developer productivity стоят на метриках и опросе, и их пересматривают раз в полгода.
  • При интеграции Index в среду токенизации попал минимум изменений, остальное ушло в стандартные среды, а решение о Java отложили.
ТерминЗначение
deprecationЛюбое изменение, из-за которого клиент должен править интеграцию
API ReviewГруппа, которая одобряет все новые и изменённые API
слой преобразования версийОдна реализация плюс цепочка преобразований для старых версий
отток (churn)Клиенты уходят к другому провайдеру или совсем
SorbetПроверщик типов для Ruby, созданный в Stripe
tokenization environmentИзолированная среда, где хранят данные карт
time-to-market acquisitionПокупка ради скорости: сами могли бы, но дольше
  • Меняете витрину или API данных: добавляйте новую версию рядом, а не ломайте поля у потребителей. Каждый удалённый столбец становится deprecation для всех, кто его читает.
  • Держите одну актуальную реализацию и превращайте старые форматы слоем преобразования. Не поддерживайте несколько версий pipeline параллельно.
  • Когда тесты dbt стали долгими, запускайте локально только затронутые модели. Это выборочный запуск тестов.
  1. Почему Stripe счёл стабильность API бизнес-решением, а не только техническим?
  2. Почему снижение deprecation с 50% до 10% почти не изменило число клиентов, а без базового оттока изменило сильно?
  3. Почему Product Infrastructure выбрала Sorbet, а не миграцию на Java или Go?
  4. Как тип поглощения (ради скорости, а не ради таланта) повлиял на политику интеграции Index?

Предыдущая: Стратегия продуктовой разработки. Следующая: Хороша ли эта стратегия.