Website Development for Businesses

Big Fish is a web development agency building corporate websites, e-commerce stores, product catalogs, landing pages, portals, and web applications since 2011. We design information architecture and user flows, create UX/UI design, develop frontend and backend systems, integrate CMS platforms, CRM, 1C, and other external systems, perform technical SEO setup, test the project, and deploy it to production.

Our technology stack includes HTML, CSS, JavaScript, React, Vue.js, Next.js, PHP, Laravel, Python, Django, WordPress, MODX, 1C-Bitrix, MySQL, MariaDB, PostgreSQL, REST API, WebGL, and other technologies. The stack for each project is determined by its functionality, data architecture, performance requirements, SEO, security, integrations, and future technical support.

Turnkey website development covers the entire production cycle within one team. At the beginning of the project, we define the website structure, functional modules, user roles, traffic sources, CMS, external integrations, and infrastructure requirements. We then create the design in Figma, develop the frontend and backend, configure content management, perform functional and technical testing, connect analytics, and deploy the website to the production server.

Development starts from RUB 190,000, with timelines starting from 20 business days. Corporate websites start from RUB 290,000, product catalog websites from RUB 390,000, and e-commerce websites from RUB 490,000. Portals, customer accounts, and web applications are estimated after the architecture and functionality have been designed.

We design the website structure by defining all types of information that will exist within the project: services, products, categories, industries, projects, case studies, employees, publications, documents, locations, vacancies, and other entities. Each entity receives its own page template and relationships with other sections.

At the same time, we create the sitemap, navigation, section hierarchy, URL structure, and internal linking architecture. A service page is connected to relevant case studies, industry pages, and expert articles. A product page is connected to its category, specifications, documentation, and related products. Case studies are integrated into commercial sections to demonstrate relevant experience directly alongside service descriptions.

SEO semantics influence the architecture before the design stage begins. Separate groups of search queries receive dedicated landing pages. A large corporate website may include services, industries, products, regional pages, and an editorial section. This architecture allows the website to grow to hundreds or thousands of URLs without changing its fundamental structure.

For large catalogs and portals, we design the data taxonomy separately. Categories, subcategories, attributes, filters, and relationships between entities are defined before backend development begins. This is especially important for projects where the catalog is synchronized with 1C, ERP, or PIM systems and contains thousands of products.

We develop corporate websites for companies with multiple business divisions, extensive service portfolios, complex products, or substantial expert content. The architecture combines information about the company, products, services, industries, projects, case studies, employees, vacancies, documents, news, and publications.

Each content type receives its own data model in the CMS. Company employees can manage services, projects, articles, and other content through the administration panel without editing HTML. Relationships between entities automatically display relevant case studies on service pages, industry-specific materials in expert sections, and related publications within articles.

Corporate websites can be integrated with CRM systems, analytics platforms, telephony, email marketing, 1C, and internal corporate services. A website inquiry can be transferred to the CRM together with the user's contact details, originating page, selected service, UTM parameters, and traffic source.

The search architecture of a corporate website is based on the company's actual business structure. Core services receive dedicated URLs, industry expertise is presented on separate pages, case studies demonstrate experience, and articles expand semantic coverage while creating additional internal links.

Corporate website development starts from RUB 290,000. Development time starts from 30 business days.

We develop catalog websites for manufacturers, distributors, equipment suppliers, material suppliers, and companies with extensive product ranges. The catalog may include categories, subcategories, product pages, specifications, filters, search, documents, images, related products, and request-for-quotation forms.

During architecture design, we define the data model and filtering rules. Attributes are divided into global and category-specific parameters, value dictionaries are created, and indexable page sets are defined in advance. This reduces technical duplicates and creates a foundation for SEO promotion of categories and product groups.

The catalog can be connected to 1C, ERP, PIM, CRM, or an internal database. Automated synchronization transfers product names, SKUs, specifications, prices, stock levels, images, and documents to the website. Reverse synchronization sends inquiries, orders, and products selected by users back to the corporate system.

