Skip to content
Try the admin demo 0
The argument

Why not WordPress, Joomla or OpenCart

Not because they are bad software. Because of how much of them you inherit, how little of it anyone has read, and what we found when we opened one up.

The number that started this

We took over a Joomla site last year — a community organisation, a few hundred articles, a photo archive. Ordinary work. Before touching anything we counted what was there:

15,663 files. 8,495 of them PHP. 1,284,885 lines of code.

That site is now on ModularPress, with every article, every gallery and every old address still answering. It is 462 files, 299 of them PHP, 51,664 lines. Same content, same visitors, a twenty-fifth of the code.

The 1.23 million lines that went were not doing nothing. They were doing things that site never asked for, from thousands of authors it never chose, on a schedule it did not set. Every one of them was also a place where something could go wrong.

And something had

A cleanup that September found about 1,170 malicious files on that installation by signature. That is the part a scanner can do, and it is the part people mean when they say a site was cleaned.

Two more were not found, because they carried nothing to find. Identical files, planted on 1 July at 14:26, sitting in two ordinary-looking directories. Each was a complete remote file manager — list, read, write, upload, delete, rename, change permissions — behind the password 123456. No eval, no base64, no obfuscation of any kind. That is precisely why every signature sweep walked straight past them.

They were used at the start of September from a single address abroad. The retained logs begin at the end of August, so their first two months are simply unaccounted for. Nobody can say what was read.

And the detail that ought to stay with you: they had been committed into the repository as part of the cleaned production baseline. The file that was meant to be the record of what the site is, was carrying the back door.

The check that passed the whole time

That site had an automated check for exactly this. It looked for eval() and system() wrapped around request input — the shape a webshell has in every tutorial. It passed on every run while two working back doors sat in the tree.

It now asks a different question: does this file read what the visitor sent and write to disk or execute? That describes a back door without describing any particular one, and it catches both of those two when run against the real samples. Legitimate extensions do both as well, so six reviewed files are listed by name and anything new fails the build.

The lesson is not that the first check was lazy. It is that a rule written to match what you have seen will keep passing on what you have not.

It is not only Joomla

On the same server, a shop running OpenCart had a webshell of its own, sitting inside the directory where extensions keep their controllers — the one place nobody looks, because that is where third-party code is supposed to be.

WordPress we can measure without having been hit. One site of ours has never run it, not for a day. Over 26 days its access log holds 57,950 requests, and 3,611 of them ask for WordPress: the installer, the login page, the admin directory, the JSON endpoints. One request in sixteen. Joomla paths, 51. OpenCart paths, none.

That is not an opinion about WordPress. It is what the attack economy has decided to spend its time on, measured at our own door, and it is the tax every site on that platform pays whether or not anything is wrong with it.

One person who has read it, instead of thousands who have not

This is the part that actually matters, and it is not about lines of code.

On a platform with an extension ecosystem, your site is assembled from the work of hundreds of authors you never met, whose interests are not yours, some of whom stopped maintaining their work years ago and did not say so. When one of them has a flaw, every site using it has that flaw the same morning — and the list of which sites those are is public.

ModularPress is 51,664 lines written by one developer who has read all of them. When something behaves oddly there is a file that does that thing, and it can be opened. When a mistake is found, it becomes a test, so it cannot come back quietly. Nothing arrives in it because somebody else shipped a release.

What this costs, because it does

One developer is also one point of failure, and it would be dishonest to sell that as a pure advantage. What answers it is the same thing that makes the rest work: the system is small enough for the next person to read. No framework to learn first, no plugin layer to reverse-engineer, and a repository where the reasoning behind each decision is written down beside the code.

There is also no shop of ready-made extensions. What a platform gives away for free is built here instead, which takes longer and costs more at the start. If what you need is a plugin that already exists, one of those platforms is the right answer and we will say so.

And none of this makes a site unbreakable. Smaller and read is not the same as perfect. It means fewer doors, all of them known, and one person who can tell you what is behind each — which is more than most sites can say after a clean-up.

The whole argument, in five lines

  • The same site: 1,284,885 lines of PHP before, 51,664 after — with nothing lost.
  • About 1,170 malicious files found by signature, and two that no signature could find.
  • Those two held a remote file manager behind the password 123456, for at least two unaccounted months.
  • One site of ours that has never run WordPress is asked for WordPress once every sixteen requests.
  • Fewer moving parts, all of them read by the person responsible for them.