I'm looking for a self-maintaining, non-payware Linux. Actually, it doesn't necessarily need to be Linux at all, as long as it runs PostgreSQL and PHP in a stable manner.

Once installed, and PostgreSQL and PHP are on it, I want to never have to think about it existing again.

I want it to automatically detect, download and install any system patches and updates to the installed programs.

The only interaction I want to have with the machine is to SFTP into it, to transfer files to it, as if it were an account at some webhost rather than my own machine.

Some reasons for me wanting this are:

  1. Serious psychological stress/mental issues from 15+ years of babysitting servers.
  2. Lack of money and trust to pay for a "managed" server.
  3. Lack of trust to be able to pay for a webhost account. (Also, rarely any PostgreSQL support anyway, even if I could accept the risk.)
  4. Physical control.
  5. Several more practical issues which are important but hard to explain.

Even besides all those reasons, wouldn't anyone want this unless your hobby is specifically to use a computer for the sake of using a computer?

Please note that it doesn't count if there is some "optional mode" where it auto-updates, but which isn't reliable, and just breaks the server instead.

If this is still not available, what exactly is the reason for this, other than "we want it to be difficult" or "ensuring work for administrators"? I consciously kept the requirement extremely basic, and don't involve a million weird and exotic software. PHP and PostgreSQL. The two basic tools in my toolbox. Hammer and saw, basically.

Even just the stress alone from having to keep track of new updates/patches, and always be ready and able to log in and manually deal with it (what happens if I'm in an accident and wake up after an eight-month coma to find that my unpatched server is compromised?) would justify this a million times over in my mind. But coupled also with all the other reasons, such as people having no clue that you even need to update stuff (yes, this is really what the vast majority of people think about servers... myself included many years ago), I simply cannot understand how this is not a thing... if it isn't. It doesn't seem to be.

Please prove me wrong.

PS: I don't want to destroy this question by adding the further requirement that it has to run on my Raspberry Pi, but if it does, that is a huge bonus.

  • 9
    Would the trust issues regarding managed servers or webhost accounts not apply to unpaid distribution maintainers too? Nov 1, 2020 at 9:13
  • 8
    "extremely basic ... PHP and PostgreSQL" that's far from basic. It's like pretending that a smartphone is extremely basic, because it just makes calls and shows pictures you can slide with your finger ;-)
    – user313992
    Nov 1, 2020 at 9:53
  • 7
    "Zero maintenance" is a lie, and by the time entropy reveals the lie everyone who knew how to fix it will have moved on or forgotten, and entropy wins again. Nov 1, 2020 at 17:04
  • 11
    "If this is still not available, what exactly is the reason for this, other than "we want it to be difficult" or "ensuring work for administrators"?" - Projecting malevolence on OS vendors serves no purpose. It makes me wonder, is this an actual question, or just a rant?
    – marcelm
    Nov 1, 2020 at 18:31
  • 3
    @user414777: Absurd humour and rhetorical devices are all very well, but it should pretty clear why that part will go over badly with most readers. It’s like asking “Why can’t I get a car that never breaks down or needs maintenance? All I’m asking is for it to run smoothly like normal. If that’s not possible, what is the reason, apart from creating work for mechanics?” Naïve questions asked politely are fine; naïvety plus an attitude of apparent entitlement is less pleasant to deal with.
    – PLL
    Nov 1, 2020 at 23:57

8 Answers 8


The short answer is no.

Pin your packages to a specific version that you consider stable and feature-complete, but then also enable automatic updates so you can still receive backported security updates. This minimizes compatibility issues while maximizing your coverage of vulnerability.

The reason there is no magic Linux distribution (or server, software, car, factory, healthcare system...) is not to create work and frustration, but because the operating environment is complex and dynamic. You cannot have stability and security for free and also with no effort. Someone, somewhere, must do something.

From what I can tell, your requirements are stability, security, minimal user intervention (or less), and free.

There are only four options:

  1. Never update, and feel confident that now that the server is stable it will remain stable. This assumes that global standards in software and hardware never change in the lifetime of the server, and that no new vulnerabilities occur. Stability with no involvement
  2. Always update, automatically. You will also still have to trust software maintainers to correctly create and push updates. Security with no involvement
  • Version pinning with security backports is a slight modification in an attempt to integrate the best of both worlds. Mostly stable, mostly secure, minimal involvement
  1. Make your own judicious updates based on your confidence in maintainers and your understanding of current events. You know you, so you can best tailor the server to your needs. Most stable, most secure, most involvement
  2. Pay someone to do #3 for you. This is the most complete answer but in return for that you have to pay (and trust the provider, like you said). Most stable, most secure, least involvement, requires money and trust

