Manifesto. Our Principles

Several decades ago, computer hardware was much less powerful (by today’s standards) and far more minimalistic. For example, instead of the 4 GB of RAM that is now considered a minimum, systems often had as little as 64 MB. And yet, developers managed to build software that solved the tasks they faced at the time. They optimized code, tracked down memory leaks, and removed unnecessary or resource-heavy parts.

Over time, as processors and storage evolved, hardware became dozens or even hundreds of times more powerful. The need for careful optimization faded. An extra loop here, an additional module call there, another library added — on modern machines, an extra second of loading time is barely noticeable. But behind this excess of often unnecessary code that consumes CPU and memory, there is also a question of security.

Modern development has largely moved away from refining existing — often flawed — code, and instead focuses on writing new code on top of old code to fix its issues. This “patching” approach works only up to a point, until new vulnerabilities are discovered and developers are forced to apply yet another patch.

This is the cycle we live in today. We believe this path is flawed and ultimately a dead end.

We take a different approach. We build clean, well-thought-out, and reliable code. No unnecessary complexity. No fragile layers. No dependence on endless updates over legacy systems. Instead of wrapping old, vulnerable code in new layers, we focus on writing it correctly from the start — and refining it over time.

One might argue: new technologies bring new risks, so updates are inevitable. Our answer is: not necessarily. Most modern technologies are still based on fundamental principles — authentication, file handling, and internet protocols — especially when it comes to website development.

Take admin authentication as an example. What exactly needs constant updating if passwords are securely stored as hashes outside the public web directory? Brute-forcing such a password would take an impractical amount of time — even with unlimited attempts. In our case, attempts are limited: five failed logins trigger a one-minute timeout.

Of course, any system can be compromised due to human factors. A password written on a sticky note, or a hacked email account — these risks always exist. But here we are speaking strictly about the technical security of our code.

The same principle applies to how we access and serve data. Content is stored on the server as simple text files. When a user requests a page, our script reads the file, converts it into HTML, and delivers it to the browser. Potential attack vectors through request manipulation are minimized. No databases, no unnecessary layers. What is simple should remain simple — secure and efficient.

We are not against databases. Where they are truly needed — large e-commerce platforms, systems with many authenticated users (such as social networks) — they are essential. But for a website with ten, fifty, or even a hundred pages that simply presents services, pricing, and contact information, using a database is, to put it mildly, excessive.

In summary, we stand for clarity, simplicity, and maximum security in code. This is our core principle: eliminate unnecessary complexity, reduce the load on computing resources, and build systems that are fast, reliable, and durable. Simplicity and security create speed and longevity.