For projects containing large numbers of products, we separately optimize database queries, filters, caching, and page generation. Catalog performance directly depends on the data architecture and the number of queries required to generate each page.

Product catalog website development starts from RUB 390,000. Development time starts from 40 business days.

We develop online stores with catalogs, search, filters, product variations, shopping carts, checkout and payment, delivery options, customer accounts, order history, and integrations with accounting and inventory systems.

The customer journey is designed from product discovery to payment confirmation. Product pages contain the required specifications, variations, images, documents, prices, availability, and related products. The cart retains selected products, the checkout collects only the required information, and the mobile version preserves the complete purchasing flow without removing essential functionality.

E-commerce websites can be connected to 1C, CRM, ERP, warehouse systems, payment gateways, and delivery services. Synchronization keeps catalogs, prices, and inventory up to date, transfers orders to the accounting system, and returns order processing statuses to the website.

For WordPress-based e-commerce projects, we use WooCommerce. Projects requiring custom order models, specialized user roles, or complex server-side logic are developed using a dedicated frontend/backend stack.

E-commerce SEO includes category pages, product pages, canonical URLs, filter indexing rules, Schema.org Product markup, XML Sitemap, correct pagination, and internal linking between categories, products, and informational content.

E-commerce website development starts from RUB 490,000. Development time starts from 45 business days.

Discuss Your Project

We create landing pages for individual services, products, advertising campaigns, events, and new business launches. The page architecture is built around a single primary offer and a structured user journey.

Before starting the design, we define page sections, key arguments, case studies, forms, and conversion points. After prototyping, we create custom UX/UI design in Figma, adaptive frontend development, forms, analytics, and technical SEO configuration.

A landing page also receives a complete technical foundation: semantic HTML markup, responsive images, optimized fonts, Core Web Vitals optimization, event analytics, and secure form processing.

Landing page development starts from RUB 120,000. Development time starts from 15 business days.

We develop web systems with authentication, customer accounts, user roles, private sections, document workflows, calculators, statuses, notifications, and custom business logic.

The architecture of these projects is divided into frontend, backend, database, and integration layers. The backend manages users, permissions, data, and business processes. The frontend displays interface states and communicates with the server through APIs. The database stores structured information, while the integration layer connects the application to 1C, CRM, ERP, and other corporate systems.

For server-side development, we use Laravel, Django, and other backend technologies. Interfaces with large numbers of dynamic states are developed with React, Vue.js, Next.js. Structured data is stored in PostgreSQL, MySQL, MariaDB, and other suitable database management systems.

For systems with user accounts, we separately design authentication, role-based access control, server-side permission validation, session management, logging, and API protection.

Interfaces are designed in Figma. The process begins with prototypes of key pages and user journeys. Prototypes define content, section order, navigation, forms, interface states, and primary user actions.

After the architecture is approved, we create the visual concept, typography, grid, UI components, and responsive layouts. Large websites receive a component library containing buttons, form fields, cards, menus, filters, tables, modal windows, navigation elements, and other reusable interface components.

The component system accelerates the development of new sections after launch. New screens can be assembled from existing components while maintaining consistent typography, spacing, states, and responsive behavior.

The visual layer is connected to frontend development during the design stage. Animations, sticky elements, expandable sections, complex transitions, and interactive components receive clearly defined behavior before programming begins.

Big Fish has a dedicated website design content cluster, so this development page focuses on how design connects with architecture, technology, performance, and user journeys.

For presentation-focused and award-oriented projects, we use 3D, WebGL, interactive graphics, video, and advanced frontend animation. WebGL runs directly in the browser and uses device hardware acceleration to render interactive 2D and 3D graphics.

