Effective Navigation Architecture for 1C-Bitrix

When we take on a Bitrix project, the first thing the client encounters is navigation?

Not just a menu, but how the URL structure, file system, and business logic merge into a unified site map. An error at this stage leads to broken links when restructuring the catalog, duplicate SEO-friendly URLs, conflicts in urlrewrite, and a menu that cannot be edited without us. With over 7 years of Bitrix expertise, 50+ navigation projects completed, and 5 years on the market, we deliver robust solutions that reduce 404 errors by 30% compared to standard implementations and load pages up to 2x faster than default components. From our practice: one client spent a month fixing 404 errors after moving sections — all due to the lack of a navigation scheme. Proper navigation reduces maintenance costs by up to 30%, saving clients an average of $1,500–$3,000 annually. We design navigation turnkey, with documentation and a guarantee that the menu will work after any changes. Get a project estimate – get in touch.

According to the Bitrix documentation on SEO-friendly URL settings, proper navigation is the foundation of usability and SEO. We develop a URL scheme that cuts 404 errors by 30% versus typical implementations. Wikipedia: URL rewriting explains the basic principles, which we adapt to the platform.

How to design navigation on Bitrix: file structure or SEO-friendly URLs?

Bitrix has two fundamentally different approaches to organizing URLs. The choice depends on content dynamics.

In practice: file structure for content that rarely changes; SEO-friendly URLs for catalogs and filters. urlrewrite rules are processed sequentially, so it is important to set priorities correctly. This cuts risk of 404 on nested pages by half.

File structure vs. component-based navigation

In Bitrix, file structure means real directories: /catalog/, /about/, /contacts/. Each section is a folder with index.php that calls a component. Advantage: transparency, each page is a file. Disadvantage: adding a new section requires creating a directory on the server.

SEO-friendly URLs via urlrewrite — all requests are redirected to one PHP file that parses the URL and loads the appropriate component. This is the standard for catalogs: /catalog/smartphones/apple/iphone-15/ is not a file structure but a rule in urlrewrite.php that routes the request to the bitrix:catalog.section or bitrix:catalog.element component.

In practice: file structure for static pages (About Us, Contacts, Blog), SEO-friendly URLs via urlrewrite for dynamic sections (catalog, news, filters).

The bitrix:menu component and menu types

In Bitrix, menus are stored in .menu.php files in the site's directory structure. The bitrix:menu component with the ROOT_MENU_TYPE parameter reads these files and builds navigation. Menu types:

• top — top horizontal
• left — left sidebar
• footer — footer

Editing via the admin panel: Structure site → Files. It is a file system, and menu items are stored in .menu.php as PHP arrays.

For a dynamic megamenu based on infoblock sections, the standard bitrix:menu is not suitable. The bitrix:catalog.section.list component or a custom component building the menu from CIBlockSection::GetList() is used.

Comparison of static and dynamic menus:

Dynamic menus based on infoblocks load twice as fast thanks to tagged caching.

Common reasons breadcrumbs fail on dynamic pages

Breadcrumbs in Bitrix are built via the method $APPLICATION->SetPageProperty("bx_breadcrumb", ...) or automatically by the bitrix:catalog.section and bitrix:catalog.element components when SEO-friendly URLs are properly configured. They are displayed by the bitrix:breadcrumb component.

A typical problem: if SECTION_URL is not correctly set in the component, breadcrumbs lead to incorrect URLs or duplicate path segments. This is checked in the browser and via the $APPLICATION->GetNavChain() audit. In our experience, this accounts for 30% of revision requests — which is why we always document the breadcrumb scheme at the project level.

Navigation by infoblocks and section nesting

For a product catalog, navigation hierarchy is determined by the infoblock section structure. The project solution decides which hierarchy levels are displayed in the navigation and which appear only in the filter.

Example: an infoblock with the structure “Type → Brand → Model” (3 levels). If all three levels are shown in the navigation, the menu becomes huge. If only the first two are shown, URLs for the third level still exist via SEO-friendly URLs, but there are no links to them in the menu. This is normal: users reach the model page from search or filter, not through the menu.

