Ретраи и экспоненциальный backoff: jitter, бюджет повторов и Retry-After
Как правильно повторять запросы: какие ошибки ретраить, экспоненциальный backoff с jitter, общий дедлайн, Retry-After, бюджет ретраев против шторма и связь с идемпотентностью. Код на Python и JS.
Коротко
| Вопрос | Короткий ответ |
|---|---|
| Что ретраить | таймауты, обрывы, 408, 429, 500, 502, 503, 504 |
| Что не ретраить | 400, 401, 403, 404, 409, 422 и любой неидемпотентный запрос без ключа |
| Сколько ждать | экспонента с потолком: |
| Зачем jitter | без него клиенты возвращаются синхронными волнами и снова кладут сервер |
| Сколько попыток | 3–5 и общий дедлайн, который не длиннее терпения пользователя |
| Как не устроить DDoS | ретраить в одном слое, бюджет повторов, circuit breaker, уважать Retry-After |
| Как не списать дважды | один Idempotency-Key на все попытки одной операции |
- Ретрай — это лекарство от коротких случайных сбоев. От долгого сбоя он не лечит, а усугубляет.
- Повторять можно только то, что безопасно повторить. Это вопрос к серверу (идемпотентность), а не к клиенту.
- Повторы — это дополнительная нагрузка ровно в тот момент, когда сервису хуже всего. Поэтому у них должен быть бюджет.
Эта статья — подробный разбор именно ретраев. Как ретраи сочетаются с размыканием цепи и таймаутами, описано в статье про Circuit Breaker, а как сервер переживает повтор неидемпотентного запроса — в статье про идемпотентность API.
Зачем вообще повторять
В распределённой системе часть запросов падает всегда, даже когда «всё работает»: пакет потерялся, под перезапустился при деплое, балансировщик отдал 502, пока снимал мёртвый экземпляр, в базе случился дедлок. Такие сбои временные и независимые: если через 100 мс спросить ещё раз, скорее всего, ответят.
Посчитаем. Пусть 1% запросов падает случайно и независимо. Одна попытка даёт 99% успеха, две — , три — . Ретрай превращает «два девятки» в «шесть» почти бесплатно: повторяется всего 1% запросов.
Но это работает только при независимых сбоях. Если сервис лежит целиком, вероятность ошибки на каждой попытке близка к 1, и три попытки дают три ошибки и втрое больше нагрузки. Вся инженерия вокруг ретраев — про то, как получить выигрыш в первом случае и не платить во втором.
Что можно повторять
Решение принимается по двум вопросам: временная ли ошибка и безопасно ли повторять операцию.
Временная ли ошибка
- Да: таймаут, обрыв соединения,
ECONNRESET, 502/503/504 от прокси, 429 «слишком много запросов», 408 «таймаут запроса», дедлок и ошибка сериализации в базе. - Нет: 400 (кривой запрос), 401/403 (нет прав), 404, 409 (конфликт состояния), 422 (не прошла валидация). Повтор вернёт то же самое, только позже.
- 500 — серая зона. Это может быть и случайный сбой, и баг, который воспроизводится на каждом запросе. Обычно 500 ретраят, но одной-двумя попытками.
Безопасно ли повторять
Клиент, получивший таймаут, не знает, что произошло на сервере: запрос не дошёл, дошёл и упал, или выполнился, но потерялся ответ. Для GET разницы нет. Для POST /payments повтор во втором случае означает второе списание.
По спецификации HTTP идемпотентны GET, HEAD, OPTIONS, PUT, DELETE. POST и PATCH — нет. Чтобы ретраить POST, нужен ключ идемпотентности: клиент генерирует его один раз, сервер запоминает результат по ключу и на повтор отдаёт сохранённый ответ.
Есть один случай, когда повтор безопасен всегда: запрос гарантированно не ушёл. Например, не удалось установить TCP-соединение или DNS не разрешил имя. Сервер ничего не видел.
from datetime import datetime, timezone from email.utils import parsedate_to_datetime RETRYABLE_STATUS = {408, 429, 500, 502, 503, 504} IDEMPOTENT_METHODS = {'GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE'} def should_retry(method, status=None, sent=True, has_idempotency_key=False): """status=None — ответа нет (таймаут, обрыв). sent=False — запрос точно не ушёл на сервер (не удалось установить соединение).""" if not sent: return True # сервер ничего не видел, повтор безопасен if status is not None and status not in RETRYABLE_STATUS: return False # 4xx: повтор вернёт то же самое return method in IDEMPOTENT_METHODS or has_idempotency_key print(should_retry('GET', 503)) # True print(should_retry('POST', None)) # False: мог пройти print(should_retry('POST', None, has_idempotency_key=True)) # True print(should_retry('POST', None, sent=False)) # True print(should_retry('PUT', 404)) # False
Экспоненциальный backoff
Повторять сразу — плохая идея. Если сервис упал от перегрузки, мгновенный повтор от всех клиентов удваивает нагрузку. Поэтому между попытками ждут, и пауза растёт геометрически:
С base = 100 мс паузы будут 0.1, 0.2, 0.4, 0.8, 1.6 с. Экспонента хороша тем, что быстро «отступает»: короткий сбой переживается за первые попытки, а при долгом клиенты быстро уходят на большие паузы и перестают давить. Потолок cap нужен, чтобы пауза не выросла до часа.
Сумма пауз за попыток — это , то есть почти вдвое больше последней паузы. Пять повторов с base = 100 мс — это уже 3.1 с ожидания. Держите это в голове, когда выбираете число попыток.
Jitter: зачем нужен случайный разброс
Представьте, что сервис лёг, и тысяча клиентов получила ошибку в одну и ту же секунду. С чистой экспонентой все они вернутся через 100 мс, потом через 300 мс, потом через 700 мс. Это не размазанная нагрузка, а залпы: сервер, который только начал подниматься, получает 1000 запросов одновременно, и падает снова.
Решение — добавить случайность. Самые известные варианты разобрал Марк Брукер в статье «Exponential Backoff And Jitter» в блоге AWS Architecture (2015):
import random BASE, CAP = 0.1, 5.0 def exponential(attempt): return min(CAP, BASE * 2**attempt) def full_jitter(attempt): # от нуля до экспоненциального потолка return random.uniform(0, exponential(attempt)) def equal_jitter(attempt): # половина гарантирована, вторая половина случайна half = exponential(attempt) / 2 return half + random.uniform(0, half) def decorrelated_jitter(prev): # prev — предыдущая задержка, на первом шаге равна BASE return min(CAP, random.uniform(BASE, prev * 3)) random.seed(1) prev = BASE print('попытка экспонента full equal decorr') for attempt in range(7): prev = decorrelated_jitter(prev) print(f'{attempt + 1:>7} {exponential(attempt):>10.2f} ' f'{full_jitter(attempt):>5.2f} {equal_jitter(attempt):>5.2f} {prev:>6.2f}')
попытка экспонента full equal decorr 1 0.10 0.08 0.09 0.13 2 0.20 0.10 0.14 0.17 3 0.40 0.32 0.22 0.37 4 0.80 0.67 0.57 0.13 5 1.60 0.00 1.16 0.32 6 3.20 0.73 3.11 0.72 7 5.00 0.15 2.56 1.95
- Full jitter — пауза случайна целиком. Лучше всего рассинхронизирует клиентов, но может выдать почти ноль.
- Equal jitter — гарантирует хотя бы половину экспоненты. Компромисс, если совсем короткие паузы нежелательны.
- Decorrelated jitter — каждая пауза зависит от предыдущей, а не от номера попытки. Растёт в среднем экспоненциально, но «гуляет» сильнее.
Как выглядят волны
Смоделируем: сервер лежит, 1000 клиентов получили ошибку в момент 0 и делают по 5 повторов. Посчитаем, сколько повторов прилетает в каждые 200 мс.
import random from collections import Counter BASE, CAP = 0.1, 5.0 def no_jitter(attempt): return min(CAP, BASE * 2**attempt) def full_jitter(attempt): return random.uniform(0, min(CAP, BASE * 2**attempt)) def equal_jitter(attempt): half = min(CAP, BASE * 2**attempt) / 2 return half + random.uniform(0, half) def timeline(strategy, clients=1000, attempts=5, slot=0.2, seed=3): """Сколько повторов пришло в каждый слот по slot секунд.""" random.seed(seed) load = Counter() for _ in range(clients): t = 0.0 for attempt in range(attempts): t += strategy(attempt) load[int(t / slot)] += 1 return [load[s] for s in range(12)] for name, strategy in [('без jitter', no_jitter), ('full jitter', full_jitter), ('equal jitter', equal_jitter)]: row = timeline(strategy) print(f'{name:<13}', ' '.join(f'{n:>4}' for n in row))
без jitter 1000 1000 0 1000 0 0 0 1000 0 0 0 0 full jitter 1908 832 594 330 288 270 179 134 134 118 92 72 equal jitter 1238 787 828 149 196 499 292 11 20 104 213 265
Без jitter видны залпы по 1000 запросов и тишина между ними. С full jitter нагрузка плавно затухает.
Но посмотрите на первый слот: у full jitter там 1908 запросов, больше, чем без jitter. Первые паузы у него крошечные (от 0 до 100 и от 0 до 200 мс), и почти все клиенты успевают сделать по две попытки в первые 200 мс. Jitter размазывает нагрузку только в пределах окна, а окно на первых попытках маленькое. Отсюда два практических вывода:
baseне должен быть слишком маленьким. 10 мс для сервиса, который поднимается секундами, — бессмысленно частые попытки.- Если первые ретраи опасны, подойдёт equal jitter или минимальная пауза снизу.
Какой jitter выбрать — вопрос второго порядка. Главное, чтобы он был. Full jitter проще всего объяснить, и он используется, например, в политике ретраев gRPC: там пауза выбирается случайно от нуля до экспоненциального потолка.
Дедлайн, а не только число попыток
«Четыре попытки» ничего не говорят о времени. Если каждая попытка ждёт ответа 5 секунд, четыре попытки — это 20 секунд плюс паузы. Пользователь ушёл через три.
Правильнее думать от общего дедлайна: на всю операцию есть, скажем, 3 секунды. Каждая попытка получает в качестве таймаута остаток этого времени, а если до следующей попытки по расписанию backoff не дожить — сдаёмся сразу, а не спим впустую.
В цепочке сервисов дедлайн передаётся дальше: сервис B, которого вызвали с оставшимися 800 мс, не должен начинать запрос к C с таймаутом 5 секунд. В gRPC это встроено — дедлайн уходит в метаданных вызова. В HTTP его передают своим заголовком.
Retry-After: когда сервер знает лучше
Ответы 429 и 503 могут прийти с заголовком Retry-After. Это прямое указание: «приходи не раньше чем через столько». Значение бывает в двух форматах — числом секунд или HTTP-датой:
Retry-After: 120 Retry-After: Mon, 09 Nov 2026 12:01:30 GMT
def parse_retry_after(value, now=None): """Retry-After бывает в секундах ('120') или HTTP-датой.""" if value is None: return None value = value.strip() if value.isdigit(): return float(value) try: moment = parsedate_to_datetime(value) except (TypeError, ValueError): return None # мусор в заголовке — используем свой backoff now = now or datetime.now(timezone.utc) return max(0.0, (moment - now).total_seconds()) now = datetime(2026, 11, 9, 12, 0, 0, tzinfo=timezone.utc) print(parse_retry_after('30')) # 30.0 print(parse_retry_after('Mon, 09 Nov 2026 12:01:30 GMT', now)) # 90.0 print(parse_retry_after('скоро')) # None
Если Retry-After больше оставшегося дедлайна, честнее сразу вернуть ошибку, чем ждать. Как сервер решает, кому и на сколько отказать, разобрано в статье про rate limiter.
Шторм ретраев и бюджет повторов
Умножение по слоям
Мобильное приложение делает 3 попытки, API-шлюз — 3, сервис заказов к сервису склада — 3. Склад лёг, и каждое нажатие кнопки превращается в запросов к складу. При слоях с попытками это . Ретраи, призванные помогать, становятся DDoS-атакой на собственный бэкенд.
Правило: ретраит один слой. Обычно тот, что ближе всего к упавшей зависимости, — он лучше всех знает, какие ошибки временные. Остальные слои пробрасывают ошибку наверх, возможно, с пометкой «уже ретраили, не повторяй».
Метастабильный отказ
Есть сценарий хуже. Сервис кратковременно притормозил, часть запросов отвалилась по таймауту, клиенты их повторили. Нагрузка выросла, сервис тормозит сильнее, таймаутов больше, повторов больше. Исходная причина давно исчезла, а система держит себя в лежачем состоянии сама: её добивают ретраи. Такое состояние называют метастабильным отказом (статья Bronson и соавторов «Metastable Failures in Distributed Systems», 2021). Выйти из него помогает только резкое снижение входящей нагрузки — то есть ретраи надо уметь выключать автоматически.
Бюджет ретраев
Идея: ретраи допустимы, пока их немного относительно обычного трафика. Когда ошибок мало — повторяем свободно. Когда сервис лежит — повторы сами собой выключаются.
Так устроен retryThrottling в gRPC: у клиента есть счётчик токенов, каждая ошибка отнимает 1, каждый успех возвращает tokenRatio, а ретраи разрешены, пока токенов больше половины максимума. Похожие механизмы есть в Finagle и Linkerd, а в книге Google SRE предлагают держать долю повторов не выше 10% от запросов клиента.
import random class RetryThrottle: """Бюджет ретраев в духе gRPC retryThrottling. Ошибка отнимает 1 токен, успех возвращает token_ratio. Повторять можно, пока токенов больше половины.""" def __init__(self, max_tokens=100, token_ratio=0.1): self.max_tokens = max_tokens self.token_ratio = token_ratio self.tokens = max_tokens def on_success(self): self.tokens = min(self.max_tokens, self.tokens + self.token_ratio) def on_failure(self): self.tokens = max(0, self.tokens - 1) def allow_retry(self): return self.tokens > self.max_tokens / 2 def run(error_rate, requests=10_000, max_attempts=3, throttle=None, seed=1): """Сколько запросов в среднем уходит на одну операцию.""" random.seed(seed) sent = 0 for _ in range(requests): for attempt in range(max_attempts): sent += 1 if random.random() >= error_rate: if throttle: throttle.on_success() break if throttle: throttle.on_failure() if not throttle.allow_retry(): break return sent / requests print('ошибок без бюджета с бюджетом') for error_rate in (0.01, 0.05, 0.2, 1.0): plain = run(error_rate) limited = run(error_rate, throttle=RetryThrottle()) print(f'{error_rate:>6.0%} {plain:>11.2f} {limited:>10.2f}')
ошибок без бюджета с бюджетом 1% 1.01 1.01 5% 1.06 1.06 20% 1.25 1.01 100% 3.00 1.00
При 1–5% ошибок бюджет ничего не меняет: ретраи работают и спасают запросы. При 20% и при полном отказе он выключает повторы, и нагрузка на сервис остаётся на уровне обычной, а не утраивается. Это ровно то поведение, которое нужно.
Circuit breaker решает похожую задачу с другой стороны: он не только запрещает повторы, но и первые попытки, пока зависимость не оживёт. На практике используют оба механизма.
Собираем всё вместе на Python
Функция ниже объединяет классификацию ошибок, full jitter, общий дедлайн, Retry-After, бюджет и ключ идемпотентности. Она использует should_retry, parse_retry_after и RetryThrottle из примеров выше. Транспорт передаётся параметром, чтобы функцию можно было проверить без сети, а время — через clock и sleep, чтобы тест не ждал по-настоящему.
import random import time import uuid from dataclasses import dataclass, field @dataclass class Response: status: int headers: dict = field(default_factory=dict) class GiveUp(Exception): pass def request_with_retries(send, method, url, *, deadline=3.0, max_attempts=4, base=0.1, cap=2.0, throttle=None, sleep=time.sleep, clock=time.monotonic): """send(method, url, headers, timeout) -> Response или исключение ConnectionError (запрос не ушёл) / TimeoutError (ответа не дождались).""" start = clock() # Ключ один на все попытки: сервер узнает повтор headers = {'Idempotency-Key': str(uuid.uuid4())} last = None for attempt in range(max_attempts): left = deadline - (clock() - start) if left <= 0: break status, sent, retry_after = None, True, None try: resp = send(method, url, headers, timeout=left) if resp.status < 400: if throttle: throttle.on_success() return resp status = resp.status retry_after = parse_retry_after(resp.headers.get('Retry-After')) last = f'HTTP {status}' except ConnectionError as exc: sent, last = False, repr(exc) except TimeoutError as exc: last = repr(exc) if throttle: throttle.on_failure() if not should_retry(method, status, sent, has_idempotency_key=True): break if throttle and not throttle.allow_retry(): break if attempt == max_attempts - 1: break delay = random.uniform(0, min(cap, base * 2**attempt)) if retry_after is not None: delay = max(delay, retry_after) # сервер знает лучше if clock() - start + delay >= deadline: break # до следующей попытки не доживём sleep(delay) raise GiveUp(f'{method} {url}: сдались, последняя ошибка {last}')
Проверим на поддельном транспорте: сначала таймаут, потом 503 с Retry-After: 1, потом успех.
random.seed(5) script = [TimeoutError('read'), Response(503, {'Retry-After': '1'}), Response(201)] seen_keys = set() def fake_send(method, url, headers, timeout): seen_keys.add(headers['Idempotency-Key']) item = script.pop(0) print(f' {method} {url} timeout={timeout:.2f} -> {item!r}') if isinstance(item, Exception): raise item return item now = [0.0] fake_clock = lambda: now[0] fake_sleep = lambda s: now.__setitem__(0, now[0] + s) resp = request_with_retries(fake_send, 'POST', '/payments', clock=fake_clock, sleep=fake_sleep) print('итог:', resp.status, 'ключей:', len(seen_keys), f'прошло {now[0]:.2f} с') script = [Response(503, {'Retry-After': '5'})] try: request_with_retries(fake_send, 'GET', '/report', clock=fake_clock, sleep=fake_sleep) except GiveUp as exc: print(exc)
POST /payments timeout=3.00 -> TimeoutError('read') POST /payments timeout=2.94 -> Response(status=503, headers={'Retry-After': '1'}) POST /payments timeout=1.94 -> Response(status=201, headers={}) итог: 201 ключей: 1 прошло 1.06 с GET /report timeout=3.00 -> Response(status=503, headers={'Retry-After': '5'}) GET /report: сдались, последняя ошибка HTTP 503
Что здесь важно:
- Таймаут каждой попытки — остаток общего дедлайна, а не фиксированные 5 секунд.
- Все три попытки платежа ушли с одним ключом идемпотентности. Новый ключ на каждую попытку — частая ошибка, которая превращает ретрай в двойное списание.
- Во втором вызове сервер попросил подождать 5 секунд, а дедлайн — 3. Функция не спит впустую, а сразу сдаётся.
То же на JavaScript
В браузере и Node.js 18+ общий дедлайн удобно сделать через AbortSignal.timeout: один сигнал на все попытки обрывает и ожидание ответа, и следующую попытку.
const RETRYABLE = new Set([408, 429, 500, 502, 503, 504]) const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)) async function fetchWithRetry( url, options = {}, { attempts = 4, baseMs = 100, capMs = 2000, deadlineMs = 3000 } = {} ) { const deadline = AbortSignal.timeout(deadlineMs) // общий дедлайн на все попытки const headers = { 'Idempotency-Key': crypto.randomUUID(), ...options.headers } for (let attempt = 0; ; attempt++) { let res try { res = await fetch(url, { ...options, headers, signal: deadline }) if (!RETRYABLE.has(res.status)) return res // успех или 4xx — решать вызывающему } catch (err) { if (deadline.aborted) throw err // время вышло, повторять бессмысленно } if (attempt === attempts - 1) { if (res) return res throw new Error(`${url}: попытки кончились`) } // Здесь Retry-After только в секундах; формат даты см. пример на Python const retryAfter = Number(res?.headers.get('retry-after')) const backoff = Math.random() * Math.min(capMs, baseMs * 2 ** attempt) await sleep(retryAfter > 0 ? retryAfter * 1000 : backoff) } }
Проверка на локальном сервере, который два раза отвечает 503, а потом 200:
import http from 'node:http' let hits = 0 const keys = new Set() const server = http.createServer((req, res) => { hits++ keys.add(req.headers['idempotency-key']) res.writeHead(hits < 3 ? 503 : 200).end(hits < 3 ? 'busy' : 'ok') }) server.listen(0, async () => { const url = `http://127.0.0.1:${server.address().port}/` const res = await fetchWithRetry(url, { method: 'POST' }) console.log( res.status, await res.text(), `запросов: ${hits}, ключей: ${keys.size}` ) server.close() }) // 200 ok запросов: 3, ключей: 1
Ретраи в очередях
В асинхронной обработке те же идеи выглядят иначе. Консьюмер взял сообщение, обработка упала — сообщение возвращается в очередь и будет доставлено снова. Без задержки упавшее сообщение тут же придёт обратно, упадёт опять и будет крутиться в цикле, забирая ресурсы у остальных.
- Задержка повтора. В SQS это visibility timeout, в RabbitMQ — отдельная очередь с TTL, откуда сообщение возвращается в основную, в Kafka — отдельные retry-топики с нарастающей задержкой. Принцип тот же: экспонента и потолок.
- Лимит попыток и DLQ. После N неудачных доставок сообщение уходит в dead letter queue, где его разбирает человек или отдельный процесс. Иначе одно «ядовитое» сообщение блокирует партицию навсегда.
- Идемпотентный обработчик. Доставка at-least-once означает, что одно и то же сообщение может прийти дважды, даже если ничего не падало. Обработчик должен это переживать.
Подробнее про гарантии доставки — в статье про очереди сообщений.
Hedged requests: ретрай наоборот
Иногда задача не в ошибках, а в хвосте задержек: p50 — 20 мс, а p99 — 800 мс из-за одной медленной реплики. Hedged request («запрос-страховка») отправляет копию запроса на другую реплику, если первая не ответила, скажем, за время p95. Берётся тот ответ, что пришёл первым, второй отменяется.
Это тоже повтор, и к нему применимы те же правила: только идемпотентные операции и строгий лимит. Если страховать каждый запрос, нагрузка удвоится; при страховке после p95 — вырастет примерно на 5%, а хвост задержек заметно сократится. Идею подробно описали Джефф Дин и Луис Баррозо в статье «The Tail at Scale» (2013).
Типичные ошибки
- Ретраи без jitter. Клиенты синхронизируются и бьют залпами.
- Ретраят 4xx. 400, 404 и 422 не исправятся от повтора, а 401 нужно лечить обновлением токена, а не ожиданием.
- Неидемпотентный POST без ключа. Таймаут, повтор, два заказа.
- Новый ключ идемпотентности на каждую попытку. Защита есть на бумаге, но не работает.
- Нет общего дедлайна. Пятая попытка уходит, когда пользователь давно закрыл вкладку.
- Ретраи на каждом уровне. запросов на одно действие пользователя.
- Игнорируют
Retry-After. Сервер просит 30 секунд, клиент приходит через 100 мс и получает ещё один 429. - Ретраят ошибку circuit breaker'а. Локальный отказ «цепь разомкнута» повторять бессмысленно.
- Слишком маленький
base. Десять попыток за первые 100 мс — это не backoff, а перебор. - Нет метрик. Доля повторов — один из лучших ранних сигналов о проблеме в зависимости. Если её не видно, о шторме ретраев узнают от пользователей.
Как отвечать на собеседовании
Ретраи редко бывают отдельной задачей. Обычно они всплывают в системном дизайне на вопросе «а что если сервис X ответит ошибкой?». Сильный ответ укладывается в одну минуту:
- Классификация: ретраю только временные ошибки — таймауты, 5xx от прокси, 429. 4xx пробрасываю.
- Безопасность:
GETиPUTповторяю свободно,POST— только сIdempotency-Key, который генерируется один раз на операцию. - Backoff: экспонента с потолком и full jitter, 3–4 попытки, общий дедлайн, учёт
Retry-After. - Защита от шторма: ретраит один слой, есть бюджет повторов и circuit breaker.
- Наблюдаемость: метрика доли ретраев и алерт на её рост.
Частые уточняющие вопросы:
- Почему не повторять сразу? При перегрузке мгновенный повтор удваивает нагрузку именно тогда, когда сервису хуже всего.
- Зачем jitter, если есть экспонента? Экспонента разводит попытки одного клиента, а jitter — разных клиентов между собой.
- Где ретраить: на клиенте или на сервере? В одном месте. Обычно рядом с зависимостью, которая падает, а внешние слои только пробрасывают ошибку.
- Чем бюджет ретраев отличается от circuit breaker? Бюджет ограничивает только повторы и оставляет первые попытки. Breaker отсекает все вызовы, пока зависимость не поправится.
Общая схема разговора на системном дизайне — в статье про подходы к проектированию систем.