We use WebGL for product models, interactive scenes, background effects, object visualization, and unconventional interface transitions. A WebGL scene is integrated into the standard HTML structure of the page and can interact with scrolling, cursor movement, interface events, and other frontend components.

For 3D content, we separately control geometry complexity, texture resolution, model size, the number of light sources, and JavaScript payload. Mobile devices receive dedicated quality and performance settings. Heavy assets load after the main content or only when the user approaches the interactive scene.

Visual impact is evaluated together with performance. A WebGL scene is integrated into the final project after testing loading speed, frame rate, and mobile behavior.

Frontend development covers the entire interface running in the browser: grids, typography, responsive behavior, navigation, forms, animations, filters, interactive components, and responses to user actions.

For corporate and content-driven projects, we use HTML, CSS, and JavaScript. Applications and interfaces with numerous dynamic components are developed using React, Vue.js, Next.js, and other technologies of the appropriate class.

During development, we control the volume of JavaScript, CSS, and third-party libraries. Images, fonts, video, analytics, and external widgets receive separate loading strategies. Above-the-fold resources receive high priority, while secondary components load later.

Responsive development covers desktop, laptop, tablet, and smartphone layouts. Mobile navigation, tables, catalogs, filters, forms, and complex interactive elements are designed separately.

Frontend architecture also determines how accessible content is to search engine crawlers. For client-rendered projects, we define HTML generation, server-side rendering, and indexing rules in advance.

Backend development handles business logic, data processing, CMS functionality, authentication, integrations, APIs, forms, and server-side operations.

We use PHP, Laravel, Python, Django, and other backend technologies. Structured data is stored in MySQL, MariaDB, PostgreSQL. Database architecture is built around project entities and the relationships between them.

For a corporate website, the backend manages content, forms, catalogs, and integrations. For a web application, the server side additionally handles user roles, statuses, calculations, documents, notifications, and other business processes.

APIs are designed with permission separation and server-side validation of incoming data. Errors are logged, while external integrations include timeout handling and processing of invalid responses.

Get a Project Estimate

For corporate websites, we use WordPress, 1C-Bitrix, MODX, and other content management systems. The CMS is selected after defining the data structure, website functionality, integrations, SEO requirements, and the way employees will work with content.

WordPress is used for corporate and content-driven projects requiring flexible page structures, custom content types, and advanced SEO configuration. 1C-Bitrix is used for projects integrated into the corresponding Russian corporate infrastructure. MODX is used for projects requiring custom template architecture and structured content management.

The administration interface is configured around the project's actual data model. Employees work with clearly defined fields such as title, description, images, documents, specifications, price, SEO parameters, and relationships with other content.

A case study entry can contain separate fields for client, industry, project cost, technologies, gallery, and related services. A product page contains specifications, images, documents, variants, and related products. Service pages are managed through their own dedicated fields and relationships.

User permissions are separated by role. Editors manage publications and page content, while administrators receive system-level permissions. Design components and technical settings remain separated from routine content editing.

We integrate corporate websites with 1C, CRM, ERP, PIM, telephony, payment systems, email marketing platforms, delivery services, analytics, and internal corporate systems.

For integrations, we use REST APIs, webhooks, and custom data exchange modules. Data formats, synchronization direction, frequency, and error-processing rules are defined before development begins.

The website can receive products, prices, stock levels, specifications, and other information from 1C or ERP. Orders are transferred back to the accounting system. CRM receives inquiries together with customer contact details, UTM parameters, originating page, and selected service or product.

Webhooks are used for event-driven data exchange. A change in order status, successful payment, or creation of a new inquiry can trigger immediate data transfer without waiting for the next full synchronization cycle.

For complex integrations, we create operation logs containing the synchronization time, transmitted data, received response, and errors. This architecture significantly simplifies troubleshooting after launch.

SEO begins with the website architecture. Search demand analysis defines the set of commercial and informational landing pages before visual design begins.