Every option involves some kind of compromise. You cannot have all your requirements. But depending on your tolerance (and where you are willing to compromise) any of them could resolve your issue on any number of server distributions.

  • 1
    I think the solution to OP's question would mostly fall under 2. The issue with that is that it requires a few people - not many - to build a FOSS (likely unpaid, 'company'-free) technical mechanism to remove trust AND dependence on maintainers. How would such a mechanism look like? Finding possible answers to this question is where the work would start (not somewhere afterwards). I'd say it requires solutions to the 4 bullet-points here & authenticated assessment by reliable, reputable individuals & orgs + reliable use/rate metrics & ...
    – mYnDstrEAm
    Nov 1, 2020 at 22:20
  • I don't necessarily disagree, but I think the biggest barrier is the aspect of trust. Even looking at the bullets you linked, reproducibility is irrelevant if you don't have the time to verify yourself (OP puts a premium on time) and signature and audit is irrelevant if you don't have complete confidence in the author (OP puts a premium on trust). The question is difficult to answer because it can be reduced to wanting maximum control with minimum work, but at some point one must be ceded to the other.
    – dcwaters
    Nov 18, 2020 at 0:31
  • On that note, since my entire answer could be summed up as "you cannot have all of your requirements," I think even in light of your comment there are still compromises that would have to be made, and OP's unwillingness to compromise in any area is why the short answer is "no."
    – dcwaters
    Nov 18, 2020 at 0:33
  • These are good points but I think "signature and audit is irrelevant if you don't have complete confidence in the author" - code-audits etc do not require "complete confidence" in those auditing. E.g. auditors would have reputation & trust to uphold even while the code & their results are public. Authenticated assessment etc could also include large numbers of people. "Verifying yourself" is imo an absurdly outdated approach. Furthermore, OP seems to be asking for how this could work in practice, not how this could become absolutely foolproof in theory. It could - even with less compromise
    – mYnDstrEAm
    Nov 18, 2020 at 8:36

Others have already answered whether there is "such a thing". Let's try to cover this part as well:

If this is still not available, what exactly is the reason for this, other than "we want it to be difficult" or "ensuring work for administrators"? I consciously kept the requirement extremely basic, and don't involve a million weird and exotic software.

Designing and implementing computer hardware and software is still a very immature discipline. Consider that many of the trades and crafts practiced by humans are thousands of years old. In contrast, the first electronic computers were made less than 100 years ago. That's a blip in historical terms.

On top of that, modern computer software is among the most complex things ever created by humans. We are still figuring out how to create good software and probably have a very long way to go. Most of the programs we write are riddled with bugs, and when we make changes to them, we usually introduce new bugs. In this Internet age, some of those bugs are remotely exploitable. (Sadly, it seems that we are finding new ways to exploit bugs faster than we are finding ways of writing software with fewer bugs.)

So no, the developers of your operating system (as well as PHP and Postgres) are not deliberately thinking of ways to "make administration more difficult" or to ensure that you need to keep patching bugs. Far from it. What they are doing is just really, really hard.

  • +1 Designing and implementing computer hardware and software is still a very immature discipline. Nov 2, 2020 at 0:10

I want to never have to think about it existing again.

"Never" is a long time. Consider that all of following security vulnerabilities, integrating and testing patches, and possibly backporting them to old versions of the software to be distributed for your OS takes time and effort. The backporting part may also get increasingly harder as time passes, since others doing the same job may start dropping support for older versions as their users move onto newer versions.

You're basically asking for someone to do all that work for you, for free, for all eternity. Or maybe just for a lifetime, but even 5 to 10 years can be a quite long time in software.

That said, at least Debian and Ubuntu have Long-Term Support versions with 5 years of (security) updates. Using them with automatic updates (the unattended-upgrades package) might be relatively low-effort path to get approximately what you want.

Do also not that a computing system isn't just software. With a 5 to 10 year time-frame, you need to prepare for hardware issues too.

wouldn't anyone want this unless your hobby is specifically to use a computer for the sake of using a computer?

Perhaps. And I would also want a pony. Relatively normal people also change their smartphone/car/whatever to a newer one every once in a while, even if they don't do Android developing or engine overhauls for a hobby. Or take care of maintenance of their house, even though they really only just want to live there, etc.

If this is still not available, what exactly is the reason for this, other than "we want it to be difficult" or "ensuring work for administrators"?

Even if we don't want it to be difficult, an operating system isn't a particularly simple system, there's a number of individual interacting pieces. And while making them work together is one thing, smooth automatic updates that work, always, 100 % of the time, or even with a few nines, are another thing entirely. While your demands might be relatively simple, many others would want an HTTP server with their PHP and database. Or something else entirely. A general purpose OS would need to make those work, too; there might not be much market for just your particular use-case. And did I already point out that you asked for this for free?

Even just the stress alone from having to keep track of new updates/patches, and always be ready and able to log in and manually deal with it

