FORKEL is an online store project for electrical products that we are developing from scratch, systematically laying the groundwork for the future product catalog, product selection, and order processing. In this article, we’ll explain where the project begins, what technical solutions we’re considering, and why the first step was to set up a local development environment.
Where Does FORKEL Begin?
Developing an online store involves more than just creating web pages and product listings. Behind the user interface must be a content management system, a catalog structure, business logic, integrations with accounting systems, order processing mechanisms, and the infrastructure on which all of this will run.
That is why we do not start by trying to implement the entire store all at once. In the initial phase, it is important to define the direction of development, lay the groundwork for the project, and establish a process in which individual solutions can be tested before they become part of a larger system.
FORKEL is conceived as an online store for electrical products: outlets, switches, and related items. However, the project’s goal is not to be limited to a simple product showcase. Moving forward, we will need to develop user-friendly navigation through the product lineup, present product specifications, create product selection scenarios, and map out the user’s journey from discovering a product to placing an order.
The project is currently in the early stages of development. We are working on a prototype of the user interface and are separately setting up the backend environment. A full-featured product catalog, shopping cart, order management, and external integrations have not yet been implemented.
Why We Started with the Technical Basics
At the outset, it’s important to break things down into several tasks:
- set up an environment in which the server-side components can be run and tested;
- define the foundation of the future website and the platform’s capabilities;
- develop the page structure and user scenarios;
- gradually transition from prototypes to working functionality;
- test each technical solution before the subsequent development stages rely on it.
This approach helps distinguish visual design from actual implementation. For example, an interface element may be present in a prototype, but that does not necessarily mean it is connected to a database, a shopping cart, or server-side logic. We will take this distinction into account in both development and project documentation.
Technological Foundation
1C-Bitrix: Website Management, “Small Business” edition, has been selected as the website management platform. This will serve as the foundation for the future online store, upon which we will build the catalog and e-commerce workflows.
Docker is used to set up the backend. The local environment allows you to define the necessary services and startup parameters in configuration files, rather than relying solely on individual settings on your work computer.
While setting up the environment, we worked with the Docker Compose configuration, the PHP container, PHP settings, and the Nginx configuration. We also prepared an example of environment variables and documentation on how to run the application.
We paid special attention to project configuration and working with Git: local environment settings and secret values must not accidentally end up in the repository. To ensure this, you need to configure the .gitignore file correctly, store the configuration example separately, and check which files are already being tracked by Git.
It is important to understand the limitations of the current result: the local environment has been set up and, based on the test results, is functioning properly. This does not yet mean that the entire website or the online store’s functionality has already been deployed and is ready for use.
How the project will unfold
Further work can be broadly divided into several areas.
1. Interface and User Scenarios
First, you need to work out the main pages and ways to interact with the site: the home page, catalog, product detail pages, search, contact page, and other sections. Prototypes allow you to test the structure and visual presentation before implementing full-fledged business logic.
2. Backend and Platform
The next major step is to develop the server-side components on the chosen platform, define the project structure, and implement the functionality required for the store to operate.
3. Catalog and Product Information
For electrical products, specifications, model variants, and accurate presentation of the product lineup are important. Therefore, the structure of product data and the rules for displaying it must be developed separately.
4. Integration and Order Processing
In the future, we will need to consider data exchange with 1C, as well as the integration of payment solutions and delivery services. For payments, we are considering UKassa and Alfa-Bank. The specific integration plan, the set of modules, and the configuration settings will be determined at the appropriate stage.
All of these areas are still part of our development plans. We will not describe them as implemented features until they have actually been implemented and tested.
Why We’ll Be Discussing the Development Process Step by Step
Instead of one long post about the project, we plan to break down individual decisions as they arise.
This will allow us to show not only the final result but also the development process: what challenges arose, what options were considered, why a particular approach was chosen, and how the result was verified.
In our technical documentation, we will distinguish between confirmed facts and assumptions or plans. If a particular feature currently exists only as a prototype, we will state that clearly. If integration has not yet begun, we will not give the impression that it is already up and running.
This is especially important for a project in its early stages: the architecture, interface, and functionality change as requirements are refined, and the technical history should reflect the actual state of development.
What’s next?
The first practical step was setting up a local backend environment. Now we can take a closer look at its structure: which services are used, how they are connected, where the settings are stored, and how the project is launched.
In the next article, we will take a closer look at the FORKEL Docker environment—from the structure of the configuration files to the startup process and health checks. This will be an analysis of a specific implementation, rather than a generic guide detached from the actual project.
FORKEL is just beginning its journey from the design phase to a fully functional online store. In this series, we will document that journey step by step—from the technical foundation to the implementation of user and commercial scenarios.