Services, business areas, product categories, industries, cities, and thematic content receive dedicated URLs. Metadata, indexing, and internal linking rules are defined for each page type.

At the technical level, we configure Title, Description, H1–H6, canonical, robots meta, XML Sitemap, robots.txt, ALT attributes, HTTP status codes, 301 redirects, 404 pages, and Schema.org. Google separately documents crawling controls, canonical URLs, robots directives, and sitemaps as technical mechanisms for managing website indexing.

The URL structure is defined before the website is published. Each page address reflects its position within the architecture and remains stable after launch.

Canonical tags are used for pages that can be accessed through multiple technical URL variations. Removed or relocated pages receive 301 redirects. 404 errors are monitored after launch through webmaster platforms and server logs.

Catalogs and e-commerce websites require particular attention. Filtering, sorting, URL parameters, pagination, search, and utility pages can generate large numbers of technical URLs. Crawling and indexing rules are defined separately for each type.

Robots.txt is used to manage crawler access to URLs, while noindex controls whether a page can be indexed. Google specifically notes that robots.txt controls crawler access and is not a mechanism for removing a page from the index.

The XML Sitemap contains the project's main indexable URLs. On large websites, sitemaps are divided by content type: services, products, categories, articles, and other entities. A sitemap helps search engines discover pages, especially on large and complex websites, although inclusion in a sitemap does not guarantee indexing.

Internal linking is built directly into the website architecture. A service page links to related case studies and expert content, an article links to a commercial section, and a category connects to products and thematic pages. Priority pages receive more relevant internal links from related sections.

We use Schema.org structured data to describe organizations, breadcrumbs, articles, products, and other entities. Corporate websites can use Organization and BreadcrumbList; publications can use Article; e-commerce projects can use Product and Offer. The exact markup depends on the content of each page.

Structured data helps search engines interpret page entities and content more accurately. Google uses structured data to understand content and generate supported search result features.

For WordPress projects, we use Yoast SEO, Rank Math, AIOSEO, SEOPress, and custom development. These plugins manage metadata, canonical URLs, XML Sitemap, robots directives, and Schema markup.

SEO plugin functionality is supplemented with custom CMS and template configuration. We programmatically generate metadata for custom page types, adjust Schema markup, configure redirects, and define indexing rules for non-standard sections.

After launch, we connect Yandex Webmaster and Google Search Console to monitor indexing, search queries, technical errors, and URL status.

Discuss Development

Performance is controlled across the frontend, backend, and server infrastructure. We optimize images, fonts, CSS, JavaScript, video, analytics, and third-party widgets.

Images are prepared in modern formats and dimensions corresponding to their actual display area. Content below the fold uses lazy loading. Critical above-the-fold images receive high loading priority.

JavaScript is split according to page functionality. Users do not download code for components that are absent from the current page. Heavy libraries are loaded only in sections where they are actually required.

On the server side, we optimize database queries, caching, and external API requests. Pages with high request frequency receive an appropriate level of server-side caching.

During performance testing, we monitor Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift. Google's thresholds for a good user experience are LCP of 2.5 seconds or less, INP of 200 ms or less, and CLS of 0.1 or less, measured at the 75th percentile of real visits.

LCP measures the time required for the largest visible element to appear. On corporate websites, this is often an image or large visual element in the first viewport. Optimization covers resource size, loading order, server response time, and the way the image is delivered.

INP measures interface responsiveness. Large amounts of JavaScript, heavy event handlers, and complex calculations increase the delay between a user action and an interface update. CLS measures unexpected layout shifts. Dimensions for images, embedded elements, and dynamic components are defined in advance so that page content remains stable during loading.

Mobile performance is analyzed separately. Smartphones using mobile networks impose significantly stricter CPU, memory, and bandwidth constraints than a developer workstation.

Security is designed across the application, server, user, API, and infrastructure layers. We use HTTPS/TLS, server-side data validation, access control, software component updates, backups, and monitoring.

