kilfor.ru has already been analyzed a bit better from a technical side, and the first findings look promising for the upcoming modernization.

First, the current project is already packaged in Docker. This means the existing system runs in a reproducible environment and does not need to be rescued from an unknown server configuration before starting work on a new frontend. For an old project with extensive internal logic, this significantly reduces operational risk.

Second, the MODX part of the project is not built as a standard site using a mix of templates, chunks, and snippets. It is based on custom components by Nikolay Fi1osof, which initially separated presentation, application logic, and debugging.

modxSmarty is responsible for the presentation layer and allowed building the frontend on Smarty without binding the entire interface to the standard MODX parser.

modxSite was used as the main logical and API layer of the project. A significant portion of operations was built around processors and xPDO, meaning they could be called independently of a specific template and interface.

Console makes it possible to execute PHP code directly inside the authorized MODX Manager, test processors, view actual responses, and explore the behavior of the existing system in its native runtime.

It is the combination of these three components that is currently of particular interest. If Kilfor's actual code consistently adheres to this architecture, the new frontend will not have to be built on top of a chaotically tangled mix of templates and business logic. The old Smarty interface can simply be replaced with a new one, and existing processors can be used as a basis for backend interaction.

For now, this is a working hypothesis rather than a statement.

Our current theory is that an architecture properly laid down in the distant past can become the key to a simpler and less risky update in the future. Kilfor provides a rare opportunity to test this idea not on a toy example, but on a system that has been running for many years and contains a significant amount of application logic.

The practical test will be very simple in concept: how easily the new frontend can use existing backend operations without having to rewrite them from scratch. If the processors turn out to be genuinely well-separated from the old presentation layer, it will confirm that architectural decisions made more than ten years ago directly reduce the cost and risk of modernization today.

If the actual code reveals that some logic is still heavily tied to Smarty templates, snippets, or other layers of the old frontend, that will also be an important result. Then it will become clear precisely where the historical architecture stood the test of time and where it will require additional separation.

This concept will be updated as the technical analysis of the project progresses and the hypothesis is tested in practice.

The general picture and current state of the project are maintained in the concept Kilfor — modernization of a legacy MODX project.