Yes, well. This is a bit off-topic for unix.SE, but I believe many people pay money to make that sort of things into Somebody Else's Problems. I.e. they pay their mechanic to make their car run smoothly, or get another one when the issues start to stack up too much. The tradeoff of spending money just to get rid of the stress of having to do something -- something you could do yourself, can often be well worth it.

  • 2
    Best answer here. OP will probably be fine with an LTS distribution with automatic updates.
    – Michael
    Nov 2, 2020 at 7:01

Well, if there were such thing, it would be a huge revolution. Suddenly there is no maintenance to do in all the tech! But it's not possible, I'm afraid. Even if you automate everything, there still is a need to check from time to time e.g. whether backups are doing well, if there is no big dust plug in server's vents, and other hardware issues. You need to check for totally unexpected behaviour, which is by definition impossible to predict. Someone's gotta service user complaints, if there are any users other than you.

Security patches however, can be automated easily with this: https://wiki.debian.org/UnattendedUpgrades Debian stable is stable enough to not go insane after some security patch. Actually it's so stable, that i'm using Debian testing on all my linux devices, because I can't stand some years-old software like qBittorrent, and still only ever had trouble with touchpad driver once after an update, both of which are not applicable for your use-case I believe.

So please, go ahead and give unattended-upgrades a try. It won't make your system bulletproof, but nothing will, really. Some links that popped out of web search:


How is unattended-upgrades started and how can I modify its schedule?



There are many free distributions available. You can choose these, but automation systems are paid because they require technical details. If you want to deal with these details, open source provides it.

As far as I understand, you are not satisfied with the services you have received with money today and you want to do it yourself without any charge. Actually this is possible but challenging. It is possible to create a free server with Amazon Web Services (AWS) and install PHP and MySQL on this server. By creating a cron on your server for automatic updating, you can perform all automatic operations. For example, if you enable the auto update option every 5 days, everything on your server will be updated. This is actually very simple to do, but some updates are not stable. When you upgrade to an unstable update, you may encounter problems with the operation of your web page. For this, you can keep the update time in a wide date range. For example, once a month, not every 5 days.

It would be more accurate to use new technologies such as Docker. Because docker and images are constantly being developed by many developers. Security is another part of the job. You may not be able to keep track of vulnerability notifications. Instead, Docker, Xampp, Lampp etc. applications do this for you and you can safely continue using your system. Because most of the teams that develop these applications have Cyber ​​Security Operations.

I can recommend Bitnami to you in this regard. You may hesitate, but Bitnami and many other similar apps stick to their published policies. Currently, Bitnami offers KubeApps with its Kubernetes infrastructure. With this application, you can easily configure many applications, and you can be sure of issues such as auto updates and patches / vulnerabilities.

If your goal is to host a web page in a healthy way, CloudLinux + cPanel + Imunify360 can be preferred as an easier and paid solution. Although it has a fee, I can say the best in this regard, as their focus is on web page hosting.

As I mentioned, there are both manual and automatic configurations. In your manual configuration, you make an effort at first, but it is possible to connect it to automatic.

To configure manually, you can search:

If you have questions, you can add them as comments.


It should be pointed out that updating software sometimes involves deeper changes like changes in the configuration files or conflicts with other libraries, such changes then have to be reviewed and arbitrated manually.

What you describe seems to be an unattended system. Your need is understandable. But if you fully rely on automation and never check manually, then you cannot be sure that the updates are actually taking place smoothly and completely. I would suggest setting up a cron of some sort and send the output of the job to yourself by E-mail for review.

But the idea of being blind and completely ignoring the background updates taking place is not realistic I'm afraid. Even the most basic car needs maintenance too, someone qualified has to have a look at it once in a while.


You could use coreos as a host. It has automatic updates, but you shouldn't add software to it as it's meant to be (mostly) immutable to facilitate automatic updates.

Then, you can run your applications in podman containers. The missing piece is keeping the podman images up-to-date. AFAIK, there is no preexisting tool for it, but dockerfiles and a cronjob could do the trick (e.g. pull the latest stable image of nginx/postgresql/...).


This is challenging your premise.

You can not expect an army of volunteers to have the discipline and reliability and perform the level of testing that a company with a fine-tuned process and rigorous quality control can provide. Crowds may be better than large companies at innovation, because they lack an inflexible process. But this forte is also their weakness.

Therefore my suggestion would be to run Windows or macOS. Yes, they are not free, but their cost is a modest one-time payment which is quickly dwarfed by the running cost of a server.

Today's consumer Windows as well as macOS are technically server operating systems. Most people will agree that Windows maintenance (for a single machine that is) needs only minimal intervention, and that hickups are very rare. From what I hear the same is true for macOS. (By the way: Good job, Microsoft and Apple, really. None of this was true 25 years ago, and it's one reason that you are still in business.)

Of course "maintenance free" is an illusion. Even "minimal maintenance" is probably only true until the next OS or PHP or Database major release. But it's the solution I'd sleep best with.

Not the answer you're looking for? Browse other questions tagged .