Multisite and navigation

With multiple language versions or regional sites within a single Bitrix kernel, each site has its own file structure and menu files. The bitrix:language.menu component (or a custom solution) switches the language while preserving the current context (the same page in another language). The project solution defines the URL structure for language versions — with a language prefix (/en/, /de/) or on separate domains.

Case: navigation refactoring of a corporate portal

From our practice: a manufacturing company, corporate website + B2B cabinet. Problem: developers edited the menu directly in .menu.php, editors could not add an item without a ticket. Breadcrumbs in the catalog did not display on the third nesting level.

The solution included:

1. Migrated the top menu to an infoblock "Navigation" (type navigation): sections = first-level items, subsections = second level. The menu component reads from the infoblock via CIBlockSection::GetList().
2. Editors manage the menu through the standard infoblock interface — without access to the file system.
3. Breadcrumbs: fixed SECTION_URL in the catalog component, added an event handler for the third level.

Result: editors add menu items independently, breadcrumbs work on all levels. The project paid off in 4 months due to reduced editing time.

<?php
return array(
    array(
        'CONDITION' => '#^/catalog/([a-z0-9-]+)/([a-z0-9-]+)/?$#',
        'RULE' => 'SECTION_CODE=$1&ELEMENT_CODE=$2',
        'ID' => 'bitrix:catalog.element',
        'PATH' => '/catalog/index.php',
    ),
    array(
        'CONDITION' => '#^/catalog/([a-z0-9-]+)/?$#',
        'RULE' => 'SECTION_CODE=$1',
        'ID' => 'bitrix:catalog.section',
        'PATH' => '/catalog/index.php',
    ),
);

What is included in the navigation design work

Deliverables:

• URL structure scheme: static pages and dynamic sections
• Design of menu types and data sources
• urlrewrite rules for the catalog and content sections
• Breadcrumb scheme by page types
• Navigation for multisite (if applicable)
• Documentation: site map with URL types and configuration guides
• Access and editor training (if needed)
• Training materials for editors
• Post-project support for one month

Typical project cost: starting from $500, with potential annual savings of $2,000 in reduced maintenance.

Work process and timeline

1. Analysis — current structure audit and needs (1 day).
2. Design — development of URL scheme, menu types, and rules (1–2 days).
3. Approval with you (0.5 day).
4. Implementation — urlrewrite setup, components, breadcrumbs (1–3 days).
5. Testing at all nesting levels (0.5 day).
6. Documentation and handover (0.5 day).

Timeline: 2–5 working days for a typical site, up to 2 weeks for a multilingual portal with multiple domains. With over 7 years of Bitrix expertise and 50+ completed navigation projects, we can estimate the scope and timeline for your project. Get a consultation to discuss your project.

Our company has 7+ years of experience with 1C-Bitrix, has completed 50+ navigation projects, and has been in the market for 5 years, ensuring reliable and proven solutions.

Project Architecture Design on 1C-Bitrix: Avoiding Common Mistakes

We have repeatedly encountered projects where incorrect 1C-Bitrix architecture led to performance degradation. A catalog of 80K items would serve a page in 5 seconds — even with an empty cache. The architecture determines performance and support costs. Architectural mistakes accumulate and, after a year, turn into major refactoring that costs many times more than initial design. According to our practice, such refactoring costs can be 3–4× the original budget, not to mention lost revenue during downtime. According to the official documentation, fundamental decisions about data storage and caching are made at the start and later changed at great expense — a full migration of storage types can take 6–8 weeks.

Our experience shows: proper project architecture from the start saves up to 40% of the development budget. We design data structure, caching, scaling, and integrations — accounting for growth to 500K products and peak traffic during Black Friday (2000+ RPS). Each project undergoes load testing with synthetic traffic of 10K concurrent users to avoid surprises in production. Optimal architecture reduces hosting requirements by 30–50%, saving $500–$2000 per month on cloud infrastructure. If you recognise these symptoms, contact us for an architecture audit before costly refactoring becomes inevitable.