OWASP identifies access control, security misconfiguration, and other systemic issues among the key risks for web applications, so protection is implemented through multiple technical measures across different layers of the project.

Administrative and customer accounts use a role-based permission system. Each user receives access only to the operations and data required for their role.

Administrative accounts are protected with strong unique passwords and two-factor authentication — 2FA for projects with increased security requirements. The number of users with maximum permissions is restricted.

The backend verifies permissions for every protected operation independently of the frontend state. Hiding a button in the interface does not provide authorization — permission is always validated on the server. Customer account systems also receive dedicated session and token management.

Data submitted through forms and APIs undergoes server-side validation. Type, length, and permitted values are checked before a business operation is executed or information is written to the database.

Client-side validation helps users complete forms correctly, while server-side validation protects data integrity and security. OWASP specifically recommends server-side input validation as a fundamental application security practice.

File uploads receive restrictions on file types, size, and storage location. Public forms include mechanisms protecting them against large-scale automated requests.

For public services, we use several layers of network and application traffic protection. A WAF filters suspicious HTTP requests, a firewall restricts network access, and rate limiting controls the frequency of requests to individual endpoints. Rate limiting is particularly important for authentication, password recovery, forms, APIs, and other functions vulnerable to automated requests.

Our development practices take into account recommendations from OWASP — the Open Worldwide Application Security Project, an international initiative that develops standards and practical guidance for web application security. We review access control, server and application configuration, authentication, input processing, software components, and other potential vulnerabilities. OWASP also identifies insufficient resource and request restrictions as a separate API security risk.

Application and server logs retain information about errors and significant events. Monitoring makes it possible to detect issues after deployment and investigate the causes of incidents.

CMS platforms, frameworks, plugins, libraries, and server components are updated regularly. Before updating a commercial project, we create a backup and test key scenarios after installing the new version.

Dependencies are controlled during development. Every third-party library adds code and requires future maintenance, so project functionality determines the minimum necessary set of components.

We back up the database, project files, user uploads, and critical configuration elements. Backups are generated automatically and stored separately from the production version of the website.

Backup frequency depends on how frequently the data changes. A content-driven corporate website and an e-commerce project processing a continuous stream of orders require different backup intervals.

For business-critical systems, we separately define RPO — Recovery Point Objective, the acceptable amount of data loss, and RTO — Recovery Time Objective, the required recovery time. These parameters determine backup frequency and infrastructure configuration.

Before launch, we perform functional, responsive, integration, and technical testing. We check navigation, links, forms, validation, component states, mobile layouts, browsers, CMS functionality, and user roles. For e-commerce websites, we test search, filters, product pages, shopping cart, checkout and payment, delivery, and order creation.

Integration testing verifies data exchange with CRM, 1C, ERP, payment systems, and other APIs. We analyze transmitted data, responses to errors, and repeated processing of failed operations.

SEO testing covers HTTP status codes, redirects, canonical URLs, robots.txt, XML Sitemap, metadata, headings, Schema.org, indexing of technical pages, and internal links. Performance is analyzed on desktop and mobile devices. We check images, JavaScript, fonts, third-party services, and Core Web Vitals.

After launch, we connect Yandex Metrica, Google Analytics, and other systems required by the project. We configure events for form submissions, phone calls, messenger clicks, file downloads, registrations, adding products to the cart, starting checkout, and successful orders.

For e-commerce projects, we create an extended event funnel. Analytics tracks the user's journey from viewing a product to adding it to the cart, completing checkout, and making payment. This makes it possible to identify the stages with the highest conversion losses.

Search performance data is collected from Yandex Webmaster and Google Search Console. We analyze queries, impressions, clicks, landing pages, and indexing issues.

Development follows 8 main stages: research and architecture, prototyping, UX/UI design, frontend, backend and CMS, integrations, testing, and launch.

