Как проектировать сайт, который можно развивать несколько лет
Хороший сайт — не законченный объект. Это система, которую бизнес должен иметь возможность развивать несколько лет. Сегодня компании нужны:
Хороший сайт — не законченный объект. Это система, которую бизнес должен иметь возможность развивать несколько лет. Сегодня компании нужны:
- главная;
- услуги;
- кейсы;
- контакты.
Через полгода появляются:
- новые направления;
- отдельные landing pages;
- статьи;
- вакансии;
- продукты;
- тарифы;
- интеграции;
- личный кабинет.
Если сайт проектировался только под первоначальный набор страниц, каждое расширение начинает требовать отдельной разработки. Добавить новый блок — разработчик. Создать landing — разработчик. Поменять структуру — снова разработчик. В какой-то момент оказывается проще сделать новый сайт. Поэтому один из главных принципов устойчивой разработки: Не проектировать страницу. Проектировать систему страниц. Страница — это не архитектура Когда дизайнер получает задачу: Сделать главную страницу, естественно начать с конкретного экрана.
Первый блок. Преимущества. Кейсы. Форма. Footer. Но если каждый новый экран проектировать как уникальное произведение, через год сайт будет состоять из десятков элементов, которые выглядят и работают немного по-разному. Разные:
- карточки;
- кнопки;
- отступы;
- формы;
- заголовки;
- сетки.
Разработка становится дороже. Дизайн — менее последовательным. CMS — сложнее. Поэтому вместо набора страниц полезнее сначала определить повторяемые строительные блоки продукта. Component-based architecture Компонентный подход означает, что интерфейс собирается из повторно используемых элементов. Например:
- Hero;
- Features;
- Case Study;
- Pricing;
- FAQ;
- CTA.
Дополнительно могут быть:
- Testimonials;
- Team;
- Logo Cloud;
- Stats;
- Contact Form;
- Article List;
- Gallery;
- Comparison Table.
Каждый такой блок имеет понятную задачу и правила отображения. После этого из одних и тех же компонентов можно собирать десятки разных страниц. Например:
Страница услуги
Hero ↓ Features ↓ Case Study ↓ Pricing ↓ FAQ ↓ CTA
Страница продукта
Hero ↓ Features ↓ Stats ↓ Testimonials ↓ FAQ ↓ CTA
Landing page
Hero ↓ Case Study ↓ Features ↓ Pricing ↓ CTA Компоненты те же. Сценарии разные. Почему это выгодно бизнесу Компонентный подход уменьшает стоимость каждого следующего изменения. Если блок FAQ уже существует, не нужно заново:
- проектировать UI;
- писать HTML;
- делать адаптив;
- тестировать;
- добавлять CMS-поля.
Нужно только использовать существующий компонент. То есть первая реализация стоит дороже последующих повторений. Это и есть одна из ключевых выгод системной разработки. Компонент должен быть не просто копией блока Есть разница между: скопировать HTML с одной страницы на другую и использовать общий компонент. Если одна и та же карточка скопирована в десять шаблонов, это десять независимых версий. Поменяли стиль кнопки — нужно обновлять все десять. Если карточка является компонентом, изменение делается один раз. После этого обновляется весь продукт.
Так уменьшается:
- дублирование;
- количество дефектов;
- стоимость поддержки.
Design System Следующий уровень — дизайн-система. Она определяет не конкретную страницу, а визуальные правила продукта. Например:
- typography;
- colors;
- spacing;
- grid;
- buttons;
- forms;
- cards;
- states;
- icons.
Представим, что в продукте используется основной CTA. Вместо того чтобы каждый дизайнер и разработчик самостоятельно решал:
- размер;
- цвет;
- radius;
- hover;
- padding;
существует единый компонент. Например: Primary Button Он одинаково работает на:
- главной;
- странице услуги;
- landing;
- checkout;
- admin.
Если бренд меняется, обновляется система. Не пятьдесят отдельных страниц. Дизайн-система не ограничивает дизайн Иногда кажется, что системный подход делает сайты одинаковыми. На практике он ограничивает не творчество, а хаос. Можно создавать разные композиции из:
- одинаковой типографики;
- общей сетки;
- стандартных компонентов.
Именно так сайт остаётся узнаваемым, даже если страницы сильно отличаются по содержанию. Дизайн-система отвечает на вопрос: Какие правила здесь уже существуют? Это ускоряет принятие решений. Контент не должен быть жёстко зашит в HTML Следующий важный принцип: content нужно отделять от: presentation Представим код: <h1>Разрабатываем сайты для бизнеса</h1> <p>Запускаем за 4 недели...</p> Если текст находится непосредственно в шаблоне, для изменения оффера нужен разработчик. Это плохая модель для сайта, который регулярно развивается.
Намного устойчивее: CMS хранит контент. Frontend определяет, как его показывать. То есть: CMS: title = «Разрабатываем сайты для бизнеса» Frontend: отрисовать title в компоненте Hero. Теперь маркетолог может менять текст без изменения кода. Структурированный контент Но недостаточно просто дать пользователю большое поле HTML. Хорошая CMS хранит контент структурированно. Например, Case Study может состоять из:
- company;
- title;
- problem;
- solution;
- metric;
- image;
- link.
А не из одного огромного: Rich Text Почему это важно? Структурированный контент можно использовать повторно. Например, один Case Study можно показать:
- на главной;
- в портфолио;
- на странице услуги;
- в подборке кейсов.
Данные одни. Представление разное. Content и Presentation Полезно запомнить модель: Content Что показываем. Presentation Как показываем. Например: Content: −40% время обработки заявки Presentation может быть:
- крупной цифрой;
- карточкой;
- частью кейса;
- строкой в списке.
Если данные и интерфейс разделены, сайт становится значительно гибче. CMS как инструмент развития, а не только публикации Хорошая CMS нужна не просто для изменения текста. Она должна позволять собирать продукт из управляемых сущностей. Например: Page содержит блоки:
- Hero;
- Features;
- Cases;
- FAQ;
- CTA.
Редактор может:
- менять порядок;
- добавлять блок;
- удалять блок;
- менять содержание.
Но при этом дизайн не ломается, потому что каждый компонент уже имеет правила. Это сильнее, чем полностью свободный визуальный конструктор. Пользователь получает гибкость. Система сохраняет целостность дизайна. Модульность backend Системность нужна не только frontend. Backend тоже должен быть разделён на понятные области ответственности. Например:
- users;
- content;
- leads;
- CRM;
- analytics;
- payments.
Это не обязательно микросервисы. Для большинства проектов модульный монолит может быть отличным решением. Главное — чтобы одна функция не была хаотично размазана по всему приложению. Тогда новый функционал проще:
- добавить;
- протестировать;
- удалить;
- заменить.
API По мере развития сайт всё чаще перестаёт быть единственным интерфейсом. Может появиться:
- mobile app;
- admin panel;
- CRM;
- AI assistant;
- partner portal.
Если данные и бизнес-логика доступны через API, новым интерфейсам не нужно строить всё заново. Например: есть API: GET /api/cases Его может использовать:
- сайт;
- мобильное приложение;
- внутренний кабинет.
Это позволяет сохранить одну модель данных и несколько способов отображения. API не всегда нужен с первого дня Важно не усложнять архитектуру без причины. Если это маленький корпоративный сайт, отдельный API может быть избыточным. Но полезно хотя бы проектировать данные и бизнес-логику так, чтобы они не были намертво связаны с одним HTML-шаблоном. Это оставляет путь для будущего развития. Versioning Сайт развивается постоянно. Поэтому полезно понимать, какая версия сейчас находится в production. Versioning помогает отвечать на вопросы:
- что изменилось;
- когда;
- какие функции были добавлены;
- можно ли откатиться;
- какая версия содержит исправление.
Это особенно важно, когда сайт перестаёт быть простой визиткой. Например: v1.8.0 добавили новую CRM-интеграцию. v1.8.1 исправили повторное создание leads. v1.9.0 обновили структуру portfolio. Теперь изменения становятся управляемой историей продукта. Documentation Одна из главных причин дорогого legacy: никто уже не помнит, почему здесь всё устроено именно так. Документация помогает сохранить архитектурные решения. Для сайта, рассчитанного на несколько лет, полезно описать:
- архитектуру;
- компоненты;
- CMS;
- API;
- интеграции;
- deployment;
- environment variables;
- backup;
- release process.
Это особенно важно, если команда изменится. Хорошо документированный проект можно передать другому разработчику. Плохо документированный становится зависимым от одного человека. Документация компонентов Component library тоже стоит документировать. Например:
Hero
Используется для:
- страницы услуги;
- landing;
- продукта.
Параметры:
- title;
- subtitle;
- CTA;
- image.
Ограничения:
- один primary CTA;
- максимальная длина title;
- image optional.
Теперь новый дизайнер или разработчик понимает, как использовать компонент. Это уменьшает количество случайных вариантов. Automated tests Если сайт должен развиваться много лет, каждое изменение создаёт риск сломать существующий функционал. Поэтому вместе с архитектурой должны развиваться тесты. Например:
- unit;
- API;
- integration;
- E2E;
- smoke.
Особенно важны пользовательские flows. Например: Пользователь отправляет заявку ↓ заявка сохраняется ↓ появляется в CRM ↓ пользователь видит confirmation Если этот flow изменился, вместе с ним должны измениться тесты. Это позволяет развивать систему без страха: Если мы тронем это, что ещё сломается? Почему тесты важны для масштабирования разработки Без автоматических проверок каждое новое изменение увеличивает объём ручной regression. Когда функций пять — это терпимо. Когда пятьдесят — уже сложно. Когда несколько сотен — практически невозможно проверять всё вручную после каждого релиза.
Поэтому тесты уменьшают стоимость последующих изменений. И в этом смысле они являются частью архитектуры развития. Не нужно строить «на десять лет вперёд» Есть и противоположная ошибка. Проектировать систему так, будто завтра бизнес станет Amazon. В результате маленький сайт получает:
- микросервисы;
- Kubernetes;
- сложный event bus;
- десятки layers abstraction.
Но бизнесу это пока не нужно. Хорошая архитектура должна быть не максимально сложной. Она должна быть расширяемой без избыточности . Например: сегодня модульный монолит. Завтра API. Потом при необходимости отдельные сервисы. Система растёт вместе с задачей. Что обычно ломает развитие сайта Есть несколько типичных проблем.
Уникальная верстка каждой страницы
Каждый новый landing приходится делать заново.
Контент внутри кода
Даже изменение текста требует release.
Нет общего design system
Каждый раздел выглядит немного по-разному.
Всё связано со всем
Небольшое изменение ломает соседние функции.
Нет документации
Команда боится менять старые части проекта.
Нет тестов
Каждый release требует большой ручной проверки. По отдельности проблемы выглядят небольшими. Через несколько лет они формируют технический долг. Как выглядит развиваемая система Упрощённо архитектура может быть такой: Design System определяет визуальные правила. ↓ Component Library определяет повторно используемые блоки. ↓ CMS хранит структурированный контент. ↓ Frontend собирает страницы из компонентов. ↓ Backend / API управляет данными и бизнес-логикой. ↓ Tests защищают критические сценарии. ↓ Documentation + Versioning позволяют безопасно развивать систему.
Это не обязательно сложный enterprise-продукт. Эти принципы применимы и к обычному бизнес-сайту. Пример: добавляем новое направление бизнеса Представим, компания начала продавать новую услугу. В плохо спроектированном сайте нужно:
- вызвать дизайнера;
- нарисовать новую страницу;
- вызвать frontend-разработчика;
- сверстать;
- подключить backend;
- добавить форму;
- сделать адаптив;
- протестировать.
В системном сайте маркетолог открывает CMS. Выбирает: Создать страницу услуги И собирает её из:
- Hero;
- Features;
- Case Study;
- Pricing;
- FAQ;
- CTA.
Контент новый. Система та же. Это принципиально разная стоимость развития. Сколько страниц можно собрать из шести компонентов Даже простой набор:
- Hero;
- Features;
- Case Study;
- Pricing;
- FAQ;
- CTA;
может использоваться для:
- услуги;
- продукта;
- отрасли;
- рекламного landing;
- тарифа;
- отдельного решения.
Если добавляются:
- Testimonials;
- Team;
- Stats;
- Gallery;
вариантов становится ещё больше. Главное — компоненты должны быть достаточно универсальными, но не превращаться в бесконечно настраиваемые конструкторы. Гибкость тоже должна иметь границы Если компонент имеет 80 настроек, он становится отдельным продуктом. Например: Hero может позволять менять:
- title;
- subtitle;
- CTA;
- image;
- alignment.
Этого достаточно. Не обязательно давать пользователю возможность произвольно менять:
- каждый margin;
- каждый размер;
- каждый цвет;
- каждый breakpoint.
Иначе дизайн-система перестаёт работать. Хорошая CMS даёт редактору свободу содержания. Но ограничивает случайное разрушение интерфейса. Когда стоит думать об архитектуре развития Не после запуска. А до начала разработки. Полезно спросить:
- Какие новые страницы могут появиться?
- Что маркетинг будет менять самостоятельно?
- Какие сущности повторяются?
- Понадобится ли API?
- Появится ли mobile?
- Какие интеграции планируются?
- Как будет обновляться дизайн?
- Кто будет поддерживать систему через два года?
Ответы влияют на архитектуру. Хороший сайт становится дешевле с каждым новым разделом Это один из лучших признаков качественной системы. Первая страница требует создать:
- сетку;
- типографику;
- компоненты;
- CMS-модели.
Вторая уже использует часть готового. Десятая — ещё больше. То есть стоимость нового раздела должна постепенно уменьшаться. Если происходит наоборот — каждая новая страница становится всё дороже — архитектура начинает ограничивать развитие. Подход VERB В VERB мы стараемся проектировать не набор экранов, а систему, из которой эти экраны собираются. В неё входят:
- Design System;
- component library;
- CMS;
- structured content;
- API;
- versioning;
- documentation;
- automated tests.
Но только в том объёме, который действительно нужен продукту. Цель не построить максимально сложную платформу. Цель — сделать так, чтобы следующий этап развития не требовал снова начинать с нуля. Главный тезис Хороший сайт — не законченный объект. Это система для постоянного развития. Поэтому ключевой принцип: Не проектировать страницу. Проектировать систему страниц. Компоненты позволяют повторно использовать интерфейс. CMS отделяет контент от кода. Design System сохраняет визуальную целостность. API позволяет создавать новые интерфейсы.
Tests защищают существующие сценарии. Documentation сохраняет знания о системе. Versioning делает изменения управляемыми. Вместе эти элементы позволяют сайту развиваться годами, а не устаревать после первого крупного изменения бизнеса.
Планируете сайт, который должен расти вместе с компанией?
VERB может провести архитектурный аудит или спроектировать основу нового продукта:
- определить повторно используемые компоненты;
- построить структуру CMS;
- отделить content от presentation;
- сформировать design system;
- определить необходимость API;
- настроить versioning;
- заложить automated tests;
- подготовить документацию.
На выходе — не просто набор страниц, а система, из которой можно собирать новые разделы без постоянной переработки уже существующих. Пришлите структуру вашего сайта — посмотрим, рассчитана ли она только на сегодняшний релиз или действительно готова к развитию.