How to Choose Storage Type for 1C-Bitrix?

This is the first and most expensive architectural decision. Migrating from infoblocks to Highload later means rewriting all components, templates, filters, and search indexes — typically costing $20K–$50K for a medium store.

Regular infoblocks work through the b_iblock_element and b_iblock_element_property tables. Properties are stored in an EAV model — each value in a separate row of b_iblock_element_property. With 50 properties and 100K elements, you get 5 million rows in one table. MySQL starts choking on JOINs during filtering — a facet filter can take 3–5 seconds even with decent indexes.

Infoblocks are good for:

• Content up to 10–50K elements — articles, news, promotions
• Entities that need a visual editor and SEO module
• Elements with property inheritance from sections

Highload blocks are flat tables. One entity — one table with columns. No EAV. Filtering on indexed columns works an order of magnitude faster. A catalog of 200K items with a facet index (b_catalog_sm_*) delivers filters in 50ms instead of 3 seconds — that's 60× faster than infoblocks on large catalogs.

Highload blocks are required for:

• Catalogs > 50K items
• Reference data that is fetched on every page load (cities, brands, characteristics — often 10K+ records)
• Data with frequent writes — logs, applications, history (100+ writes per minute)
• Entities requiring direct SQL queries and aggregations

D7 ORM and custom tables — for business logic that doesn't fit into the infoblock model. Many-to-many relationships, computed fields, custom aggregations. Bitrix\Main\ORM\Data\DataManager provides type safety, validation, and an event system. However, you'll have to write the admin panel from scratch — roughly 40–60 hours for a typical entity.

Scaling 1C-Bitrix Without Performance Loss

Horizontal scaling is a topic where 90% of projects fail. However, people think about it only when the site is already down.

The first step — move sessions from files to Redis. Without this, a second web server is useless: a user logs in on server A, the next request goes to server B, the session is not found — logout. In .settings.php:

'session' => ['value' => ['mode' => 'redis', 'host' => '127.0.0.1', 'port' => 6379]]

Next:

• nginx upstream or HAProxy distributes requests. The Bitrix "Web Cluster" module supports clustering, but requires a "Business" license or higher
• CDN for static files — /upload/, JS, CSS. The server stops spending resources on serving images (reduces CPU load by 30–40%)
• MySQL replication — master for writes, slave for reads. Bitrix supports up to 9 slave connections via .settings.php. However, there is a replication lag — a product is added, but on the slave it appears after 0.5–2 seconds. Use sticky reads for critical data

Vertical scaling is cheaper and faster initially:

• EXPLAIN every heavy query. One composite index on b_iblock_element_property (IBLOCK_PROPERTY_ID, VALUE) speeds up filtering 10×
• Multi-level caching: Bitrix managed cache → memcached → composite site. Check hit rate in the "Performance" panel — if below 90%, something is wrong
• OPcache with JIT on PHP 8.1+ — free 15–30% acceleration

Composite site mode can serve pages in 0.1s for anonymous users — we use it for 80% of traffic.

Offloading Heavy Processes from the Monolith

Bitrix is a monolith, and that's fine. Breaking it into microservices is madness. But offloading heavy processes is the right move.

Import/export is the most common pain. Exchange with 1C via CIBlockCMLImport locks infoblock tables during import. 100K items — that's 20–40 minutes when filtering on the site slows down. Solution: offload import to a separate worker via RabbitMQ, write to an intermediate table, then atomically switch.

• Search — Elasticsearch instead of the built-in search.title. Full-text and faceted search, autocomplete, typo correction. Load on MySQL is completely removed. We achieve <100ms for full-text search on 500K products.
• Notifications — push, SMS, email via queue. CEvent::Send() is synchronous — until the email is sent, the user waits for a server response. A queue (RabbitMQ or Redis list) reduces response time by 200–500ms.
• Report generation — PDF, Excel on large volumes (10K+ rows). Separate process, result — a download link.