During the research stage, we define the product, target audience, functionality, traffic sources, content, and integrations. Architecture determines website sections, page types, user journeys, and the content model.

Prototypes define the content of key pages and interface scenarios. Once approved, we create the visual system and responsive layouts in Figma. Frontend development implements the interface and responsive behavior. Backend development creates the CMS, data model, business logic, and integrations. After all components are connected, we perform testing, technical SEO configuration, and analytics setup.

At launch, the project is transferred to the production server, and we connect the domain, SSL/TLS, analytics, and monitoring systems. The client's team receives access credentials and instructions for managing the website.

Landing page development starts from 20 business days. A corporate website starts from 30 business days. A product catalog website starts from 40 business days. An e-commerce website starts from 45 business days. Timelines depend on project objectives, technical specifications, and the speed of client approvals.

The project schedule is created after defining the number of unique templates, frontend and backend complexity, integrations, and content preparation requirements.

A corporate website with a standard CMS and a limited number of templates requires less development time than a portal with customer accounts, multiple user roles, documents, and integrations. Large projects are divided into stages with separate approval milestones.

The budget is based on the scope of research, UX/UI design, number of unique templates, frontend, backend, CMS, integrations, and testing.

Landing page — from RUB 120,000. Corporate website — from RUB 290,000. Product catalog website — from RUB 390,000. E-commerce website — from RUB 490,000.

The cost is also affected by 3D and WebGL, catalog architecture and filtering, customer accounts, user roles, 1C, CRM and ERP integrations, multilingual functionality, data migration, complex forms, and custom server-side logic.

Before development begins, we define the architecture, functionality, stages, timeline, and budget. Additional functionality receives a separate estimate before development begins.

Get a Quote

We use HTML, CSS, JavaScript, React, Vue.js, Next.js, PHP, Laravel, Python, Django, WordPress, 1C-Bitrix, MODX, MySQL, MariaDB, PostgreSQL, REST API, WebGL, and other technologies.

For corporate websites, the primary requirements are a convenient CMS, indexable architecture, high performance, and straightforward content management. For web applications, the focus shifts toward backend architecture, APIs, data models, user roles, and dynamic frontend development. Presentation-focused websites can add another technical layer through WebGL, 3D, animation, and complex visual compositions.

The technology stack is defined during the architecture stage. The architecture determines the role of each technology within the project and the scope of future technical support.

Big Fish is a web development agency bringing UX/UI designers, frontend and backend developers, project managers, and website architecture specialists together within one team.

UX/UI is designed in Figma. Frontend development uses HTML/CSS/JavaScript or a component-based stack. Backend development handles the CMS, database, APIs, and integrations. SEO requirements are incorporated into the architecture before publication. Testing covers the interface, mobile devices, functionality, integrations, performance, and technical indexing.

Each project receives unified technical documentation covering its architecture, stack, integrations, access credentials, and key settings. After launch, the client receives the source materials and access to management systems according to the contract. Turnkey website development covers the entire process from the first prototype to the production server.

After launch, we create new sections, landing pages, and functional modules. We expand catalogs, connect new APIs, improve frontend and backend functionality, and update CMS platforms and dependencies.

Technical support includes error monitoring, updates, backups, security, and integration reliability. For actively developing projects, we create a regular task backlog and release updates iteratively.

SEO development includes technical improvements, new landing pages, internal linking, and correction of indexing issues.

For existing websites, we perform technical audits covering architecture, CMS, frontend, performance, Core Web Vitals, mobile layouts, HTTP status codes, redirects, canonical URLs, sitemap, security, and integrations.

To estimate a project, we define the website type, architecture, number of unique templates, CMS, functionality, integrations, and design requirements. After the architecture stage, we prepare the scope of work, technology stack, timeline, and budget.

Big Fish provides the complete development cycle: research, architecture, prototypes, UX/UI design, frontend, backend, CMS, integrations, technical SEO, testing, and launch.