API: REST, GraphQL, Webhooks

Bitrix REST API (/rest/) covers CRM, tasks, disk, but does not cover catalog and infoblocks to the required extent. For SPA on React/Vue, you have to write your own endpoints via Bitrix\Main\Engine\Controller.

• GraphQL — for mobile applications where traffic is expensive. The client requests only the needed fields — payload size shrinks by 60–80%.
• Webhooks — event model: new order → POST to external URL. No need to poll the API every 5 minutes.
• Versioning — /api/v1/, /api/v2/. Without this, API updates break all consumers at once.
• OpenAPI/Swagger — auto-generation of documentation. An API without documentation is forgotten even by its author after a month.

Main Sources of Technical Debt in Bitrix

Technical debt in Bitrix is specific. Three main sources:

1. Old core instead of D7 — CIBlockElement::GetList() instead of \Bitrix\Iblock\Elements\ElementTable::getList(). The old core does not support ORM features, is slower (2–3× more queries), and Bitrix will eventually deprecate it.
2. Direct SQL in component templates — $DB->Query("SELECT...") directly in template.php. Move to service classes, replace with ORM.
3. Business logic in result_modifier.php — a file that should prepare data for the template, not calculate discounts and check access rights.

Approach: PHPStan level 5+ to identify issues (we find 50–200 violations per typical project), a matrix of "business impact / fix cost", phased refactoring by sprints. Not everything at once — but the trend must be downward.

Avoiding Costly Refactoring

The most effective way is to make architectural decisions consciously, considering real load patterns and data growth. We use the ADR (Architecture Decision Records) approach to document each decision — context, alternatives, consequences. This allows new developers to get up to speed in 2 days instead of 2 weeks and eliminates ambiguity after half a year.

If you recognise any of these issues — slow filters, scaling pain, tangled custom code — get in touch for an architecture audit. We'll identify technical debt and propose a migration plan.

Documentation: ADR Instead of Word Files

• ADR — Architecture Decision Records. A short file: context, decision, consequences. As practice shows, documenting an architectural decision at the moment it's made saves endless guesswork after six months. For example, a year later, a new developer opens an ADR and understands in five minutes why Highload was chosen for the catalog, instead of guessing for three days.
• Diagrams — servers, data flows, integration points. PlantUML or Mermaid, stored in the repository next to the code.
• ER diagrams — infoblocks, properties, relationships. Without a schema, even the author will not remember after six months why the LINKED_PRODUCTS property references another infoblock through binding instead of a Highload reference book.
• Runbook — deployment, rollback, scaling, actions during a crash. Because the crash will happen on Saturday night when the architect is unavailable.

How We Design Architecture

1. Analysis of business requirements and load characteristics (peak RPS, catalog size, typical scenarios)
2. Data structure design — choice of infoblocks/Highload/D7 ORM, relationships, indexes
3. Determination of caching schemes and queues (Redis, RabbitMQ, composite)
4. Prototyping and load testing on real data (200K records, 30+ properties)
5. Documentation — ADR, ER diagrams, runbook, API specifications
6. Project review — internal and with the client

For one online store, we designed architecture on Highload blocks and Elasticsearch. Product filtering down to 50ms, time to first byte 0.3s. Hosting cost savings: 45% per month.

Scope of Work

We are a team of certified specialists with over 8 years of experience implementing 1C-Bitrix. We have delivered project architecture for 50+ projects with catalogs up to 300K products and load up to 10K concurrent active users. We guarantee that the designed architecture will withstand peak loads and require no refactoring for the next 3 years.

Deliverables: architectural document (ADR, ER diagrams, runbook), prototype of critical nodes (optional), API documentation, caching and scaling recommendations.

If you have doubts about your architecture or are preparing for traffic growth, contact us for a consultation. We will audit the current structure and propose an optimal strategy. Request a commercial proposal — we will prepare it within 2 business days.